Added support for sizeof operator on expressions, and changed shorthand generics syntax to use '#' instead of '-'

Author: IsaacShelton

Diff for: src/ast/expr/kind.rs

@@ -34,6 +34,7 @@ pub enum ExprKind {
     StaticMemberValue(Box<StaticMemberValue>),
     StaticMemberCall(Box<StaticMemberCall>),
     SizeOf(Box<Type>),
+    SizeOfValue(Box<Expr>),
     InterpreterSyscall(Box<InterpreterSyscall>),
 }
 

Diff for: src/lexer/mod.rs

@@ -522,7 +522,7 @@ impl<T: Text + Send> Lexer<T> {
     fn feed_short_generic(&mut self) -> FeedResult<Token> {
         self.state = State::Idle;
 
-        if let Ok(source) = self.characters.eat_remember('-') {
+        if let Ok(source) = self.characters.eat_remember('#') {
             FeedResult::Has(TokenKind::ShortGeneric.at(source))
         } else {
             self.feed_idle()

Diff for: src/parser/parse_expr/primary/mod.rs

@@ -159,9 +159,15 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                                     .at(source));
                                 };
 
-                                let TypeArg::Type(ty) = arg else {
+                                let expr = if let TypeArg::Type(ty) = arg {
+                                    ExprKind::SizeOf(Box::new(ty)).at(source)
+                                } else if let TypeArg::Expr(value) = arg {
+                                    ExprKind::SizeOfValue(Box::new(value)).at(source)
+                                } else {
                                     return Err(ParseErrorKind::Other {
-                                        message: "Cannot get size of non-type value".into(),
+                                        message:
+                                            "Cannot get size of compile-time value that isn't type or expression"
+                                                .into(),
                                     }
                                     .at(source));
                                 };
@@ -173,7 +179,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                                     .at(source));
                                 };
 
-                                return Ok(ExprKind::SizeOf(Box::new(ty)).at(source));
+                                return Ok(expr);
                             }
 
                             return Err(ParseErrorKind::Other {

Diff for: src/parser/parse_type.rs

@@ -93,7 +93,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         Ok(if self.input.peek().could_start_type() {
             TypeArg::Type(self.parse_type(None::<&str>, Some("for compile time argument"))?)
         } else {
-            TypeArg::Expr(self.parse_expr_primary()?)
+            TypeArg::Expr(self.parse_expr_primary_base()?)
         })
     }
 

Diff for: src/resolve/expr/mod.rs

@@ -383,6 +383,21 @@ pub fn resolve_expr(
                 asg::ExprKind::SizeOf(Box::new(ty)).at(source),
             ))
         }
+        ast::ExprKind::SizeOfValue(value) => {
+            let ty = resolve_expr(
+                ctx,
+                value,
+                preferred_type,
+                initialized,
+                ResolveExprMode::RequireValue,
+            )?
+            .ty;
+
+            Ok(TypedExpr::new(
+                asg::TypeKind::Integer(IntegerBits::Bits64, IntegerSign::Unsigned).at(source),
+                asg::ExprKind::SizeOf(Box::new(ty)).at(source),
+            ))
+        }
         ast::ExprKind::InterpreterSyscall(info) => {
             let ast::InterpreterSyscall {
                 kind,

Diff for: src/token.rs

@@ -232,7 +232,7 @@ impl Display for TokenKind {
             TokenKind::StaticMember => f.write_str("'::'"),
             TokenKind::Extend => f.write_str("'..'"),
             TokenKind::FatArrow => f.write_str("'=>'"),
-            TokenKind::ShortGeneric => f.write_str("short generic '-'"),
+            TokenKind::ShortGeneric => f.write_str("short generic '#'"),
         }
     }
 }

Diff for: tests/success/generics_shorthand/main.adept

@@ -2,10 +2,10 @@
 pragma => adept("3.0")
 
 #[foreign]
-func printf(format ptr-char, ...) int
+func printf(format ptr#char, ...) int
 
 func main {
-    message ptr-char = c"Hello from generics shorthand example!"
+    message ptr#char = c"Hello from generics shorthand example!"
     printf(c"%s\n", message)
 }
 

Diff for: tests/success/null/main.adept

@@ -2,10 +2,10 @@
 pragma => adept("3.0")
 
 #[foreign]
-func printf(format ptr-char, ...) int
+func printf(format ptr#char, ...) int
 
 func main {
-    message ptr<char> = null
+    message ptr#char = null
     printf(c"message\t= %010p\n", message)
     printf(c"null\t= %010p\n", null)
 }

Diff for: tests/success/sizeof/main.adept

@@ -2,18 +2,18 @@
 pragma => adept("3.0")
 
 #[foreign]
-func printf(format ptr-char, ...) int
+func printf(format ptr#char, ...) int
 
-struct FullName (firstname ptr-char, lastname ptr-char)
+struct FullName (firstname ptr#char, lastname ptr#char)
 
 func main {
-    printf(c"sizeof-char = %d\n", sizeof-char.int())
-    printf(c"sizeof-short = %d\n", sizeof-char.int())
-    printf(c"sizeof-int = %d\n", sizeof-int.int())
-    printf(c"sizeof-long = %d\n", sizeof-long.int())
-    printf(c"sizeof-longlong = %d\n", sizeof-longlong.int())
-    printf(c"sizeof-ptr-char = %d\n", sizeof-ptr-char.int())
-    printf(c"sizeof-double = %d\n", sizeof-double.int())
+    printf(c"sizeof#char = %d\n", sizeof#char.int())
+    printf(c"sizeof#short = %d\n", sizeof#short.int())
+    printf(c"sizeof#int = %d\n", sizeof#int.int())
+    printf(c"sizeof#long = %d\n", sizeof#long.int())
+    printf(c"sizeof#longlong = %d\n", sizeof#longlong.int())
+    printf(c"sizeof#ptr#char = %d\n", sizeof#ptr#char.int())
+    printf(c"sizeof#double = %d\n", sizeof#double.int())
 
     // This syntax is also accepted
     printf(c"sizeof<FullName> = %d\n", sizeof<FullName>.int())