Add constant support for windows-rdl (#3882)

Author: kennykerr

crates/libs/rdl/src/reader/const.rs

@@ -0,0 +1,21 @@
+use super::*;
+
+pub fn encode_const(encoder: &mut Encoder, item: &syntax::Const) -> Result<(), Error> {
+    let name = item.name.to_string();
+    let ty = encode_type(encoder, &item.ty)?;
+    let value = encode_value(encoder, &ty, &item.expr)?;
+
+    let field = encoder.output.Field(
+        &name,
+        &ty,
+        metadata::FieldAttributes::Public
+            | metadata::FieldAttributes::Static
+            | metadata::FieldAttributes::Literal,
+    );
+
+    encoder
+        .output
+        .Constant(metadata::writer::HasConstant::Field(field), &value);
+
+    Ok(())
+}

crates/libs/rdl/src/reader/mod.rs

@@ -1,3 +1,4 @@
+mod r#const;
 mod r#enum;
 mod r#fn;
 mod index;
@@ -10,6 +11,7 @@ use super::*;
 use index::*;
 use interface::*;
 use param::*;
+use r#const::*;
 use r#enum::*;
 use r#fn::*;
 use r#struct::*;
@@ -288,6 +290,7 @@ fn encode_item(
         syntax::Item::Interface(ty) => encode_interface(encoder, ty),
         syntax::Item::Union(ty) => encode_union(encoder, ty),
         syntax::Item::Fn(ty) => encode_fn(encoder, ty),
+        syntax::Item::Const(ty) => encode_const(encoder, ty),
         rest => todo!("{rest:?}"),
     }
 }
@@ -301,6 +304,70 @@ fn encode_type(encoder: &Encoder, ty: &syn::Type) -> Result<metadata::Type, Erro
     }
 }
 
+fn encode_value(
+    encoder: &Encoder,
+    ty: &metadata::Type,
+    value: &syn::Expr,
+) -> Result<metadata::Value, Error> {
+    let value = match ty {
+        metadata::Type::I8 => metadata::Value::I8(encode_neg_lit_int::<i8>(encoder, value)?),
+        metadata::Type::U8 => metadata::Value::U8(encode_lit_int::<u8>(encoder, value)?),
+        metadata::Type::I16 => metadata::Value::I16(encode_neg_lit_int::<i16>(encoder, value)?),
+        metadata::Type::U16 => metadata::Value::U16(encode_lit_int::<u16>(encoder, value)?),
+        metadata::Type::I32 => metadata::Value::I32(encode_neg_lit_int::<i32>(encoder, value)?),
+        metadata::Type::U32 => metadata::Value::U32(encode_lit_int::<u32>(encoder, value)?),
+        metadata::Type::I64 => metadata::Value::I64(encode_neg_lit_int::<i64>(encoder, value)?),
+        metadata::Type::U64 => metadata::Value::U64(encode_lit_int::<u64>(encoder, value)?),
+        rest => todo!("{rest:?}"),
+    };
+
+    Ok(value)
+}
+
+fn encode_neg_lit_int<T>(encoder: &Encoder, expr: &syn::Expr) -> Result<T, Error>
+where
+    T: std::str::FromStr + std::ops::Neg<Output = T>,
+    T::Err: std::fmt::Display,
+{
+    let value = match expr {
+        syn::Expr::Lit(syn::ExprLit {
+            lit: syn::Lit::Int(int),
+            ..
+        }) => int.base10_parse().ok(),
+        syn::Expr::Unary(syn::ExprUnary {
+            op: syn::UnOp::Neg(_),
+            expr,
+            ..
+        }) => match expr.as_ref() {
+            syn::Expr::Lit(syn::ExprLit {
+                lit: syn::Lit::Int(int),
+                ..
+            }) => int.base10_parse().ok().map(|value: T| -value),
+            _ => None,
+        },
+        _ => None,
+    };
+
+    value.ok_or_else(|| encoder.error(expr, "value not valid"))
+}
+
+fn encode_lit_int<T>(encoder: &Encoder, expr: &syn::Expr) -> Result<T, Error>
+where
+    T: std::str::FromStr,
+    T::Err: std::fmt::Display,
+{
+    let value = match expr {
+        syn::Expr::Lit(syn::ExprLit {
+            lit: syn::Lit::Int(int),
+            ..
+        }) => int.base10_parse().ok(),
+
+        _ => None,
+    };
+
+    value.ok_or_else(|| encoder.error(expr, "value not valid"))
+}
+
 fn encode_type_reference(
     encoder: &Encoder,
     ty: &syn::TypeReference,

crates/libs/rdl/src/syntax/item.rs

@@ -66,6 +66,8 @@ impl syn::parse::Parse for Item {
             input.parse().map(Item::Union)
         } else if lookahead.peek(syn::Token![fn]) {
             input.parse().map(Item::Fn)
+        } else if lookahead.peek(syn::Token![const]) {
+            input.parse().map(Item::Const)
         } else {
             Err(lookahead.error())
         }?;

crates/libs/rdl/src/writer/mod.rs

@@ -163,12 +163,20 @@ fn rustfmt(tokens: &str) -> Option<String> {
 fn write(namespace: &str, item: &metadata::reader::Item) -> TokenStream {
     match item {
         metadata::reader::Item::Type(ty) => write_type_def(ty),
-        metadata::reader::Item::Fn(ty) => write_method_def(namespace, ty),
-        rest => todo!("{rest:?}"),
+        metadata::reader::Item::Fn(ty) => write_fn(namespace, ty),
+        metadata::reader::Item::Const(ty) => write_const(namespace, ty),
     }
 }
 
-fn write_method_def(namespace: &str, item: &metadata::reader::MethodDef) -> TokenStream {
+fn write_const(namespace: &str, item: &metadata::reader::Field) -> TokenStream {
+    let name = format_ident!("{}", item.name());
+    let constant = item.constant().expect("field missing constant");
+    let ty = write_type(namespace, &item.ty());
+    let value = write_value(&constant.value());
+    quote! { const #name: #ty = #value; }
+}
+
+fn write_fn(namespace: &str, item: &metadata::reader::MethodDef) -> TokenStream {
     let name = format_ident!("{}", item.name());
     let signature = item.signature(&[]);
 

crates/libs/rdl/tests/const.rdl

@@ -0,0 +1,11 @@
+#[win32]
+mod Test {
+    const I16: i16 = -16;
+    const I32: i32 = -32;
+    const I64: i64 = -64;
+    const I8: i8 = -8;
+    const U16: u16 = 16;
+    const U32: u32 = 32;
+    const U64: u64 = 64;
+    const U8: u8 = 8;
+}

crates/libs/rdl/tests/const.rs

@@ -0,0 +1,17 @@
+use windows_rdl::*;
+
+#[test]
+pub fn parse() {
+    Reader::new()
+        .input("tests/const.rdl")
+        .output("tests/const.winmd")
+        .write()
+        .unwrap();
+
+    Writer::new()
+        .input("tests/const.winmd")
+        .output("tests/const.rdl")
+        .namespace("Test")
+        .write()
+        .unwrap();
+}