fef
/
gaybuild
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

ast: remove unnecessary qualifier

Browse Source
main
anna 2 years ago
parent 311059449a
commit cb32a2c7e2
Signed by: fef
GPG Key ID: EC22E476DC2D3D84
1 changed files with 56 additions and 56 deletions
Show Stats Download Patch File Download Diff File

112
src/ast/mod.rs
Unescape Escape View File

@ -5,7 +5,7 @@ use crate::lex::token;
use crate::lex::token::Token;
use crate::lex::Lexer;
use crate::ast::tree::{File, Operator};
use crate::ast::tree::{File, Node, Operator};
use std::fs;
use std::io;
@ -25,7 +25,7 @@ struct Parser {
filename: String,
}
pub fn parse(filename: String) -> io::Result<Result<tree::Node, Error>> {
pub fn parse(filename: String) -> io::Result<Result<Node, Error>> {
let raw: String = fs::read_to_string(filename.clone())?;
let mut p = Parser::new(filename, raw);
Ok(p.parse_file())
@ -53,7 +53,7 @@ impl Parser {
/// File
/// : Statement [ File ]
/// ```
pub fn parse_file(&mut self) -> Result<tree::Node, Error> {
pub fn parse_file(&mut self) -> Result<Node, Error> {
let mut nodes = Vec::new();
self.scope.push(Scope::File);
@ -62,7 +62,7 @@ impl Parser {
}
self.scope.pop();
Ok(tree::Node::File(
Ok(Node::File(
token::Position {
file: self.filename.clone(),
line: 0,
@ -84,7 +84,7 @@ impl Parser {
/// | TypeStatement
/// | ExpressionStatement
/// ```
fn parse_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_stmt(&mut self) -> Result<Node, Error> {
let token = self.lexer.peek_or_err()?;
match token.kind {
token::Kind::BreakKeyword => self.parse_break_stmt(),
@ -107,11 +107,11 @@ impl Parser {
/// BreakStatement
/// : "break" ";"
/// ```
fn parse_break_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_break_stmt(&mut self) -> Result<Node, Error> {
let break_keyword = self.lexer.expect_kind(token::Kind::BreakKeyword)?;
self.assert_scope(Scope::Loop)?;
self.lexer.expect_kind(token::Kind::Semi)?;
Ok(tree::Node::Break(break_keyword.pos))
Ok(Node::Break(break_keyword.pos))
}
/// ```notrust
@ -121,7 +121,7 @@ impl Parser {
/// StatementList
/// : Statement [ StatementList ]
/// ```
fn parse_block_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_block_stmt(&mut self) -> Result<Node, Error> {
let mut nodes = Vec::new();
let obrace = self.lexer.expect_kind(token::Kind::OBrace)?;
while let Some(result) = self.lexer.peek() {
@ -133,37 +133,37 @@ impl Parser {
_ => nodes.push(self.parse_stmt()?),
}
}
Ok(tree::Node::Block(obrace.pos, nodes))
Ok(Node::Block(obrace.pos, nodes))
}
/// ```notrust
/// ReturnStatement
/// : "return" Expression ";"
/// ```
fn parse_return_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_return_stmt(&mut self) -> Result<Node, Error> {
self.assert_scope(Scope::Function)?;
let return_keyword = self.lexer.expect_kind(token::Kind::ReturnKeyword)?;
let expr = self.parse_expr(&[token::Kind::Semi])?;
Ok(tree::Node::ReturnStmt(return_keyword.pos, Box::new(expr)))
Ok(Node::ReturnStmt(return_keyword.pos, Box::new(expr)))
}
/// ```notrust
/// TargetStatement
/// : "target" Expression BlockStatement
/// ```
fn parse_target_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_target_stmt(&mut self) -> Result<Node, Error> {
self.assert_scope(Scope::File)?;
self.assert_scope_not(Scope::Target)?;
self.scope.push(Scope::Target);
let target_keyword = self.lexer.expect_kind(token::Kind::TargetKeyword)?;
let name_token = self.lexer.expect_kind(token::Kind::Ident)?;
let name = tree::Node::Ident(name_token.pos, name_token.raw);
let name = Node::Ident(name_token.pos, name_token.raw);
let children = self.parse_block_stmt()?;
self.scope.pop();
Ok(tree::Node::make_target_stmt(
Ok(Node::make_target_stmt(
target_keyword.pos,
name,
children,
@ -174,20 +174,20 @@ impl Parser {
/// DependStatement
/// : "depend" Expression ";"
/// ```
fn parse_depend_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_depend_stmt(&mut self) -> Result<Node, Error> {
self.assert_scope(Scope::Target)?;
self.scope.push(Scope::DepList);
let depend_keyword = self.lexer.expect_kind(token::Kind::DependKeyword)?;
let rvalue = self.parse_expr(&[token::Kind::Semi])?;
self.scope.pop();
Ok(tree::Node::DepList(depend_keyword.pos, Box::new(rvalue)))
Ok(Node::DepList(depend_keyword.pos, Box::new(rvalue)))
}
/// ```notrust
/// IfStatement
/// : "if" "(" Expression ")" BlockStatement [ "else" BlockStatement ]
/// ```
fn parse_if_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_if_stmt(&mut self) -> Result<Node, Error> {
let if_keyword = self.lexer.expect_kind(token::Kind::IfKeyword)?;
self.lexer.expect_kind(token::Kind::OParen)?;
let condition = self.parse_expr(&[token::Kind::CParen])?;
@ -197,7 +197,7 @@ impl Parser {
} else {
None
};
Ok(tree::Node::make_if_stmt(
Ok(Node::make_if_stmt(
if_keyword.pos,
condition,
then_block,
@ -209,14 +209,14 @@ impl Parser {
/// WhileStatement
/// : "while" "(" Expression ")" BlockStatement
/// ```
fn parse_while_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_while_stmt(&mut self) -> Result<Node, Error> {
let while_keyword = self.lexer.expect_kind(token::Kind::WhileKeyword)?;
self.scope.push(Scope::Loop);
self.lexer.expect_kind(token::Kind::OParen)?;
let condition = self.parse_expr(&[token::Kind::CParen])?;
let body = self.parse_block_stmt()?;
self.scope.pop();
Ok(tree::Node::make_while_stmt(
Ok(Node::make_while_stmt(
while_keyword.pos,
condition,
body,
@ -227,7 +227,7 @@ impl Parser {
/// ForStatement
/// : "for" "(" [ Expression ] ";" [ Expression ] ";" [ Expression ] ")" BlockStatement
/// ```
fn parse_for_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_for_stmt(&mut self) -> Result<Node, Error> {
let for_keyword = self.lexer.expect_kind(token::Kind::ForKeyword)?;
self.scope.push(Scope::Loop);
self.lexer.expect_kind(token::Kind::OParen)?;
@ -245,7 +245,7 @@ impl Parser {
let exec = exprs.pop().unwrap();
let condition = exprs.pop().unwrap();
let setup = exprs.pop().unwrap();
Ok(tree::Node::make_for_stmt(
Ok(Node::make_for_stmt(
for_keyword.pos,
setup,
condition,
@ -258,14 +258,14 @@ impl Parser {
/// SetStatement
/// : "set" AssignmentExpression ";"
/// ```
fn parse_set_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_set_stmt(&mut self) -> Result<Node, Error> {
self.assert_scope(Scope::File)?;
let set_keyword = self.lexer.expect_kind(token::Kind::SetKeyword)?;
let expr = self.parse_expr(&[token::Kind::Semi])?;
match expr {
tree::Node::BinaryExpr(_, expr) => {
Node::BinaryExpr(_, expr) => {
if expr.op == Operator::Eq {
Ok(tree::Node::make_set_stmt(
Ok(Node::make_set_stmt(
set_keyword.pos,
*expr.lhs,
*expr.rhs,
@ -285,31 +285,31 @@ impl Parser {
/// TypeStatement
/// : "type" Expression ";"
/// ```
fn parse_type_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_type_stmt(&mut self) -> Result<Node, Error> {
let type_keyword = self.lexer.expect_kind(token::Kind::TypeKeyword)?;
self.assert_scope(Scope::Target)?;
let expr = self.parse_expr(&[token::Kind::Semi])?;
Ok(tree::Node::TypeStmt(type_keyword.pos, Box::new(expr)))
Ok(Node::TypeStmt(type_keyword.pos, Box::new(expr)))
}
/// ```notrust
/// SourceStatement
/// : "source" Expression ";"
/// ```
fn parse_source_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_source_stmt(&mut self) -> Result<Node, Error> {
let source_keyword = self.lexer.expect_kind(token::Kind::SourceKeyword)?;
self.assert_scope(Scope::Target)?;
self.scope.push(Scope::SourceList);
let source = self.parse_expr(&[token::Kind::Semi])?;
self.scope.pop();
Ok(tree::Node::SourceList(source_keyword.pos, Box::new(source)))
Ok(Node::SourceList(source_keyword.pos, Box::new(source)))
}
/// ```notrust
/// ExpressionStatement
/// : Expression ";"
/// ```
fn parse_expr_stmt(&mut self) -> Result<tree::Node, Error> {
fn parse_expr_stmt(&mut self) -> Result<Node, Error> {
self.parse_expr(&[token::Kind::Semi])
}
@ -320,7 +320,7 @@ impl Parser {
/// | UnaryExpression
/// | PrimaryExpression
/// ```
fn parse_expr(&mut self, terminators: &[token::Kind]) -> Result<tree::Node, Error> {
fn parse_expr(&mut self, terminators: &[token::Kind]) -> Result<Node, Error> {
self.assert_scope(Scope::File)?;
let expr = if let Some(result) = self.lexer.peek() {
let token = result?;
@ -356,7 +356,7 @@ impl Parser {
fn parse_assignment_expr_or_higher(
&mut self,
terminators: &[token::Kind],
) -> Result<tree::Node, Error> {
) -> Result<Node, Error> {
// we speculate on this being an assignment expression, so we need to
// be able to undo our work in case this speculation doesn't hold true
// so parse_binary_expr_or_higher() can do its thing
@ -368,7 +368,7 @@ impl Parser {
let op_token = self.lexer.require_next()?;
let op = Operator::from_token(&op_token)?;
let rhs = self.parse_binary_expr_or_higher(terminators)?;
return Ok(tree::Node::make_binary_expr(op_token.pos, lhs, op, rhs));
return Ok(Node::make_binary_expr(op_token.pos, lhs, op, rhs));
} else if token.kind.binary_op_precedence().is_some() {
// shoot, this wasn't an assignment, all of our work was useless
self.lexer.restore(bookmark);
@ -396,7 +396,7 @@ impl Parser {
fn parse_binary_expr_or_higher(
&mut self,
terminators: &[token::Kind],
) -> Result<tree::Node, Error> {
) -> Result<Node, Error> {
let mut lhs = self.parse_unary_expr_or_higher()?;
while let Some(Ok(token)) = self.lexer.peek() {
@ -408,7 +408,7 @@ impl Parser {
let op = Operator::from_token(&token)?;
self.lexer.next();
let precedence = token.kind.binary_op_precedence().unwrap();
lhs = tree::Node::make_binary_expr(
lhs = Node::make_binary_expr(
token.pos,
lhs,
op,
@ -443,7 +443,7 @@ impl Parser {
&mut self,
precedence: u32,
terminators: &[token::Kind],
) -> Result<tree::Node, Error> {
) -> Result<Node, Error> {
let mut lhs = self.parse_unary_expr_or_higher()?;
while let Some(Ok(token)) = self.lexer.peek() {
@ -451,7 +451,7 @@ impl Parser {
if new_precedence > precedence {
let op = Operator::from_token(&token)?;
self.lexer.next();
lhs = tree::Node::make_binary_expr(
lhs = Node::make_binary_expr(
token.pos,
lhs,
op,
@ -475,14 +475,14 @@ impl Parser {
/// UnaryOperator
/// : "!" | "-"
/// ```
fn parse_unary_expr_or_higher(&mut self) -> Result<tree::Node, Error> {
fn parse_unary_expr_or_higher(&mut self) -> Result<Node, Error> {
if let Some(result) = self.lexer.peek() {
let token = result?;
if token.kind == token::Kind::Bang || token.kind == token::Kind::Minus {
self.lexer.next(); // consume unary operator token
let op = Operator::from_token(&token)?;
let expr = self.parse_primary_expr()?;
return Ok(tree::Node::make_unary_expr(token.pos, op, expr));
return Ok(Node::make_unary_expr(token.pos, op, expr));
}
}
self.parse_primary_expr()
@ -513,7 +513,7 @@ impl Parser {
/// MemberExpression
/// : PrimaryExpression "." PrimaryExpression
/// ```
fn parse_primary_expr(&mut self) -> Result<tree::Node, Error> {
fn parse_primary_expr(&mut self) -> Result<Node, Error> {
let token = self.lexer.require_next()?;
match token.kind {
token::Kind::OParen => {
@ -521,7 +521,7 @@ impl Parser {
self.parse_primary_expr_rest(expr)
}
token::Kind::Ident => {
let ident = tree::Node::Ident(token.pos, String::from(token.raw));
let ident = Node::Ident(token.pos, String::from(token.raw));
self.parse_primary_expr_rest(ident)
}
token::Kind::IntLiteral => {
@ -533,11 +533,11 @@ impl Parser {
_ => raw.parse(),
}
.unwrap();
Ok(tree::Node::Int(token.pos, num))
Ok(Node::Int(token.pos, num))
}
token::Kind::StringLiteral => Ok(tree::Node::String(token.pos, token.raw)),
token::Kind::TrueKeyword => Ok(tree::Node::Bool(token.pos, true)),
token::Kind::FalseKeyword => Ok(tree::Node::Bool(token.pos, false)),
token::Kind::StringLiteral => Ok(Node::String(token.pos, token.raw)),
token::Kind::TrueKeyword => Ok(Node::Bool(token.pos, true)),
token::Kind::FalseKeyword => Ok(Node::Bool(token.pos, false)),
token::Kind::FnKeyword => {
self.lexer.prev(); // parse_fn() expects to consume the keyword
self.parse_fn(true)
@ -545,7 +545,7 @@ impl Parser {
token::Kind::OBracket => {
let elements =
self.parse_delimited_list(token::Kind::Comma, token::Kind::CBracket, true)?;
Ok(tree::Node::Array(token.pos, elements))
Ok(Node::Array(token.pos, elements))
}
_ => self.syntax_error(format!("Unexpected token {}", token.kind), &token),
}
@ -561,7 +561,7 @@ impl Parser {
/// function_returning_an_array(params)[index]
/// (fn(a, b) { return a + b; })(1, 2)
/// ```
fn parse_primary_expr_rest(&mut self, start: tree::Node) -> Result<tree::Node, Error> {
fn parse_primary_expr_rest(&mut self, start: Node) -> Result<Node, Error> {
if let Some(Ok(token)) = self.lexer.peek() {
match token.kind {
token::Kind::OParen => {
@ -569,7 +569,7 @@ impl Parser {
self.lexer.next();
let params =
self.parse_delimited_list(token::Kind::Comma, token::Kind::CParen, false)?;
self.parse_primary_expr_rest(tree::Node::make_call_expr(
self.parse_primary_expr_rest(Node::make_call_expr(
token.pos, start, params,
))
}
@ -577,7 +577,7 @@ impl Parser {
// array index
self.lexer.next();
let index = self.parse_expr(&[token::Kind::CBracket])?;
self.parse_primary_expr_rest(tree::Node::make_array_expr(
self.parse_primary_expr_rest(Node::make_array_expr(
token.pos, start, index,
))
}
@ -585,11 +585,11 @@ impl Parser {
// member access
self.lexer.next();
let member = self.lexer.expect_kind(token::Kind::Ident)?;
self.parse_primary_expr_rest(tree::Node::make_binary_expr(
self.parse_primary_expr_rest(Node::make_binary_expr(
token.pos,
start,
Operator::Dot,
tree::Node::Ident(member.pos, member.raw),
Node::Ident(member.pos, member.raw),
))
}
_ => Ok(start),
@ -606,7 +606,7 @@ impl Parser {
/// ParameterList
/// : Identifier [ "," ParameterList ]
/// ```
fn parse_fn(&mut self, allow_anonymous: bool) -> Result<tree::Node, Error> {
fn parse_fn(&mut self, allow_anonymous: bool) -> Result<Node, Error> {
self.scope.push(Scope::Function);
let fn_keyword = self.lexer.expect_kind(token::Kind::FnKeyword)?;
@ -614,7 +614,7 @@ impl Parser {
let name = if let Some(Ok(token)) = self.lexer.peek() {
if token.kind == token::Kind::Ident {
self.lexer.next();
Some(tree::Node::Ident(token.pos, token.raw))
Some(Node::Ident(token.pos, token.raw))
} else {
None
}
@ -631,7 +631,7 @@ impl Parser {
let params = self.parse_delimited_list(token::Kind::Comma, token::Kind::CParen, false)?;
for p in &params {
match p {
tree::Node::Ident(_, _) => continue,
Node::Ident(_, _) => continue,
_ => {
return self
.syntax_error(format!("Not an identifier"), &self.lexer.current().unwrap())
@ -642,7 +642,7 @@ impl Parser {
let body = self.parse_block_stmt()?;
self.scope.pop();
Ok(tree::Node::make_fn(fn_keyword.pos, name, params, body))
Ok(Node::make_fn(fn_keyword.pos, name, params, body))
}
/// Parse a terminated, delimited list of expressions. This is used for
@ -652,7 +652,7 @@ impl Parser {
delimiter: token::Kind,
terminator: token::Kind,
allow_trailing_delimiter: bool,
) -> Result<Vec<tree::Node>, Error> {
) -> Result<Vec<Node>, Error> {
let mut list = Vec::new();
// In the simplest case, we immediately see the terminator.

Write Preview
Loading…
Cancel
Save