greg
/
schala
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rename ExpressionType -> ExpressionKind

This commit is contained in:
greg 2019-02-21 01:26:51 -08:00
parent 6fba0cc5b4
commit 9fa0576547
4 changed files with 26 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
schala-lang/language/src/ast.rs
View File

@ -92,7 +92,7 @@ pub enum Variant {
} }
#[derive(Debug, PartialEq, Clone)] #[derive(Debug, PartialEq, Clone)]
pub struct Expression(pub ExpressionType, pub Option<TypeIdentifier>); pub struct Expression(pub ExpressionKind, pub Option<TypeIdentifier>);
#[derive(Debug, PartialEq, Clone)] #[derive(Debug, PartialEq, Clone)]
@ -108,7 +108,7 @@ pub struct TypeSingletonName {
} }
#[derive(Debug, PartialEq, Clone)] #[derive(Debug, PartialEq, Clone)]
pub enum ExpressionType { pub enum ExpressionKind {
NatLiteral(u64), NatLiteral(u64),
FloatLiteral(f64), FloatLiteral(f64),
StringLiteral(Rc<String>), StringLiteral(Rc<String>),
@ -177,7 +177,7 @@ pub enum Guard {
#[derive(Debug, PartialEq, Clone)] #[derive(Debug, PartialEq, Clone)]
pub struct HalfExpr { pub struct HalfExpr {
pub op: Option<BinOp>, pub op: Option<BinOp>,
pub expr: ExpressionType, pub expr: ExpressionKind,
} }
#[derive(Debug, PartialEq, Clone)] #[derive(Debug, PartialEq, Clone)]
@ -193,7 +193,7 @@ pub enum Pattern {
pub enum PatternLiteral { pub enum PatternLiteral {
NumPattern { NumPattern {
neg: bool, neg: bool,
num: ExpressionType, num: ExpressionKind,
}, },
StringPattern(Rc<String>), StringPattern(Rc<String>),
BoolPattern(bool), BoolPattern(bool),

30
schala-lang/language/src/parsing.rs
View File

@ -560,7 +560,7 @@ impl Parser {
None => unreachable!() None => unreachable!()
}; };
let rhs = self.precedence_expr(new_precedence)?; let rhs = self.precedence_expr(new_precedence)?;
lhs = Expression(ExpressionType::BinExp(operation, bx!(lhs.into()), bx!(rhs.into())), None); lhs = Expression(ExpressionKind::BinExp(operation, bx!(lhs.into()), bx!(rhs.into())), None);
} }
self.parse_level -= 1; self.parse_level -= 1;
Ok(lhs) Ok(lhs)
@ -576,7 +576,7 @@ impl Parser {
}; };
let expr = self.primary()?; let expr = self.primary()?;
Ok(Expression( Ok(Expression(
ExpressionType::PrefixExp(PrefixOp::from_sigil(sigil.as_str()), bx!(expr.into())), ExpressionKind::PrefixExp(PrefixOp::from_sigil(sigil.as_str()), bx!(expr.into())),
None None
)) ))
}, },
@ -590,7 +590,7 @@ impl Parser {
while let LParen = self.token_handler.peek_kind() { while let LParen = self.token_handler.peek_kind() {
let arguments = delimited!(self, LParen, expression, Comma, RParen); let arguments = delimited!(self, LParen, expression, Comma, RParen);
let arguments = arguments.into_iter().map(|s| Node::new(s)).collect(); let arguments = arguments.into_iter().map(|s| Node::new(s)).collect();
expr = Expression(ExpressionType::Call { f: bx!(expr), arguments }, None); //TODO none is incorrect expr = Expression(ExpressionKind::Call { f: bx!(expr), arguments }, None); //TODO none is incorrect
} }
Ok(expr) Ok(expr)
@ -601,7 +601,7 @@ impl Parser {
let primary = self.primary()?; let primary = self.primary()?;
Ok(if let LSquareBracket = self.token_handler.peek_kind() { Ok(if let LSquareBracket = self.token_handler.peek_kind() {
let indexers = delimited!(self, LSquareBracket, expression, Comma, RSquareBracket); let indexers = delimited!(self, LSquareBracket, expression, Comma, RSquareBracket);
Expression(ExpressionType::Index { Expression(ExpressionKind::Index {
indexee: bx!(Expression(primary.0, None)), indexee: bx!(Expression(primary.0, None)),
indexers, indexers,
}, None) }, None)
@ -628,7 +628,7 @@ impl Parser {
#[recursive_descent_method] #[recursive_descent_method]
fn list_expr(&mut self) -> ParseResult<Expression> { fn list_expr(&mut self) -> ParseResult<Expression> {
let exprs = delimited!(self, LSquareBracket, expression, Comma, RSquareBracket); let exprs = delimited!(self, LSquareBracket, expression, Comma, RSquareBracket);
Ok(Expression(ExpressionType::ListLiteral(exprs), None)) Ok(Expression(ExpressionKind::ListLiteral(exprs), None))
} }
#[recursive_descent_method] #[recursive_descent_method]
@ -645,7 +645,7 @@ impl Parser {
_ => None, _ => None,
}; };
let body = self.nonempty_func_body()?; let body = self.nonempty_func_body()?;
Ok(Expression(ExpressionType::Lambda { params, type_anno, body }, None)) //TODO need to handle types somehow Ok(Expression(ExpressionKind::Lambda { params, type_anno, body }, None)) //TODO need to handle types somehow
} }
#[recursive_descent_method] #[recursive_descent_method]
@ -660,7 +660,7 @@ impl Parser {
#[recursive_descent_method] #[recursive_descent_method]
fn paren_expr(&mut self) -> ParseResult<Expression> { fn paren_expr(&mut self) -> ParseResult<Expression> {
use self::ExpressionType::*; use self::ExpressionKind::*;
let old_struct_value = self.restrictions.no_struct_literal; let old_struct_value = self.restrictions.no_struct_literal;
self.restrictions.no_struct_literal = false; self.restrictions.no_struct_literal = false;
let output = { let output = {
@ -680,7 +680,7 @@ impl Parser {
#[recursive_descent_method] #[recursive_descent_method]
fn identifier_expr(&mut self) -> ParseResult<Expression> { fn identifier_expr(&mut self) -> ParseResult<Expression> {
use self::ExpressionType::*; use self::ExpressionKind::*;
let identifier = self.identifier()?; let identifier = self.identifier()?;
Ok(match self.token_handler.peek_kind() { Ok(match self.token_handler.peek_kind() {
LCurlyBrace if !self.restrictions.no_struct_literal => { LCurlyBrace if !self.restrictions.no_struct_literal => {
@ -720,7 +720,7 @@ impl Parser {
_ => self.guard_block()? _ => self.guard_block()?
}); });
Ok(Expression(ExpressionType::IfExpression { discriminator, body }, None)) Ok(Expression(ExpressionKind::IfExpression { discriminator, body }, None))
} }
#[recursive_descent_method] #[recursive_descent_method]
@ -920,7 +920,7 @@ impl Parser {
#[recursive_descent_method] #[recursive_descent_method]
fn while_expr(&mut self) -> ParseResult<Expression> { fn while_expr(&mut self) -> ParseResult<Expression> {
use self::ExpressionType::*; use self::ExpressionKind::*;
expect!(self, Keyword(Kw::While)); expect!(self, Keyword(Kw::While));
let condition = { let condition = {
self.restrictions.no_struct_literal = true; self.restrictions.no_struct_literal = true;
@ -955,7 +955,7 @@ impl Parser {
vec![single_enum] vec![single_enum]
}; };
let body = Box::new(self.for_expr_body()?); let body = Box::new(self.for_expr_body()?);
Ok(Expression(ExpressionType::ForExpression { enumerators, body }, None)) Ok(Expression(ExpressionKind::ForExpression { enumerators, body }, None))
} }
#[recursive_descent_method] #[recursive_descent_method]
@ -994,7 +994,7 @@ impl Parser {
#[recursive_descent_method] #[recursive_descent_method]
fn literal(&mut self) -> ParseResult<Expression> { fn literal(&mut self) -> ParseResult<Expression> {
use self::ExpressionType::*; use self::ExpressionKind::*;
let tok = self.token_handler.peek(); let tok = self.token_handler.peek();
match tok.get_kind() { match tok.get_kind() {
@ -1025,7 +1025,7 @@ impl Parser {
#[recursive_descent_method] #[recursive_descent_method]
fn int_literal(&mut self) -> ParseResult<Expression> { fn int_literal(&mut self) -> ParseResult<Expression> {
use self::ExpressionType::*; use self::ExpressionKind::*;
let tok = self.token_handler.next(); let tok = self.token_handler.next();
match tok.get_kind() { match tok.get_kind() {
BinNumberSigil => { BinNumberSigil => {
@ -1044,7 +1044,7 @@ impl Parser {
#[recursive_descent_method] #[recursive_descent_method]
fn float_literal(&mut self) -> ParseResult<Expression> { fn float_literal(&mut self) -> ParseResult<Expression> {
use self::ExpressionType::*; use self::ExpressionKind::*;
let tok = self.token_handler.peek(); let tok = self.token_handler.peek();
let mut digits = self.digits()?; let mut digits = self.digits()?;
if let Period = self.token_handler.peek_kind() { if let Period = self.token_handler.peek_kind() {
@ -1123,7 +1123,7 @@ mod parse_tests {
use super::Signature; use super::Signature;
use super::TypeIdentifier::*; use super::TypeIdentifier::*;
use super::TypeSingletonName; use super::TypeSingletonName;
use super::ExpressionType::*; use super::ExpressionKind::*;
use super::Variant::*; use super::Variant::*;
use super::ForBody::*; use super::ForBody::*;

10
schala-lang/language/src/reduced_ast.rs
View File

@ -120,7 +120,7 @@ fn reduce_block(block: &Block, symbol_table: &SymbolTable) -> Vec<Stmt> {
impl Expression { impl Expression {
fn reduce(&self, symbol_table: &SymbolTable) -> Expr { fn reduce(&self, symbol_table: &SymbolTable) -> Expr {
use crate::ast::ExpressionType::*; use crate::ast::ExpressionKind::*;
let ref input = self.0; let ref input = self.0;
match input { match input {
NatLiteral(n) => Expr::Lit(Lit::Nat(*n)), NatLiteral(n) => Expr::Lit(Lit::Nat(*n)),
@ -294,10 +294,10 @@ impl PatternLiteral {
match self { match self {
NumPattern { neg, num } => { NumPattern { neg, num } => {
let comparison = Expr::Lit(match (neg, num) { let comparison = Expr::Lit(match (neg, num) {
(false, ExpressionType::NatLiteral(n)) => Lit::Nat(*n), (false, ExpressionKind::NatLiteral(n)) => Lit::Nat(*n),
(false, ExpressionType::FloatLiteral(f)) => Lit::Float(*f), (false, ExpressionKind::FloatLiteral(f)) => Lit::Float(*f),
(true, ExpressionType::NatLiteral(n)) => Lit::Int(-1*(*n as i64)), (true, ExpressionKind::NatLiteral(n)) => Lit::Int(-1*(*n as i64)),
(true, ExpressionType::FloatLiteral(f)) => Lit::Float(-1.0*f), (true, ExpressionKind::FloatLiteral(f)) => Lit::Float(-1.0*f),
_ => panic!("This should never happen") _ => panic!("This should never happen")
}); });
let guard = Some(Expr::Call { let guard = Some(Expr::Call {

4
schala-lang/language/src/typechecking.rs
View File

@ -235,8 +235,8 @@ impl<'a> TypeContext<'a> {
} }
} }
fn expr_type(&mut self, expr: &ExpressionType) -> InferResult<Type> { fn expr_type(&mut self, expr: &ExpressionKind) -> InferResult<Type> {
use self::ExpressionType::*; use self::ExpressionKind::*;
Ok(match expr { Ok(match expr {
NatLiteral(_) => ty!(Nat), NatLiteral(_) => ty!(Nat),
BoolLiteral(_) => ty!(Bool), BoolLiteral(_) => ty!(Bool),