james/huia
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename typename to just ty.

Browse source
This commit is contained in:
James Harton 2019-03-03 13:37:56 +13:00
parent b7d15a2c3c
commit 59b28f7ce9
4 changed files with 36 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
huia-compiler/src/lib.rs
View file

@ -0,0 +1 @@
mod ir;

4
huia-parser/src/ast/mod.rs
View file

@ -7,7 +7,7 @@ mod integer;
mod local;
mod string;
mod term;
mod typename;
mod ty;
mod unary;
pub use atom::Atom;
@ -19,7 +19,7 @@ pub use integer::Integer;
pub use local::Local;
pub use string::String;
pub use term::{NodeType, Term};
pub use typename::Type;
pub use ty::Ty;
pub use unary::Unary;
use crate::input_location::InputLocation;

50
huia-parser/src/ast/term.rs
View file

@ -23,7 +23,7 @@ pub enum NodeType {
Binary,
Boolean,
Call,
Type,
Ty,
Constructor,
Declaration,
Definition,
@ -43,8 +43,8 @@ enum Inner {
Binary(Binary, Box<Term>, Box<Term>),
Boolean(Boolean),
Call(Identifier, Vec<Term>),
Type(Type),
Constructor(Type, Vec<(Identifier, Term)>),
Ty(Ty),
Constructor(Ty, Vec<(Identifier, Term)>),
Declaration(Identifier, Box<Term>),
Definition(
Identifier,
@ -91,7 +91,7 @@ impl Term {
Inner::Boolean(_) => NodeType::Boolean,
Inner::Binary(_, _, _) => NodeType::Binary,
Inner::Call(_, _) => NodeType::Call,
Inner::Type(_) => NodeType::Type,
Inner::Ty(_) => NodeType::Ty,
Inner::Constructor(_, _) => NodeType::Constructor,
Inner::Definition(_, _, _, _, _) => NodeType::Definition,
Inner::Declaration(_, _) => NodeType::Declaration,
@ -140,16 +140,16 @@ impl Term {
}
}
pub fn typename(&self) -> Option<&Type> {
pub fn ty(&self) -> Option<&Ty> {
match self.inner {
Inner::Type(ref node) => Some(node),
Inner::Ty(ref node) => Some(node),
_ => None,
}
}
pub fn constructor(&self) -> Option<(&Type, &Vec<(Identifier, Term)>)> {
pub fn constructor(&self) -> Option<(&Ty, &Vec<(Identifier, Term)>)> {
match self.inner {
Inner::Constructor(ref typename, ref properties) => Some((typename, properties)),
Inner::Constructor(ref ty, ref properties) => Some((ty, properties)),
_ => None,
}
}
@ -282,11 +282,11 @@ impl<'a> From<Pair<'a, Rule>> for Term {
}
Rule::typename => Term {
location: InputLocation::from(pair.clone()),
inner: Inner::Type(Type::from(pair)),
inner: Inner::Ty(Ty::from(pair)),
},
Rule::constructor => {
let mut inner = pair.clone().into_inner();
let typename = Type::from(inner.next().unwrap());
let ty = Ty::from(inner.next().unwrap());
let mut properties = Vec::new();
for property in inner {
@ -303,7 +303,7 @@ impl<'a> From<Pair<'a, Rule>> for Term {
Term {
location: InputLocation::from(pair),
inner: Inner::Constructor(typename, properties),
inner: Inner::Constructor(ty, properties),
}
}
Rule::declaration => {
@ -570,8 +570,8 @@ mod test {
#[test]
fn test_typename() {
let terms = Term::input("Marty").unwrap();
assert_eq!(terms[0].node_type(), NodeType::Type);
let term = terms[0].typename().unwrap().clone();
assert_eq!(terms[0].node_type(), NodeType::Ty);
let term = terms[0].ty().unwrap().clone();
assert_eq!(term.value(), "Marty");
}
@ -579,16 +579,16 @@ mod test {
fn test_constructor_empty() {
let terms = Term::input("Character {}").unwrap();
assert_eq!(terms[0].node_type(), NodeType::Constructor);
let (typename, properties) = terms[0].constructor().unwrap();
assert_eq!(typename.value_ref(), "Character");
let (ty, properties) = terms[0].constructor().unwrap();
assert_eq!(ty.value_ref(), "Character");
assert_eq!(properties.len(), 0);
}
#[test]
fn test_constructor() {
let terms = Term::input("Character { name: \"Marty McFly\" }").unwrap();
let (typename, properties) = terms[0].constructor().unwrap();
assert_eq!(typename.value_ref(), "Character");
let (ty, properties) = terms[0].constructor().unwrap();
assert_eq!(ty.value_ref(), "Character");
assert_eq!(properties.len(), 1);
let (key, value) = &properties[0];
assert_eq!(key.value_ref(), "name");
@ -602,12 +602,12 @@ mod test {
let (deftype, defname, args, body, _reqs) = terms[0].definition().unwrap();
assert_eq!(deftype.value_ref(), "type");
assert_eq!(defname.typename().unwrap().value_ref(), "Delorean");
assert_eq!(defname.ty().unwrap().value_ref(), "Delorean");
let (argname, argvalue) = &args[0];
assert_eq!(argname.value_ref(), "speed");
assert_eq!(argvalue.typename().unwrap().value_ref(), "Integer");
assert_eq!(argvalue.ty().unwrap().value_ref(), "Integer");
let (argname, argvalues) = &body[0];
assert_eq!(argname.value_ref(), "do");
@ -621,7 +621,7 @@ mod test {
let terms = Term::input("type Delorean").unwrap();
let (deftype, defname, args, body, _reqs) = terms[0].definition().unwrap();
assert_eq!(deftype.value_ref(), "type");
assert_eq!(defname.typename().unwrap().value_ref(), "Delorean");
assert_eq!(defname.ty().unwrap().value_ref(), "Delorean");
assert_eq!(args.len(), 0);
assert_eq!(body.len(), 0);
}
@ -654,7 +654,7 @@ mod test {
assert_eq!(defname.atom().unwrap().value_ref(), "example");
assert_eq!(args.len(), 2);
assert_eq!(body.len(), 1);
assert_eq!(reqs.unwrap().typename().unwrap().value_ref(), "Integer");
assert_eq!(reqs.unwrap().ty().unwrap().value_ref(), "Integer");
}
#[test]
@ -662,15 +662,15 @@ mod test {
let terms = Term::input("trait Integer: Add + Subtract").unwrap();
let (deftype, defname, args, body, reqs_option) = terms[0].definition().unwrap();
assert_eq!(deftype.value_ref(), "trait");
assert_eq!(defname.typename().unwrap().value_ref(), "Integer");
assert_eq!(defname.ty().unwrap().value_ref(), "Integer");
assert_eq!(args.len(), 0);
assert_eq!(body.len(), 0);
let reqs = reqs_option.unwrap();
let (op, lhs, rhs) = reqs.binary().unwrap();
assert_eq!(op.value_ref(), &binary::Operator::Plus);
assert_eq!(lhs.typename().unwrap().value_ref(), "Add");
assert_eq!(rhs.typename().unwrap().value_ref(), "Subtract");
assert_eq!(lhs.ty().unwrap().value_ref(), "Add");
assert_eq!(rhs.ty().unwrap().value_ref(), "Subtract");
}
#[test]
@ -791,7 +791,7 @@ mod test {
let terms = Term::input("My.Greeter.hello()").unwrap();
let (method_name, receiver, arguments) = terms[0].method_call().unwrap();
assert_eq!(method_name.value_ref(), "hello");
assert_eq!(receiver.typename().unwrap().value_ref(), "My.Greeter");
assert_eq!(receiver.ty().unwrap().value_ref(), "My.Greeter");
assert_eq!(arguments.len(), 0);
}

16
huia-parser/src/ast/typename.rs → huia-parser/src/ast/ty.rs
View file

@ -4,18 +4,18 @@ use crate::input_location::InputLocation;
use pest::iterators::Pair;
#[derive(Debug, Clone)]
pub struct Type {
pub struct Ty {
value: String,
location: InputLocation,
}
impl Type {
impl Ty {
pub fn value(&self) -> &str {
&self.value
}
}
impl Value for Type {
impl Value for Ty {
type Item = String;
fn value(self) -> Self::Item {
@ -27,23 +27,23 @@ impl Value for Type {
}
}
impl Location for Type {
impl Location for Ty {
fn location(&self) -> &InputLocation {
&self.location
}
}
impl<'a> From<Pair<'a, Rule>> for Type {
impl<'a> From<Pair<'a, Rule>> for Ty {
fn from(pair: Pair<'a, Rule>) -> Self {
match pair.as_rule() {
Rule::typename => {
let value = pair.clone().into_span().as_str().to_string();
Type {
Ty {
value: value,
location: InputLocation::from(pair.into_span()),
}
}
_ => unreachable!("Expected pair to be a Type"),
_ => unreachable!("Expected pair to be a Ty"),
}
}
}
@ -60,7 +60,7 @@ mod test {
.unwrap()
.next()
.unwrap();
let r#type = Type::from(pair);
let r#type = Ty::from(pair);
assert_eq!(r#type.value(), "Marty.McFly");
}
}