schala/schala-lang/language/src/ast/mod.rs

#![allow(clippy::upper_case_acronyms)]
#![allow(clippy::enum_variant_names)]

mod visitor;
mod operators;

pub use operators::{PrefixOp, BinOp};
pub use visitor::{walk_ast, ASTVisitor};

use std::rc::Rc;
use crate::derivative::Derivative;
use crate::tokenizing::Location;

/// An abstract identifier for an AST node. Note that
/// the u32 index limits the size of an AST to 2^32 nodes.
#[derive(Debug, PartialEq, Eq, Hash, Clone, Default)]
pub struct ItemId {
  idx: u32,
}

impl ItemId {
  fn new(n: u32) -> ItemId {
    ItemId { idx: n }
  }
}

pub struct ItemIdStore {
  last_idx: u32
}

impl ItemIdStore {
  pub fn new() -> ItemIdStore {
    ItemIdStore { last_idx: 0 }
  }

  pub fn fresh(&mut self) -> ItemId {
    let idx = self.last_idx;
    self.last_idx += 1;
    ItemId::new(idx)
  }
}

#[derive(Derivative, Debug)]
#[derivative(PartialEq)]
pub struct AST {
  #[derivative(PartialEq="ignore")]
  pub id: ItemId,
  pub statements: Vec<Statement>
}

#[derive(Derivative, Debug, Clone)]
#[derivative(PartialEq)]
pub struct Statement {
  #[derivative(PartialEq="ignore")]
  pub id: ItemId,
  #[derivative(PartialEq="ignore")]
  pub location: Location,
  pub kind: StatementKind,
}

#[derive(Debug, PartialEq, Clone)]
pub enum StatementKind {
  Expression(Expression),
  Declaration(Declaration),
  Import(ImportSpecifier),
  Module(ModuleSpecifier),
}

pub type Block = Vec<Statement>;
pub type ParamName = Rc<String>;

#[derive(Debug, Derivative, Clone)]
#[derivative(PartialEq)]
pub struct QualifiedName {
  #[derivative(PartialEq="ignore")]
  pub id: ItemId,
  pub components: Vec<Rc<String>>,
}

#[derive(Debug, PartialEq, Clone)]
pub struct FormalParam {
  pub name: ParamName,
  pub default: Option<Expression>,
  pub anno: Option<TypeIdentifier>
}

#[derive(Debug, PartialEq, Clone)]
pub enum Declaration {
  FuncSig(Signature),
  FuncDecl(Signature, Block),
  TypeDecl {
    name: TypeSingletonName,
    body: TypeBody,
    mutable: bool
  },
  //TODO this needs to be more sophisticated
  TypeAlias {
    alias: Rc<String>,
    original: Rc<String>,
  },
  Binding {
    name: Rc<String>,
    constant: bool,
    type_anno: Option<TypeIdentifier>,
    expr: Expression,
  },
  Impl {
    type_name: TypeIdentifier,
    interface_name: Option<TypeSingletonName>,
    block: Vec<Declaration>,
  },
  Interface {
    name: Rc<String>,
    signatures: Vec<Signature>
  },
  Annotation {
      name: Rc<String>,
      arguments: Vec<Expression>
  }
}

/*
 * @foo(arg1, arg2)
 * fn hello() {
 *
 * }
 *
 * Declaration::Annotation {
 *  name: "foo",
 *  arguments: vec!["arg1", "arg2"]
 *  }
 *
 *
 *
 */

#[derive(Debug, PartialEq, Clone)]
pub struct Signature {
  pub name: Rc<String>,
  pub operator: bool,
  pub params: Vec<FormalParam>,
  pub type_anno: Option<TypeIdentifier>,
}

#[derive(Debug, PartialEq, Clone)]
pub struct TypeBody(pub Vec<Variant>);

#[derive(Debug, Derivative, Clone)]
#[derivative(PartialEq)]
pub struct Variant {
    #[derivative(PartialEq="ignore")]
    pub id: ItemId,
    pub name: Rc<String>,
    pub kind: VariantKind,
 }

#[derive(Debug, PartialEq, Clone)]
pub enum VariantKind {
    UnitStruct,
    TupleStruct(Vec<TypeIdentifier>),
    Record(Vec<(Rc<String>, TypeIdentifier)>),
 }

#[derive(Debug, Derivative, Clone)]
#[derivative(PartialEq)]
pub struct Expression {
  #[derivative(PartialEq="ignore")]
  pub id: ItemId,
  pub kind: ExpressionKind,
  pub type_anno: Option<TypeIdentifier>
}

