Add an option shorthand

tools/witx/src/ast.rs

@@ -447,6 +447,29 @@ impl Variant {
         }
     }
 
+    /// If this variant looks like an `option` shorthand, return the type
+    /// associated with option.
+    ///
+    /// Only matches variants fo the form:
+    ///
+    /// ```text
+    /// (variant
+    ///     (case "none")
+    ///     (case "some" ty))
+    /// ```
+    pub fn as_option(&self) -> Option<&TypeRef> {
+        if self.cases.len() != 2 {
+            return None;
+        }
+        if self.cases[0].name != "none" || self.cases[0].tref.is_some() {
+            return None;
+        }
+        if self.cases[1].name != "some" {
+            return None;
+        }
+        self.cases[1].tref.as_ref()
+    }
+
     /// If this variant looks like an `expected` shorthand, return the ok/err
     /// types associated with this result.
     ///

tools/witx/src/parser.rs

@@ -53,6 +53,7 @@ mod kw {
     wast::custom_keyword!(usize);
     wast::custom_keyword!(variant);
     wast::custom_keyword!(bool_ = "bool");
+    wast::custom_keyword!(option);
 }
 
 mod annotation {
@@ -283,6 +284,7 @@ pub enum TypedefSyntax<'a> {
     Enum(EnumSyntax<'a>),
     Tuple(TupleSyntax<'a>),
     Expected(ExpectedSyntax<'a>),
+    Option(OptionSyntax<'a>),
     Flags(FlagsSyntax<'a>),
     Record(RecordSyntax<'a>),
     Union(UnionSyntax<'a>),
@@ -319,6 +321,8 @@ impl<'a> Parse<'a> for TypedefSyntax<'a> {
                     Ok(TypedefSyntax::Tuple(parser.parse()?))
                 } else if l.peek::<kw::expected>() {
                     Ok(TypedefSyntax::Expected(parser.parse()?))
+                } else if l.peek::<kw::option>() {
+                    Ok(TypedefSyntax::Option(parser.parse()?))
                 } else if l.peek::<kw::flags>() {
                     Ok(TypedefSyntax::Flags(parser.parse()?))
                 } else if l.peek::<kw::record>() {
@@ -433,6 +437,19 @@ impl<'a> Parse<'a> for ExpectedSyntax<'a> {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct OptionSyntax<'a> {
+    pub ty: Box<TypedefSyntax<'a>>,
+}
+
+impl<'a> Parse<'a> for OptionSyntax<'a> {
+    fn parse(parser: Parser<'a>) -> Result<Self> {
+        parser.parse::<kw::option>()?;
+        let ty = Box::new(parser.parse()?);
+        Ok(OptionSyntax { ty })
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ConstSyntax<'a> {
     pub ty: wast::Id<'a>,

tools/witx/src/validate.rs

@@ -2,8 +2,8 @@ use crate::{
     io::{Filesystem, WitxIo},
     parser::{
         CommentSyntax, DeclSyntax, Documented, EnumSyntax, ExpectedSyntax, FlagsSyntax,
-        HandleSyntax, ImportTypeSyntax, ModuleDeclSyntax, RecordSyntax, TupleSyntax, TypedefSyntax,
-        UnionSyntax, VariantSyntax,
+        HandleSyntax, ImportTypeSyntax, ModuleDeclSyntax, OptionSyntax, RecordSyntax, TupleSyntax,
+        TypedefSyntax, UnionSyntax, VariantSyntax,
     },
     BuiltinType, Case, Constant, Definition, Document, Entry, HandleDatatype, Id, IntRepr,
     InterfaceFunc, InterfaceFuncParam, Location, Module, ModuleDefinition, ModuleEntry,
@@ -309,6 +309,9 @@ impl DocValidationScope<'_> {
                 TypedefSyntax::Expected(syntax) => {
                     Type::Variant(self.validate_expected(&syntax, span)?)
                 }
+                TypedefSyntax::Option(syntax) => {
+                    Type::Variant(self.validate_option(&syntax, span)?)
+                }
                 TypedefSyntax::Flags(syntax) => Type::Record(self.validate_flags(&syntax, span)?),
                 TypedefSyntax::Record(syntax) => Type::Record(self.validate_record(&syntax, span)?),
                 TypedefSyntax::Union(syntax) => Type::Variant(self.validate_union(&syntax, span)?),
@@ -416,6 +419,29 @@ impl DocValidationScope<'_> {
         })
     }
 
+    fn validate_option(
+        &self,
+        syntax: &OptionSyntax,
+        span: wast::Span,
+    ) -> Result<Variant, ValidationError> {
+        let tref = self.validate_datatype(&syntax.ty, false, span)?;
+        Ok(Variant {
+            tag_repr: IntRepr::U8,
+            cases: vec![
+                Case {
+                    name: Id::new("none"),
+                    tref: None,
+                    docs: String::new(),
+                },
+                Case {
+                    name: Id::new("some"),
+                    tref: Some(tref),
+                    docs: String::new(),
+                },
+            ],
+        })
+    }
+
     fn validate_flags(
         &self,
         syntax: &FlagsSyntax,

tools/witx/tests/witxt/shorthand.witxt

@@ -57,3 +57,9 @@
 (witx $b
   (typename $a (variant (case $0 u32) (case $1 u64))))
 (assert_representable eq $a "a" $b "a")
+
+(witx $a
+  (typename $a (option u32)))
+(witx $b
+  (typename $a (variant (case $none) (case $some u32))))
+(assert_representable eq $a "a" $b "a")