lang: rename struct to value

Basic affordances are made such that `value`-named identifiers still work

fixes #73

dora-parser/src/ast.rs

@@ -37,8 +37,8 @@ impl File {
     }
 
     #[cfg(test)]
-    pub fn struct0(&self) -> &Struct {
-        self.elements[0].to_struct().unwrap()
+    pub fn value0(&self) -> &Value {
+        self.elements[0].to_value().unwrap()
     }
 
     #[cfg(test)]
@@ -100,7 +100,7 @@ impl fmt::Display for NodeId {
 pub enum Elem {
     Function(Arc<Function>),
     Class(Arc<Class>),
-    Struct(Arc<Struct>),
+    Value(Arc<Value>),
     Trait(Arc<Trait>),
     Impl(Arc<Impl>),
     Annotation(Arc<Annotation>),
@@ -117,7 +117,7 @@ impl Elem {
         match self {
             &Elem::Function(ref f) => f.id,
             &Elem::Class(ref c) => c.id,
-            &Elem::Struct(ref s) => s.id,
+            &Elem::Value(ref s) => s.id,
             &Elem::Trait(ref t) => t.id,
             &Elem::Impl(ref i) => i.id,
             &Elem::Annotation(ref a) => a.id,
@@ -165,9 +165,9 @@ impl Elem {
         }
     }
 
-    pub fn to_struct(&self) -> Option<&Struct> {
+    pub fn to_value(&self) -> Option<&Value> {
         match self {
-            &Elem::Struct(ref struc) => Some(struc),
+            &Elem::Value(ref value) => Some(value),
             _ => None,
         }
     }
@@ -317,19 +317,19 @@ pub struct Alias {
 }
 
 #[derive(Clone, Debug)]
-pub struct Struct {
+pub struct Value {
     pub id: NodeId,
     pub pos: Position,
     pub span: Span,
     pub name: Name,
-    pub fields: Vec<StructField>,
+    pub fields: Vec<ValueField>,
     pub visibility: Visibility,
     pub internal: bool,
     pub type_params: Option<Vec<TypeParam>>,
 }
 
 #[derive(Clone, Debug)]
-pub struct StructField {
+pub struct ValueField {
     pub id: NodeId,
     pub name: Name,
     pub pos: Position,

dora-parser/src/ast/dump.rs

@@ -65,7 +65,7 @@ impl<'a> AstDumper<'a> {
         match *el {
             Elem::Function(ref node) => self.dump_fct(node),
             Elem::Class(ref node) => self.dump_class(node),
-            Elem::Struct(ref node) => self.dump_struct(node),
+            Elem::Value(ref node) => self.dump_value(node),
             Elem::Trait(ref node) => self.dump_trait(node),
             Elem::Impl(ref node) => self.dump_impl(node),
             Elem::Annotation(ref node) => self.dump_annotation(node),
@@ -194,23 +194,23 @@ impl<'a> AstDumper<'a> {
         });
     }
 
-    fn dump_struct(&mut self, struc: &Struct) {
+    fn dump_value(&mut self, value: &Value) {
         dump!(
             self,
-            "struct {} @ {} {}",
-            self.str(struc.name),
-            struc.pos,
-            struc.id
+            "value {} @ {} {}",
+            self.str(value.name),
+            value.pos,
+            value.id
         );
 
         self.indent(|d| {
-            for field in &struc.fields {
-                d.dump_struct_field(field);
+            for field in &value.fields {
+                d.dump_value_field(field);
             }
         });
     }
 
-    fn dump_struct_field(&mut self, field: &StructField) {
+    fn dump_value_field(&mut self, field: &ValueField) {
         dump!(
             self,
             "field {} @ {} {}",

dora-parser/src/ast/visit.rs

@@ -21,8 +21,8 @@ pub trait Visitor: Sized {
         walk_class(self, c);
     }
 
-    fn visit_struct(&mut self, s: &Arc<Struct>) {
-        walk_struct(self, s);
+    fn visit_value(&mut self, s: &Arc<Value>) {
+        walk_value(self, s);
     }
 
     fn visit_annotation(&mut self, a: &Arc<Annotation>) {
@@ -49,8 +49,8 @@ pub trait Visitor: Sized {
         walk_use(self, i);
     }
 
-    fn visit_struct_field(&mut self, f: &StructField) {
-        walk_struct_field(self, f);
+    fn visit_value_field(&mut self, f: &ValueField) {
+        walk_value_field(self, f);
     }
 
     fn visit_ctor(&mut self, m: &Arc<Function>) {
@@ -96,7 +96,7 @@ pub fn walk_elem<V: Visitor>(v: &mut V, e: &Elem) {
     match e {
         Elem::Function(f) => v.visit_fct(f),
         Elem::Class(ref c) => v.visit_class(c),
-        Elem::Struct(ref s) => v.visit_struct(s),
+        Elem::Value(ref s) => v.visit_value(s),
         Elem::Trait(ref t) => v.visit_trait(t),
         Elem::Impl(ref i) => v.visit_impl(i),
         Elem::Annotation(ref a) => v.visit_annotation(a),
@@ -162,13 +162,13 @@ pub fn walk_use<V: Visitor>(_v: &mut V, _use: &Arc<Use>) {
     // nothing to do
 }
 
-pub fn walk_struct<V: Visitor>(v: &mut V, s: &Struct) {
+pub fn walk_value<V: Visitor>(v: &mut V, s: &Value) {
     for f in &s.fields {
-        v.visit_struct_field(f);
+        v.visit_value_field(f);
     }
 }
 
-pub fn walk_struct_field<V: Visitor>(v: &mut V, f: &StructField) {
+pub fn walk_value_field<V: Visitor>(v: &mut V, f: &ValueField) {
     v.visit_type(&f.data_type);
 }
 

dora-parser/src/lexer.rs

@@ -541,7 +541,7 @@ fn keywords_in_map() -> HashMap<&'static str, TokenKind> {
     // "big" shapes
     keywords.insert("class", TokenKind::Class);
     keywords.insert("enum", TokenKind::Enum);
-    keywords.insert("struct", TokenKind::Struct);
+    keywords.insert("value", TokenKind::Value);
     keywords.insert("trait", TokenKind::Trait);
     keywords.insert("impl", TokenKind::Impl);
     keywords.insert("annotation", TokenKind::Annotation);
@@ -1058,13 +1058,13 @@ mod tests {
         assert_tok(&mut reader, TokenKind::Super, 1, 12);
         assert_tok(&mut reader, TokenKind::Mod, 1, 18);
 
-        let mut reader = Lexer::from_str("type struct enum alias trait const");
+        let mut reader = Lexer::from_str("type value enum alias trait const");
         assert_tok(&mut reader, TokenKind::Type, 1, 1);
-        assert_tok(&mut reader, TokenKind::Struct, 1, 6);
-        assert_tok(&mut reader, TokenKind::Enum, 1, 13);
-        assert_tok(&mut reader, TokenKind::Alias, 1, 18);
-        assert_tok(&mut reader, TokenKind::Trait, 1, 24);
-        assert_tok(&mut reader, TokenKind::Const, 1, 30);
+        assert_tok(&mut reader, TokenKind::Value, 1, 6);
+        assert_tok(&mut reader, TokenKind::Enum, 1, 12);
+        assert_tok(&mut reader, TokenKind::Alias, 1, 17);
+        assert_tok(&mut reader, TokenKind::Trait, 1, 23);
+        assert_tok(&mut reader, TokenKind::Const, 1, 29);
 
         let mut reader = Lexer::from_str("for in impl Self");
         assert_tok(&mut reader, TokenKind::For, 1, 1);

dora-parser/src/lexer/token.rs

@@ -19,7 +19,7 @@ pub enum TokenKind {
     // "big" shapes
     Class,
     Enum,
-    Struct,
+    Value,
     Trait,
     Impl,
     Annotation,
@@ -123,7 +123,7 @@ impl TokenKind {
             // "big" shapes
             TokenKind::Class => "class",
             TokenKind::Enum => "enum",
-            TokenKind::Struct => "struct",
+            TokenKind::Value => "value",
             TokenKind::Trait => "trait",
             TokenKind::Impl => "impl",
             TokenKind::Annotation => "annotation",

dora-parser/src/parser.rs

@@ -106,10 +106,10 @@ impl<'a> Parser<'a> {
                 Ok(Elem::Class(Arc::new(class)))
             }
 
-            TokenKind::Struct => {
+            TokenKind::Value => {
                 self.restrict_modifiers(&modifiers, &[Modifier::Pub, Modifier::Internal])?;
-                let struc = self.parse_struct(&modifiers)?;
-                Ok(Elem::Struct(Arc::new(struc)))
+                let value = self.parse_value(&modifiers)?;
+                Ok(Elem::Value(Arc::new(value)))
             }
 
             TokenKind::Trait => {
@@ -496,29 +496,29 @@ impl<'a> Parser<'a> {
         })
     }
 
-    fn parse_struct(&mut self, modifiers: &Modifiers) -> Result<Struct, ParseErrorAndPos> {
+    fn parse_value(&mut self, modifiers: &Modifiers) -> Result<Value, ParseErrorAndPos> {
         let start = self.token.span.start();
-        let pos = self.expect_token(TokenKind::Struct)?.position;
+        let pos = self.expect_token(TokenKind::Value)?.position;
         let ident = self.expect_identifier()?;
         let type_params = self.parse_type_params()?;
 
         let fields = if self.token.is(TokenKind::LParen) {
             self.expect_token(TokenKind::LParen)?;
             self.parse_list(TokenKind::Comma, TokenKind::RParen, |p| {
-                p.parse_struct_field()
+                p.parse_value_field()
             })?
         } else if self.token.is(TokenKind::LBrace) {
             self.expect_token(TokenKind::LBrace)?;
             self.parse_list(TokenKind::Comma, TokenKind::RBrace, |p| {
-                p.parse_struct_field()
+                p.parse_value_field()
             })?
         } else {
             Vec::new()
         };
 
         let span = self.span_from(start);
 
-        Ok(Struct {
+        Ok(Value {
             id: self.generate_id(),
             name: ident,
             pos,
@@ -530,7 +530,7 @@ impl<'a> Parser<'a> {
         })
     }
 
-    fn parse_struct_field(&mut self) -> Result<StructField, ParseErrorAndPos> {
+    fn parse_value_field(&mut self) -> Result<ValueField, ParseErrorAndPos> {
         let start = self.token.span.start();
         let pos = self.token.position;
 
@@ -544,7 +544,7 @@ impl<'a> Parser<'a> {
         let ty = self.parse_type()?;
         let span = self.span_from(start);
 
-        Ok(StructField {
+        Ok(ValueField {
             id: self.generate_id(),
             name: ident,
             pos,
@@ -977,7 +977,7 @@ impl<'a> Parser<'a> {
                 Ok(Type::create_self(self.generate_id(), pos, span))
             }
 
-            TokenKind::Identifier(_) | TokenKind::Is => {
+            TokenKind::Identifier(_) | TokenKind::Is | TokenKind::Value => {
                 let pos = self.token.position;
                 let start = self.token.span.start();
                 let path = self.parse_path()?;
@@ -1718,7 +1718,7 @@ impl<'a> Parser<'a> {
             TokenKind::LitInt(_, _, _) => self.parse_lit_int(),
             TokenKind::LitFloat(_, _) => self.parse_lit_float(),
             TokenKind::StringTail(_) | TokenKind::StringExpr(_) => self.parse_string(),
-            TokenKind::Identifier(_) | TokenKind::Is => self.parse_identifier(),
+            TokenKind::Identifier(_) | TokenKind::Is | TokenKind::Value => self.parse_identifier(),
             TokenKind::True => self.parse_bool_literal(),
             TokenKind::False => self.parse_bool_literal(),
             TokenKind::This => self.parse_this(),
@@ -2037,7 +2037,7 @@ impl<'a> Parser<'a> {
 
         match tok.kind {
             TokenKind::Identifier(ref value) => Ok(self.interner.intern(value)),
-            TokenKind::Is => Ok(self.interner.intern(tok.kind.name())),
+            TokenKind::Is | TokenKind::Value => Ok(self.interner.intern(tok.kind.name())),
             _ => Err(ParseErrorAndPos::new(
                 tok.position,
                 ParseError::ExpectedIdentifier(tok.name()),
@@ -3093,21 +3093,21 @@ mod tests {
     }
 
     #[test]
-    fn parse_struct_empty() {
-        let (prog, interner) = parse("struct Foo {}");
-        let struc = prog.struct0();
+    fn parse_value_empty() {
+        let (prog, interner) = parse("value Foo {}");
+        let struc = prog.value0();
         assert_eq!(0, struc.fields.len());
         assert_eq!("Foo", *interner.str(struc.name));
     }
 
     #[test]
-    fn parse_struct_one_field() {
+    fn parse_value_one_field() {
         let (prog, interner) = parse(
-            "struct Bar {
+            "value Bar {
             f1: Foo1,
         }",
         );
-        let struc = prog.struct0();
+        let struc = prog.value0();
         assert_eq!(1, struc.fields.len());
         assert_eq!("Bar", *interner.str(struc.name));
 
@@ -3116,14 +3116,14 @@ mod tests {
     }
 
     #[test]
-    fn parse_struct_multiple_fields() {
+    fn parse_value_multiple_fields() {
         let (prog, interner) = parse(
-            "struct FooBar {
+            "value FooBar {
             fa: Foo1,
             fb: Foo2,
         }",
         );
-        let struc = prog.struct0();
+        let struc = prog.value0();
         assert_eq!(2, struc.fields.len());
         assert_eq!("FooBar", *interner.str(struc.name));
 
@@ -3135,21 +3135,21 @@ mod tests {
     }
 
     #[test]
-    fn parse_struct_with_type_params() {
+    fn parse_value_with_type_params() {
         let (prog, interner) = parse(
-            "struct Bar[T1, T2] {
+            "value Bar[T1, T2] {
             f1: T1, f2: T2,
         }",
         );
-        let struct_ = prog.struct0();
-        assert_eq!(2, struct_.fields.len());
-        assert_eq!("Bar", *interner.str(struct_.name));
+        let value = prog.value0();
+        assert_eq!(2, value.fields.len());
+        assert_eq!("Bar", *interner.str(value.name));
 
-        assert_eq!(2, struct_.type_params.as_ref().unwrap().len());
+        assert_eq!(2, value.type_params.as_ref().unwrap().len());
     }
 
     #[test]
-    fn parse_struct_lit_while() {
+    fn parse_value_lit_while() {
         let stmt = parse_stmt("while i < n { }");
         let while_stmt = stmt.to_while().unwrap();
         let bin = while_stmt.cond.to_bin().unwrap();
@@ -3159,7 +3159,7 @@ mod tests {
     }
 
     #[test]
-    fn parse_struct_lit_if() {
+    fn parse_value_lit_if() {
         let (expr, _) = parse_expr("if i < n { }");
         let ifexpr = expr.to_if().unwrap();
         let bin = ifexpr.cond.expr.as_ref().unwrap().to_bin().unwrap();