impl Expression {
  pub fn new(id: ItemId, kind: ExpressionKind) -> Expression {
    Expression { id, kind, type_anno: None }
  }

  #[cfg(test)]
  pub fn with_anno(id: ItemId, kind: ExpressionKind, type_anno: TypeIdentifier) -> Expression {
    Expression { id, kind, type_anno: Some(type_anno) }
  }
}

#[derive(Debug, PartialEq, Clone)]
pub enum TypeIdentifier {
  Tuple(Vec<TypeIdentifier>),
  Singleton(TypeSingletonName)
}

#[derive(Debug, PartialEq, Clone)]
pub struct TypeSingletonName {
  pub name: Rc<String>,
  pub params: Vec<TypeIdentifier>,
}

#[derive(Debug, PartialEq, Clone)]
pub enum ExpressionKind {
  NatLiteral(u64),
  FloatLiteral(f64),
  StringLiteral(Rc<String>),
  BoolLiteral(bool),
  BinExp(BinOp, Box<Expression>, Box<Expression>),
  PrefixExp(PrefixOp, Box<Expression>),
  TupleLiteral(Vec<Expression>),
  Value(QualifiedName),
  NamedStruct {
    name: QualifiedName,
    fields: Vec<(Rc<String>, Expression)>,
  },
  Call {
    f: Box<Expression>,
    arguments: Vec<InvocationArgument>,
  },
  Index {
    indexee: Box<Expression>,
    indexers: Vec<Expression>,
  },
  IfExpression {
    discriminator: Option<Box<Expression>>,
    body: Box<IfExpressionBody>,
  },
  WhileExpression {
    condition: Option<Box<Expression>>,
    body: Block,
  },
  ForExpression {
    enumerators: Vec<Enumerator>,
    body: Box<ForBody>,
  },
  Lambda {
    params: Vec<FormalParam>,
    type_anno: Option<TypeIdentifier>,
    body: Block,
  },
  ListLiteral(Vec<Expression>),
}

#[derive(Debug, PartialEq, Clone)]
pub enum InvocationArgument {
  Positional(Expression),
  Keyword {
    name: Rc<String>,
    expr: Expression,
  },
  Ignored
}

#[derive(Debug, PartialEq, Clone)]
pub enum IfExpressionBody {
  SimpleConditional {
    then_case: Block,
    else_case: Option<Block>
  },
  SimplePatternMatch {
    pattern: Pattern,
    then_case: Block,
    else_case: Option<Block>
  },
  CondList(Vec<ConditionArm>)
}

#[derive(Debug, PartialEq, Clone)]
pub struct ConditionArm {
  pub condition: Condition,
  pub guard: Option<Expression>,
  pub body: Block,
}

#[derive(Debug, PartialEq, Clone)]
pub enum Condition {
  Pattern(Pattern),
  TruncatedOp(BinOp, Expression),
  Expression(Expression),
  Else,
}

#[derive(Debug, PartialEq, Clone)]
pub enum Pattern {
  Ignored,
  TuplePattern(Vec<Pattern>),
  Literal(PatternLiteral),
  TupleStruct(QualifiedName, Vec<Pattern>),
  Record(QualifiedName, Vec<(Rc<String>, Pattern)>),
  VarOrName(QualifiedName),
}

#[derive(Debug, PartialEq, Clone)]
pub enum PatternLiteral {
  NumPattern {
    neg: bool,
    num: ExpressionKind,
  },
  StringPattern(Rc<String>),
  BoolPattern(bool),
}

#[derive(Debug, PartialEq, Clone)]
pub struct Enumerator {
  pub id: Rc<String>,
  pub generator: Expression,
}

#[derive(Debug, PartialEq, Clone)]
pub enum ForBody {
  MonadicReturn(Expression),
  StatementBlock(Block),
}

#[derive(Debug, Derivative, Clone)]
#[derivative(PartialEq)]
pub struct ImportSpecifier {
  #[derivative(PartialEq="ignore")]
  pub id: ItemId,
  pub path_components: Vec<Rc<String>>,
  pub imported_names: ImportedNames
}

#[derive(Debug, PartialEq, Clone)]
pub enum ImportedNames {
  All,
  LastOfPath,
  List(Vec<Rc<String>>)
}


#[derive(Debug, PartialEq, Clone)]
pub struct ModuleSpecifier {
  pub name: Rc<String>,
  pub contents: Vec<Statement>,
}