Format improvements (WIP)

src/ast/meta.rs

@@ -574,7 +574,7 @@ impl ToMeta for f32 {
     fn to_meta(&self) -> Meta { Meta::Scalar(sp!((*self).into())) }
 }
 impl ToMeta for bool {
-    fn to_meta(&self) -> Meta { Meta::Scalar(sp!(ast::Expr::LitInt { value: *self as i32, radix: ast::IntRadix::Bool })) }
+    fn to_meta(&self) -> Meta { Meta::Scalar(sp!(ast::Expr::LitInt { value: *self as i32, format: ast::IntFormat { unsigned: true, radix: ast::IntRadix::Bool } })) }
 }
 impl ToMeta for String {
     fn to_meta(&self) -> Meta { Meta::Scalar(sp!(self.to_owned().into())) }

src/ast/mod.rs

@@ -462,7 +462,7 @@ pub enum Expr {
         value: raw::LangInt,
         /// A hint to the formatter on how it should write the integer.
         /// (may not necessarily represent the original radix of a parsed token)
-        radix: IntRadix,
+        format: IntFormat,
     },
     LitFloat { value: raw::LangFloat },
     LitString(LitString),
@@ -476,14 +476,18 @@ pub enum Expr {
     },
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct IntFormat {
+    pub unsigned: bool,
+    pub radix: IntRadix,
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum IntRadix {
     /// Display as decimal.
     Dec,
     /// Display as hexadecimal, with an `0x` prefix.
     Hex,
-    /// Display as potentially negative hexadecimal, with an `0x` prefix.
-    SignedHex,
     /// Display as binary, with an `0b` prefix.
     Bin,
     /// Use `true` and `false` if the value is `1` or `0`.  Otherwise, fall back to decimal.
@@ -848,7 +852,7 @@ string_enum! {
 }
 
 impl From<raw::LangInt> for Expr {
-    fn from(value: raw::LangInt) -> Expr { Expr::LitInt { value, radix: IntRadix::Dec } }
+    fn from(value: raw::LangInt) -> Expr { Expr::LitInt { value, format: IntFormat { unsigned: false, radix: IntRadix::Dec } } }
 }
 impl From<raw::LangFloat> for Expr {
     fn from(value: raw::LangFloat) -> Expr { Expr::LitFloat { value } }
@@ -1266,7 +1270,7 @@ macro_rules! generate_visitor_stuff {
                 Expr::XcrementOp { op: _, order: _, var } => {
                     v.visit_var(var);
                 },
-                Expr::LitInt { value: _, radix: _ } => {},
+                Expr::LitInt { value: _, format: _ } => {},
                 Expr::LitFloat { value: _ } => {},
                 Expr::LitString(_s) => {},
                 Expr::LabelProperty { .. } => {},

src/context/defs.rs

@@ -1114,34 +1114,18 @@ impl Signature {
         signature_from_func_ast(ty_keyword, params)
     }
 
-    pub(crate) fn validate(&self, ctx: &CompilerContext) -> Result<(), ErrorReported> {
-        self._check_non_optional_after_optional(ctx)
-    }
-
-    fn _check_non_optional_after_optional(&self, ctx: &CompilerContext) -> Result<(), ErrorReported> {
-        let mut first_optional = None;
-        for param in self.params.iter() {
-            if param.default.is_some() {
-                first_optional = Some(param);
-            } else if let Some(optional) = first_optional {
-                return Err(ctx.emitter.emit(error!(
-                    message("invalid function signature"),
-                    secondary(optional.useful_span, "optional parameter"),
-                    primary(param.useful_span, "non-optional parameter after optional"),
-                )));
-            }
-        }
+    pub(crate) fn validate(&self, _ctx: &CompilerContext) -> Result<(), ErrorReported> {
         Ok(())
     }
 
     /// Minimum number of arguments accepted.
     pub fn min_args(&self) -> usize {
-        self.params.iter().take_while(|param| param.default.is_none()).count()
+        self.params.iter().fold(0, |count, param| count + param.default.is_none() as usize)
     }
 
     /// Maximum number of arguments accepted.
     pub fn max_args(&self) -> usize {
-        self.params.len()
+        self.min_args()
     }
 
     /// Matches arguments at a call site to their corresponding parameters.

src/core_mapfiles/std.rs

@@ -22,9 +22,9 @@ static STD_06: &CoreSignatures = &CoreSignatures {
         (Th06, 0, Some(("fff", None))),
         (Th06, 1, Some(("Cff", None))),
         (Th06, 2, Some(("fff", None))),
-        (Th06, 3, Some(("S__", None))),
-        (Th06, 4, Some(("S__", None))),
-        (Th06, 5, Some(("___", None))),
+        (Th06, 3, Some(("S________", None))),
+        (Th06, 4, Some(("S________", None))),
+        (Th06, 5, Some(("____________", None))),
     ],
     var: &[],
 };
@@ -34,40 +34,40 @@ static STD_07_09: &CoreSignatures = &CoreSignatures {
     ins: &[
         (Th07, 0, Some(("fff", None))),
         (Th07, 1, Some(("Cff", None))),
-        (Th07, 2, Some(("S__", None))),
-        (Th07, 3, Some(("___", None))),
-        (Th07, 4, Some(("ot_", Some(IKind::Jmp)))),
+        (Th07, 2, Some(("S________", None))),
+        (Th07, 3, Some(("____________", None))),
+        (Th07, 4, Some(("ot____", Some(IKind::Jmp)))),
         (Th07, 5, Some(("fff", None))),
-        (Th07, 6, Some(("SS_", None))),
+        (Th07, 6, Some(("SS____", None))),
         (Th07, 7, Some(("fff", None))),
-        (Th07, 8, Some(("SS_", None))),
+        (Th07, 8, Some(("SS____", None))),
         (Th07, 9, Some(("fff", None))),
-        (Th07, 10, Some(("SS_", None))),
-        (Th07, 11, Some(("f__", None))),
-        (Th07, 12, Some(("SS_", None))),
-        (Th07, 13, Some(("C__", None))),
+        (Th07, 10, Some(("SS____", None))),
+        (Th07, 11, Some(("f________", None))),
+        (Th07, 12, Some(("SS____", None))),
+        (Th07, 13, Some(("C________", None))),
         (Th07, 14, Some(("fff", None))),
         (Th07, 15, Some(("fff", None))),
         (Th07, 16, Some(("fff", None))),
         (Th07, 17, Some(("fff", None))),
-        (Th07, 18, Some(("S__", None))),
+        (Th07, 18, Some(("S________", None))),
         (Th07, 19, Some(("fff", None))),
         (Th07, 20, Some(("fff", None))),
         (Th07, 21, Some(("fff", None))),
         (Th07, 22, Some(("fff", None))),
-        (Th07, 23, Some(("S__", None))),
+        (Th07, 23, Some(("S________", None))),
         (Th07, 24, Some(("fff", None))),
         (Th07, 25, Some(("fff", None))),
         (Th07, 26, Some(("fff", None))),
         (Th07, 27, Some(("fff", None))),
-        (Th07, 28, Some(("S__", None))),
-        (Th07, 29, Some(("S__", None))),  // anm script
-        (Th07, 30, Some(("S__", None))),  // anm script
-        (Th07, 31, Some(("S__", Some(IKind::InterruptLabel)))),
+        (Th07, 28, Some(("S________", None))),
+        (Th07, 29, Some(("S________", None))),  // anm script
+        (Th07, 30, Some(("S________", None))),  // anm script
+        (Th07, 31, Some(("S________", Some(IKind::InterruptLabel)))),
 
         (Th08, 32, Some(("fff", None))),
-        (Th08, 33, Some(("S__", None))),
-        (Th08, 34, Some(("S__", None))),  // anm script
+        (Th08, 33, Some(("S________", None))),
+        (Th08, 34, Some(("S________", None))),  // anm script
     ],
     var: &[],
 };

src/fmt.rs

@@ -904,13 +904,15 @@ impl Format for ast::Expr {
             ast::Expr::XcrementOp { order: ast::XcrementOpOrder::Pre, op, var } => out.fmt((op, var)),
             ast::Expr::XcrementOp { order: ast::XcrementOpOrder::Post, op, var } => out.fmt((var, op)),
             ast::Expr::EnumConst { enum_name, ident } => out.fmt((enum_name, ".", ident)),
-            ast::Expr::LitInt { value: 0, radix: ast::IntRadix::Bool } => out.fmt("false"),
-            ast::Expr::LitInt { value: 1, radix: ast::IntRadix::Bool } => out.fmt("true"),
-            ast::Expr::LitInt { value, radix: ast::IntRadix::Bool } => out.fmt(value),
-            ast::Expr::LitInt { value, radix: ast::IntRadix::Dec } => out.fmt(value),
-            ast::Expr::LitInt { value, radix: ast::IntRadix::Hex } => out.fmt(format_args!("{:#x}", value)),
-            ast::Expr::LitInt { value, radix: ast::IntRadix::SignedHex } => out.fmt(format_args!("{:#x}", SignedRadix(*value))),
-            ast::Expr::LitInt { value, radix: ast::IntRadix::Bin } => out.fmt(format_args!("{:#b}", value)),
+            ast::Expr::LitInt { value: 0, format: ast::IntFormat { unsigned: _, radix: ast::IntRadix::Bool } } => out.fmt("false"),
+            ast::Expr::LitInt { value: 1, format: ast::IntFormat { unsigned: _, radix: ast::IntRadix::Bool } } => out.fmt("true"),
+            ast::Expr::LitInt { value, format: ast::IntFormat { unsigned: false, radix: ast::IntRadix::Bool } } => out.fmt(value),
+            ast::Expr::LitInt { value, format: ast::IntFormat { unsigned: true, radix: ast::IntRadix::Bool } } => out.fmt(format_args!("{}", *value as u32)),
+            ast::Expr::LitInt { value, format: ast::IntFormat { unsigned: false, radix: ast::IntRadix::Dec } } => out.fmt(value),
+            ast::Expr::LitInt { value, format: ast::IntFormat { unsigned: true, radix: ast::IntRadix::Dec } } => out.fmt(format_args!("{}", *value as u32)),
+            ast::Expr::LitInt { value, format: ast::IntFormat { unsigned: true, radix: ast::IntRadix::Hex } } => out.fmt(format_args!("{:#x}", value)),
+            ast::Expr::LitInt { value, format: ast::IntFormat { unsigned: false, radix: ast::IntRadix::Hex } } => out.fmt(format_args!("{:#x}", SignedRadix(*value))),
+            ast::Expr::LitInt { value, format: ast::IntFormat { unsigned: _, radix: ast::IntRadix::Bin } } => out.fmt(format_args!("{:#b}", value)),
             ast::Expr::LitFloat { value } => out.fmt(value),
             ast::Expr::LitString(x) => out.fmt(x),
             ast::Expr::LabelProperty { label, keyword } => out.fmt((keyword, "(", label, ")")),

src/formats/anm/mod.rs

@@ -701,7 +701,7 @@ fn format_to_meta(format_num: u32) -> Meta {
 }
 
 fn colorkey_to_meta(colorkey: u32) -> impl ToMeta {
-    ast::Expr::LitInt { value: colorkey as i32, radix: ast::IntRadix::Hex }
+    ast::Expr::LitInt { value: colorkey as i32, format: ast::IntFormat { unsigned: true, radix: ast::IntRadix::Hex } }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]