schala/schala-lang/language/src/ast_visitor.rs

use ast::*;

pub fn dispatch<T, V: ASTVisitor<T>>(visitor: &mut V, ast: &AST) -> T {
  visitor.ast(ast);
  for statement in ast.0.iter() {
    visitor.statement(statement);
    match statement {
      Statement::ExpressionStatement(expr) => {
        let ref mut expression_visitor = visitor.expression();
        ExpressionVisitor::dispatch(expression_visitor, expr);
      },
      Statement::Declaration(decl) => {
        let ref mut declaration_visitor = visitor.declaration();
        DeclarationVisitor::dispatch(declaration_visitor, decl);
      },
    }
  }
  visitor.done()
}

pub trait ASTVisitor<T> {
  type EV : ExpressionVisitor<T>;
  type DV : DeclarationVisitor<T>;

  fn ast(&mut self, ast: &AST) {
  }
  fn done(&mut self) -> T;

  fn statement(&mut self, statement: &Statement) {
  }

  fn expression(&mut self) -> Self::EV;
  fn declaration(&mut self) -> Self::DV;
}

pub trait ExpressionVisitor<T> {
  fn dispatch(visitor: &mut Self, expr: &Expression) -> T {
    visitor.expression(expr);
    visitor.done()
  }
  fn expression(&mut self, expression: &Expression) {
  }
  fn done(&mut self) -> T;
}

pub trait DeclarationVisitor<T> {
  fn dispatch(visitor: &mut Self, decl: &Declaration) -> T {
    use self::Declaration::*;
    match decl {
      FuncSig(sig) => visitor.func_signature(sig),
      FuncDecl(sig, block) => visitor.func_declaration(sig, block),
      TypeDecl { name, body, mutable } => visitor.type_declaration(name, body, mutable),
      TypeAlias(..) => unimplemented!(), 
      Binding { .. } => unimplemented!(),
      Impl { .. } => unimplemented!(),
      Interface { .. } => unimplemented!(),
    };
    visitor.done()
  }

  fn declaration(&mut self, decl: &Declaration) {
  }

  fn func_signature(&mut self, sig: &Signature) {
  }

  fn func_declaration(&mut self, sig: &Signature, block: &Vec<Statement>) {
  }

  fn type_declaration(&mut self, name: &TypeSingletonName, body: &TypeBody, mutable: &bool) {
  }

  fn done(&mut self) -> T;
}

/*----*/


struct NullVisitor { }
impl ASTVisitor<()> for NullVisitor {
  type EV = NullVisitor;
  type DV = NullVisitor;
  fn done(&mut self) -> () {
    ()
  }

  fn expression(&mut self) -> Self::EV {
    NullVisitor { }
  }

  fn declaration(&mut self) -> Self::DV {
    NullVisitor { }
  }
}

impl ExpressionVisitor<()> for NullVisitor {
  fn done(&mut self) -> () {
    ()
  }
}

impl DeclarationVisitor<()> for NullVisitor {
  fn done(&mut self) -> () {
    ()
  }
}