Improved riddle syntax parsing and testing (#2324)

crates/libs/metadata/src/writer/imp/mod.rs

@@ -71,7 +71,7 @@ pub fn write(name: &str, winrt: bool, definitions: &[Item], assemblies: &[&str])
  Item::Enum(ty) => {
  strings.insert(&ty.namespace);
  strings.insert(&ty.name);
- let enum_type = Type::named(&ty.namespace, &ty.name);
+ let enum_type = Type::Named((ty.namespace.clone(), ty.name.clone()));
  blobs.insert(field_blob(&enum_type, definitions, references));
  blobs.insert(field_blob(&value_to_type(&ty.constants[0].value), definitions, references));
  ty.constants.iter().for_each(|constant| {
@@ -138,7 +138,7 @@ pub fn write(name: &str, winrt: bool, definitions: &[Item], assemblies: &[&str])
  FieldList: tables.Field.len() as _,
  MethodList: tables.MethodDef.len() as _,
  });
- let enum_type = Type::named(&ty.namespace, &ty.name);
+ let enum_type = Type::Named((ty.namespace.clone(), ty.name.clone()));
  let flags = FieldAttributes::PRIVATE | FieldAttributes::SPECIAL | FieldAttributes::RUNTIME_SPECIAL;
  tables.Field.push2(tables::Field {
  Flags: flags.0,

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

@@ -18,82 +18,40 @@ pub struct Struct {
  pub fields: Vec<Field>,
 }
 
-impl Struct {
- pub fn item(namespace: &str, name: &str, fields: Vec<Field>) -> Item {
- Item::Struct(Self { namespace: namespace.to_string(), name: name.to_string(), fields })
- }
-}
-
 pub struct Enum {
  pub namespace: String,
  pub name: String,
  pub constants: Vec<Constant>,
 }
 
-impl Enum {
- pub fn item(namespace: &str, name: &str, constants: Vec<Constant>) -> Item {
- Item::Enum(Self { namespace: namespace.to_string(), name: name.to_string(), constants })
- }
-}
-
 pub struct Interface {
  pub namespace: String,
  pub name: String,
  pub methods: Vec<Method>,
 }
 
-impl Interface {
- pub fn item(namespace: &str, name: &str, methods: Vec<Method>) -> Item {
- Item::Interface(Self { namespace: namespace.to_string(), name: name.to_string(), methods })
- }
-}
-
 pub struct Field {
  pub name: String,
  pub ty: Type,
 }
 
-impl Field {
- pub fn new(name: &str, ty: Type) -> Self {
- Self { name: name.to_string(), ty }
- }
-}
-
 pub struct Constant {
  pub name: String,
  pub value: Value,
 }
 
-impl Constant {
- pub fn new(name: &str, value: Value) -> Self {
- Self { name: name.to_string(), value }
- }
-}
-
 pub struct Method {
  pub name: String,
  pub return_type: Type,
  pub params: Vec<Param>,
 }
 
-impl Method {
- pub fn new(name: &str, return_type: Type, params: Vec<Param>) -> Self {
- Self { name: name.to_string(), return_type, params }
- }
-}
-
 pub struct Param {
  pub name: String,
  pub ty: Type,
  pub flags: ParamFlags,
 }
 
-impl Param {
- pub fn new(name: &str, ty: Type, flags: ParamFlags) -> Self {
- Self { name: name.to_string(), ty, flags }
- }
-}
-
 flags!(ParamFlags, u32);
 impl ParamFlags {
  pub const INPUT: Self = Self(0x1);
@@ -121,12 +79,6 @@ pub enum Type {
  Named((String, String)),
 }
 
-impl Type {
- pub fn named(namespace: &str, name: &str) -> Self {
- Self::Named((namespace.to_string(), name.to_string()))
- }
-}
-
 pub enum Value {
  Bool(bool),
  U8(u8),

crates/tests/riddle/src/lib.rs

@@ -1 +1,21 @@
+use std::process::Command;
 
+pub fn run_riddle(input: &str) -> String {
+ let mut command = Command::new("cargo.exe");
+ command.arg("install").arg("--path").arg("../../tools/riddle");
+
+ if !command.status().unwrap().success() {
+ panic!("Failed to install riddle");
+ }
+
+ let output = std::env::temp_dir().join(std::path::Path::new(input).with_extension("winmd").file_name().expect("file_name failed")).to_string_lossy().into_owned();
+
+ let mut command = Command::new("riddle.exe");
+ command.arg("-input").arg(input).arg("-output").arg(&output);
+
+ if !command.status().unwrap().success() {
+ panic!("Failed to run riddle");
+ }
+
+ output
+}

crates/tests/riddle/tests/basic.rs

@@ -1,25 +1,9 @@
-use std::process::Command;
+use test_riddle::run_riddle;
 use windows_metadata::reader::*;
 
 #[test]
-fn basic() {
- // For visual inspection: ildasm.exe %temp%\test_riddle.winmd
- let output = std::env::temp_dir().join("test_riddle.winmd").to_string_lossy().into_owned();
-
- let mut command = Command::new("cargo.exe");
- command.arg("install").arg("--path").arg("../../tools/riddle");
-
- if !command.status().unwrap().success() {
- panic!("Failed to install riddle");
- }
-
- let mut command = Command::new("riddle.exe");
- command.arg("-input").arg("src/basic.rs").arg("-output").arg(&output);
-
- if !command.status().unwrap().success() {
- panic!("Failed to run riddle");
- }
-
+fn riddle_basic() {
+ let output = run_riddle("tests/basic.idl");
  let files = File::with_default(&[&output]).expect("Failed to open winmd files");
  let reader = &Reader::new(&files);
 

crates/tests/riddle/tests/enum.idl

@@ -0,0 +1,8 @@
+mod TypeNamespace {
+ enum TypeName {
+ A,
+ B,
+ C = 42,
+ D,
+ }
+}

crates/tests/riddle/tests/enum.rs

@@ -0,0 +1,26 @@
+use test_riddle::run_riddle;
+use windows_metadata::reader::*;
+
+#[test]
+fn riddle_enum() {
+ let output = run_riddle("tests/enum.idl");
+ let files = File::with_default(&[&output]).expect("Failed to open winmd files");
+ let reader = &Reader::new(&files);
+
+ let def = reader.get(TypeName::new("TypeNamespace", "TypeName")).next().expect("Type missing");
+ assert_eq!(reader.type_def_kind(def), TypeKind::Enum);
+
+ let fields: Vec<Field> = reader.type_def_fields(def).collect();
+ assert_eq!(fields.len(), 5);
+ assert_eq!(reader.field_name(fields[0]), "value__");
+
+ assert_eq!(reader.field_name(fields[1]), "A");
+ assert_eq!(reader.field_name(fields[2]), "B");
+ assert_eq!(reader.field_name(fields[3]), "C");
+ assert_eq!(reader.field_name(fields[4]), "D");
+
+ assert!(matches!(reader.constant_value(reader.field_constant(fields[1]).expect("missing constant")), Value::I32(value) if value == 0));
+ assert!(matches!(reader.constant_value(reader.field_constant(fields[2]).expect("missing constant")), Value::I32(value) if value == 1));
+ assert!(matches!(reader.constant_value(reader.field_constant(fields[3]).expect("missing constant")), Value::I32(value) if value == 42));
+ assert!(matches!(reader.constant_value(reader.field_constant(fields[4]).expect("missing constant")), Value::I32(value) if value == 43));
+}

crates/tests/riddle/tests/struct.idl

@@ -0,0 +1,8 @@
+mod TypeNamespace {
+ struct TypeName{
+ a: i32,
+ b: f32,
+ c: u64,
+ d: f64,
+ }
+}

crates/tests/riddle/tests/struct.rs

@@ -0,0 +1,25 @@
+use test_riddle::run_riddle;
+use windows_metadata::reader::*;
+
+#[test]
+fn riddle_struct() {
+ let output = run_riddle("tests/struct.idl");
+ let files = File::with_default(&[&output]).expect("Failed to open winmd files");
+ let reader = &Reader::new(&files);
+
+ let def = reader.get(TypeName::new("TypeNamespace", "TypeName")).next().expect("Type missing");
+ assert_eq!(reader.type_def_kind(def), TypeKind::Struct);
+
+ let fields: Vec<Field> = reader.type_def_fields(def).collect();
+ assert_eq!(fields.len(), 4);
+
+ assert_eq!(reader.field_name(fields[0]), "a");
+ assert_eq!(reader.field_name(fields[1]), "b");
+ assert_eq!(reader.field_name(fields[2]), "c");
+ assert_eq!(reader.field_name(fields[3]), "d");
+
+ assert!(matches!(reader.field_type(fields[0], None), Type::I32));
+ assert!(matches!(reader.field_type(fields[1], None), Type::F32));
+ assert!(matches!(reader.field_type(fields[2], None), Type::U64));
+ assert!(matches!(reader.field_type(fields[3], None), Type::F64));
+}

crates/tools/riddle/src/main.rs

@@ -1,90 +1,8 @@
+mod syntax;
 use metadata::writer;
 use std::io::Read;
-use syn::{parse::*, *};
-
-mod keywords {
- syn::custom_keyword!(interface);
-}
-
-#[derive(Debug)]
-struct Module {
- pub name: Ident,
- pub members: Vec<ModuleMember>,
-}
-
-impl Parse for Module {
- fn parse(input: ParseStream) -> Result<Self> {
- input.parse::<Token![mod]>()?;
- let name = input.parse::<Ident>()?;
- let content;
- braced!(content in input);
- let mut members = Vec::new();
- while !content.is_empty() {
- members.push(content.parse::<ModuleMember>()?);
- }
- Ok(Self { name, members })
- }
-}
-
-#[derive(Debug)]
-enum ModuleMember {
- Module(Module),
- Interface(Interface),
-}
-
-impl Parse for ModuleMember {
- fn parse(input: ParseStream) -> Result<Self> {
- let lookahead = input.lookahead1();
- if lookahead.peek(Token![mod]) {
- Ok(ModuleMember::Module(input.parse::<Module>()?))
- } else if lookahead.peek(keywords::interface) {
- Ok(ModuleMember::Interface(input.parse::<Interface>()?))
- } else {
- Err(lookahead.error())
- }
- }
-}
-
-#[derive(Debug)]
-struct Interface {
- pub name: Ident,
- pub methods: Vec<TraitItemMethod>,
-}
-
-impl Parse for Interface {
- fn parse(input: ParseStream) -> Result<Self> {
- input.parse::<keywords::interface>()?;
- let name = input.parse::<Ident>()?;
- let content;
- braced!(content in input);
- let mut methods = Vec::new();
- while !content.is_empty() {
- methods.push(content.parse::<TraitItemMethod>()?);
- }
- Ok(Self { name, methods })
- }
-}
-
-fn module_to_writer(namespace: &str, module: &Module, items: &mut Vec<writer::Item>) -> Result<()> {
- for member in &module.members {
- match member {
- ModuleMember::Module(module) => module_to_writer(&format!("{namespace}.{}", module.name), module, items)?,
- ModuleMember::Interface(interface) => interface_to_writer(namespace, interface, items)?,
- }
- }
- Ok(())
-}
-
-fn interface_to_writer(namespace: &str, interface: &Interface, items: &mut Vec<writer::Item>) -> Result<()> {
- let mut methods = Vec::new();
-
- for method in &interface.methods {
- methods.push(writer::Method { name: method.sig.ident.to_string(), return_type: writer::Type::Void, params: vec![] });
- }
-
- items.push(writer::Interface::item(namespace, &interface.name.to_string(), methods));
- Ok(())
-}
+use syn::*;
+use syntax::*;
 
 fn main() {
  if let Err(message) = run() {
@@ -147,9 +65,10 @@ fn run() -> ToolResult {
  let mut source = String::new();
  file.read_to_string(&mut source).map_err(|_| format!("failed to read `{filename}`"))?;
 
- if let Err(error) = parse_str::<Module>(&source).and_then(|module| module_to_writer(&module.name.to_string(), &module, &mut items)) {
+ if let Err(error) = parse_str::<Module>(&source).and_then(|module| module.to_writer(module.name.to_string(), &mut items)) {
  let start = error.span().start();
- return Err(format!("{error}\n --> {}:{:?}:{:?} ", filename, start.line, start.column));
+ let filename = std::fs::canonicalize(filename).map_err(|_| format!("failed to canonicalize `{filename}`"))?;
+ return Err(format!("{error}\n --> {}:{:?}:{:?} ", filename.to_string_lossy().trim_start_matches(r#"\\?\"#), start.line, start.column));
  }
  }