Visitor cleanup

This commit is contained in:
greg 2019-09-28 02:37:36 -07:00
parent 253b5d88f0
commit f06b5922de
2 changed files with 32 additions and 36 deletions

View File

@ -1,43 +1,38 @@
use std::rc::Rc; use std::rc::Rc;
use std::error::Error;
use crate::ast::*; use crate::ast::*;
use crate::ast::walker;
//TODO maybe these functions should take closures that return a KeepRecursing | StopHere type, //TODO maybe these functions should take closures that return a KeepRecursing | StopHere type,
//or a tuple of (T, <that type>) //or a tuple of (T, <that type>)
//TODO default implmentations should call walk methods - then I can test printing
pub trait ASTVisitor: Sized { pub trait ASTVisitor: Sized {
fn ast(&mut self, ast: &AST) {} fn ast(&mut self, _ast: &AST) {}
fn block(&mut self, statements: &Vec<Statement>) {} fn block(&mut self, _statements: &Vec<Statement>) {}
fn statement(&mut self, statement: &Statement) {} fn statement(&mut self, _statement: &Statement) {}
fn declaration(&mut self, declaration: &Declaration) {} fn declaration(&mut self, _declaration: &Declaration) {}
fn signature(&mut self, signature: &Signature) {} fn signature(&mut self, _signature: &Signature) {}
fn type_declaration(&mut self, name: &TypeSingletonName, body: &TypeBody, mutable: bool) {} fn type_declaration(&mut self, _name: &TypeSingletonName, _body: &TypeBody, _mutable: bool) {}
fn type_alias(&mut self, old_name: &Rc<String>, new_name: &Rc<String>) {} fn type_alias(&mut self, _old_name: &Rc<String>, _new_name: &Rc<String>) {}
fn binding(&mut self, name: &Rc<String>, constant: bool, type_anno: Option<&TypeIdentifier>, expr: &Expression) {} fn binding(&mut self, _name: &Rc<String>, _constant: bool, _type_anno: Option<&TypeIdentifier>, _expr: &Expression) {}
fn implemention(&mut self, type_name: &TypeIdentifier, interface_name: Option<&TypeSingletonName>, block: &Vec<Declaration>) {} fn implemention(&mut self, _type_name: &TypeIdentifier, _interface_name: Option<&TypeSingletonName>, _block: &Vec<Declaration>) {}
fn interface(&mut self, name: &Rc<String>, signatures: &Vec<Signature>) {} fn interface(&mut self, _name: &Rc<String>, _signatures: &Vec<Signature>) {}
fn expression(&mut self, expression: &Expression) {} fn expression(&mut self, _expression: &Expression) {}
fn expression_kind(&mut self, kind: &ExpressionKind) {} fn expression_kind(&mut self, _kind: &ExpressionKind) {}
fn type_annotation(&mut self, type_anno: Option<&TypeIdentifier>) {} fn type_annotation(&mut self, _type_anno: Option<&TypeIdentifier>) {}
fn named_struct(&mut self, name: &QualifiedName, fields: &Vec<(Rc<String>, Expression)>) {} fn named_struct(&mut self, _name: &QualifiedName, _fields: &Vec<(Rc<String>, Expression)>) {}
fn call(&mut self, f: &Expression, arguments: &Vec<InvocationArgument>) {} fn call(&mut self, _f: &Expression, _arguments: &Vec<InvocationArgument>) {}
fn index(&mut self, indexee: &Expression, indexers: &Vec<Expression>) {} fn index(&mut self, _indexee: &Expression, _indexers: &Vec<Expression>) {}
fn if_expression(&mut self, discrim: &Discriminator, body: &IfExpressionBody) {} fn if_expression(&mut self, _discrim: &Discriminator, _body: &IfExpressionBody) {}
fn while_expression(&mut self, condition: Option<&Expression>, body: &Block) {} fn while_expression(&mut self, _condition: Option<&Expression>, _body: &Block) {}
fn for_expression(&mut self, enumerators: &Vec<Enumerator>, body: &ForBody) {} fn for_expression(&mut self, _enumerators: &Vec<Enumerator>, _body: &ForBody) {}
fn lambda(&mut self, params: &Vec<FormalParam>, type_anno: Option<&TypeIdentifier>, body: &Block) {} fn lambda(&mut self, _params: &Vec<FormalParam>, _type_anno: Option<&TypeIdentifier>, _body: &Block) {}
fn invocation_argument(&mut self, arg: &InvocationArgument) {} fn invocation_argument(&mut self, _arg: &InvocationArgument) {}
fn formal_param(&mut self, param: &FormalParam) {} fn formal_param(&mut self, _param: &FormalParam) {}
fn import(&mut self, import: &ImportSpecifier) {} fn import(&mut self, _import: &ImportSpecifier) {}
fn qualified_name(&mut self, name: &QualifiedName) {} fn qualified_name(&mut self, _name: &QualifiedName) {}
fn nat_literal(&mut self, n: u64) {} fn nat_literal(&mut self, _n: u64) {}
fn float_literal(&mut self, f: f64) {} fn float_literal(&mut self, _f: f64) {}
fn string_literal(&mut self, s: &Rc<String>) {} fn string_literal(&mut self, _s: &Rc<String>) {}
fn bool_literal(&mut self, b: bool) {} fn bool_literal(&mut self, _b: bool) {}
fn binexp(&mut self, op: &BinOp, lhs: &Expression, rhs: &Expression) {} fn binexp(&mut self, _op: &BinOp, _lhs: &Expression, _rhs: &Expression) {}
fn prefix_exp(&mut self, op: &PrefixOp, arg: &Expression) {} fn prefix_exp(&mut self, _op: &PrefixOp, _arg: &Expression) {}
} }

View File

@ -1,3 +1,4 @@
#![allow(dead_code)]
use std::rc::Rc; use std::rc::Rc;
use crate::ast::*; use crate::ast::*;
use crate::ast::visitor::ASTVisitor; use crate::ast::visitor::ASTVisitor;
@ -8,7 +9,7 @@ pub fn ast<V: ASTVisitor>(v: &mut V, ast: &AST) {
walk_block(v, &ast.statements); walk_block(v, &ast.statements);
} }
pub fn walk_block<V: ASTVisitor>(v: &mut V, block: &Vec<Statement>) { fn walk_block<V: ASTVisitor>(v: &mut V, block: &Vec<Statement>) {
for s in block { for s in block {
v.statement(s); v.statement(s);
statement(v, s); statement(v, s);