char literals

lumina-compiler/src/hir/expr.rs

@@ -73,6 +73,7 @@ pub enum Literal<'s> {
     Int(bool, u128, Var),
     Float(f64),
     String(&'s str),
+    Char(&'s str),
 }
 
 impl<'t, 'a, 's> FuncLower<'t, 'a, 's> {
@@ -96,6 +97,7 @@ impl<'t, 'a, 's> FuncLower<'t, 'a, 's> {
             }
             parser::Expr::Lit(parser::Literal::Float(n)) => Expr::Lit(Literal::Float(*n)),
             parser::Expr::Lit(parser::Literal::String(str)) => Expr::Lit(Literal::String(*str)),
+            parser::Expr::Lit(parser::Literal::Char(c)) => Expr::Lit(Literal::Char(*c)),
             parser::Expr::Call(apath, params) => self.callable(apath.as_ref(), params, Expr::Call),
             parser::Expr::Lambda(patterns, params, body) => {
                 let lambda = self.lambda(patterns, None, (**body).as_ref());

lumina-compiler/src/mir/expr.rs

@@ -165,6 +165,7 @@ impl<'a, 's> Verify<'a, 's> {
                     let record = self.items.pinfo.string;
                     IType::string(record, vec![])
                 }
+                hir::Literal::Char(_) => IType::int(false, 8),
             },
             hir::Expr::Poison => IType::poison(),
         }

lumina-compiler/src/mir/lower/expr.rs

@@ -240,7 +240,7 @@ impl<'a, 's> Lower<'a, 's> {
 
                 Expr::Record(key, params, unordered_fields)
             }
-            hir::Expr::Lit(lit) => self.lower_literal(lit),
+            hir::Expr::Lit(lit) => self.lower_literal(expr.span, lit),
             hir::Expr::Tuple(elems) => Expr::Tuple(self.lower_exprs(elems)),
             hir::Expr::List(elems, var) => self.lower_list(elems, *var),
             hir::Expr::Array(elems, arr) => self.lower_array(expr.span, elems, *arr),
@@ -280,7 +280,7 @@ impl<'a, 's> Lower<'a, 's> {
             .collect()
     }
 
-    fn lower_literal(&mut self, lit: &hir::Literal<'s>) -> Expr {
+    fn lower_literal(&mut self, span: Span, lit: &hir::Literal<'s>) -> Expr {
         match lit {
             hir::Literal::Bool(b) => Expr::Bool(*b),
             hir::Literal::Int(neg, n, nvar) => {
@@ -292,6 +292,16 @@ impl<'a, 's> Lower<'a, 's> {
                 Expr::Int(intsize, neg.then(|| -n).unwrap_or(n))
             }
             hir::Literal::Float(f) => Expr::Float(*f),
+            hir::Literal::Char(str) => {
+                let str = self.escape(str);
+                if str.len() != 1 {
+                    self.errors.push(FinError::LargeCharLiteral(span));
+                    Expr::Poison
+                } else {
+                    let byte = str[0];
+                    Expr::Int(IntSize::new(false, 8), byte as i128)
+                }
+            }
             hir::Literal::String(str) => {
                 let ro_key = self.str_to_ro(*str);
 

lumina-compiler/src/mir/lower/mod.rs

@@ -96,6 +96,7 @@ pub enum FinError {
     UnreachablePattern(Span),
     MissingPatterns(Span, Vec<pat::MissingPattern>),
     InvalidCast(Tr<Type>, Type),
+    LargeCharLiteral(Span),
     BadArrayCount { got: Tr<usize>, exp: Tr<u64> },
     BadGenericArrayCount { got: Tr<usize> },
     DuplicateField(Tr<String>, Span),
@@ -137,13 +138,13 @@ impl<'a, 's> Lower<'a, 's> {
         }
     }
 
-    fn str_to_ro(&mut self, str: &'s str) -> M<key::ReadOnly> {
+    fn escape(&self, str: &'s str) -> Vec<u8> {
         let mut buffer = Vec::with_capacity(str.len());
         let mut bytes = str.bytes();
 
         loop {
             let Some(mut b) = bytes.next() else {
-                break;
+                break buffer;
             };
 
             match b {
@@ -163,14 +164,18 @@ impl<'a, 's> Lower<'a, 's> {
 
             buffer.push(b);
         }
+    }
+
+    fn str_to_ro(&mut self, str: &'s str) -> M<key::ReadOnly> {
+        let str = self.escape(str);
 
         // We set the type to `u8` because when this data is accessed
         // with ReadOnly, it's treated by-reference so it'll become `*u8`
         let ty = Type::u8();
 
         self.read_only_table.push(
             self.current.fkey.0,
-            (mir::ReadOnlyBytes(buffer.into_boxed_slice()), ty),
+            (mir::ReadOnlyBytes(str.into_boxed_slice()), ty),
         )
     }
 
@@ -369,6 +374,14 @@ pub fn emit_fin_error<'s>(
     error: FinError,
 ) {
     match error {
+        FinError::LargeCharLiteral(span) => sources
+            .error("invalid char literal")
+            .m(module)
+            .eline(
+                span.move_indice(1),
+                "char literals may only be used to represent a single character",
+            )
+            .emit(),
         FinError::DuplicateField(field, previous) => sources
             .error("field assigned twice")
             .m(module)

lumina-parser/src/expr.rs

@@ -61,6 +61,7 @@ pub enum Literal<'a> {
     Int(bool, u128),
     Float(f64),
     String(&'a str),
+    Char(&'a str),
 }
 
 pub(super) struct ExprParser<'p, 'a> {
@@ -235,6 +236,7 @@ impl<'p, 'a> ExprParser<'p, 'a> {
             T::Path => self.expr_path(span, true),
             T::Default => self.expr_path(span, true),
             T::StringLiteral => self.expr_string(span),
+            T::CharLiteral => self.expr_char(span),
             T::OpenParen => self.expr_parenthesis(span),
             T::OpenCurly => self.expr_record(span),
             T::OpenList => self.expr_list(span),
@@ -261,6 +263,7 @@ impl<'p, 'a> ExprParser<'p, 'a> {
             T::Path => self.expr_path(span, false),
             T::Default => self.expr_path(span, false),
             T::StringLiteral => self.expr_string(span),
+            T::CharLiteral => self.expr_char(span),
             T::OpenParen => self.expr_parenthesis(span),
             T::OpenCurly => self.expr_record(span),
             T::OpenList => self.expr_list(span),
@@ -470,6 +473,11 @@ impl<'p, 'a> ExprParser<'p, 'a> {
         Some(Expr::Lit(Literal::String(self.parser.take(inner_span))).tr(span))
     }
 
+    fn expr_char(&mut self, span: Span) -> Option<Tr<Expr<'a>>> {
+        let inner_span = span.move_indice(1).extend_length(-1);
+        Some(Expr::Lit(Literal::Char(self.parser.take(inner_span))).tr(span))
+    }
+
     fn expr_parenthesis(&mut self, span: Span) -> Option<Tr<Expr<'a>>> {
         let (mut elems, end) = self
             .parser
@@ -837,6 +845,7 @@ impl<'a> fmt::Display for Literal<'a> {
             Literal::Int(false, n) => n.fmt(f),
             Literal::Float(n) => n.fmt(f),
             Literal::String(str) => write!(f, "\"{str}\""),
+            Literal::Char(c) => write!(f, "\'{c}\'"),
         }
     }
 }

lumina-parser/src/lexer.rs

@@ -1,15 +1,15 @@
 use logos::{Lexer as LogosLexer, Logos, SpannedIter};
 use lumina_util::Span;
 
-fn find_str_end<'src>(lex: &mut LogosLexer<'src, Token>) {
+fn find_str_end<'src>(end: u8, lex: &mut LogosLexer<'src, Token>) {
     let mut i = 0;
     let bytes = lex.remainder().as_bytes();
 
     while let Some(&c) = bytes.get(i) {
         match c {
-            b'\\' if bytes.get(i + 1) == Some(&b'"') => i += 2,
+            b'\\' if bytes.get(i + 1) == Some(&end) => i += 2,
             b'\\' if bytes.get(i + 1) == Some(&b'\\') => i += 2,
-            b'"' => break,
+            c if c == end => break,
             _ => i += 1,
         }
     }
@@ -24,8 +24,10 @@ pub enum Token {
     #[regex("\\n+")]
     NewLines,
 
-    #[token("\"", find_str_end)]
+    #[token("\"", |lex| find_str_end(b'"', lex))]
     StringLiteral,
+    #[token("'", |lex| find_str_end(b'\'', lex))]
+    CharLiteral,
 
     #[regex("\\-?\\d+")]
     Int,
@@ -177,6 +179,7 @@ impl Token {
             T::Val => "static",
             T::LineDocComment | T::LineComment => "documentation comment",
             T::StringLiteral => "string literal",
+            T::CharLiteral => "char literal",
             T::If => "start of if expression",
             T::Bar => "vertical bar",
             T::Can => "`can` keyword",

luminapath/std/char/lib.lm

@@ -0,0 +1 @@
+// Placeholder module until proper utf-8 support is implemented