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

Write Preview
Loading…
Cancel
Save