diff --git a/crates/libs/bindgen/src/lib.rs b/crates/libs/bindgen/src/lib.rs
index c9eec0e95a..b52c42dbce 100644
--- a/crates/libs/bindgen/src/lib.rs
+++ b/crates/libs/bindgen/src/lib.rs
@@ -104,15 +104,15 @@ where
     let output = canonicalize(output)?;
 
     let input = read_input(&input)?;
-    let reader = metadata::Reader::new(&input);
+    let reader = metadata::Reader::new(input);
     let filter = metadata::Filter::new(&include, &exclude);
 
-    winmd::verify(&reader, &filter)?;
+    winmd::verify(reader, &filter)?;
 
     match extension(&output) {
-        "rdl" => rdl::from_reader(&reader, &filter, config, &output)?,
-        "winmd" => winmd::from_reader(&reader, &filter, config, &output)?,
-        "rs" => rust::from_reader(&reader, &filter, config, &output)?,
+        "rdl" => rdl::from_reader(reader, &filter, config, &output)?,
+        "winmd" => winmd::from_reader(reader, &filter, config, &output)?,
+        "rs" => rust::from_reader(reader, &filter, config, &output)?,
         _ => return Err(Error::new("output extension must be one of winmd/rdl/rs")),
     }
 
diff --git a/crates/libs/bindgen/src/metadata.rs b/crates/libs/bindgen/src/metadata.rs
index 13d4faa43b..7c8a55ec1b 100644
--- a/crates/libs/bindgen/src/metadata.rs
+++ b/crates/libs/bindgen/src/metadata.rs
@@ -76,37 +76,74 @@ pub enum AsyncKind {
     OperationWithProgress,
 }
 
-pub fn type_def_invoke_method(reader: &Reader, row: TypeDef) -> MethodDef {
-    reader.type_def_methods(row).find(|method| reader.method_def_name(*method) == "Invoke").expect("`Invoke` method not found")
+#[derive(Clone, PartialEq, Eq, Default)]
+pub struct Guid(pub u32, pub u16, pub u16, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8);
+
+impl Guid {
+    pub fn from_args(args: &[(String, Value)]) -> Self {
+        fn unwrap_u32(value: &Value) -> u32 {
+            match value {
+                Value::U32(value) => *value,
+                rest => unimplemented!("{rest:?}"),
+            }
+        }
+        fn unwrap_u16(value: &Value) -> u16 {
+            match value {
+                Value::U16(value) => *value,
+                rest => unimplemented!("{rest:?}"),
+            }
+        }
+        fn unwrap_u8(value: &Value) -> u8 {
+            match value {
+                Value::U8(value) => *value,
+                rest => unimplemented!("{rest:?}"),
+            }
+        }
+        Self(unwrap_u32(&args[0].1), unwrap_u16(&args[1].1), unwrap_u16(&args[2].1), unwrap_u8(&args[3].1), unwrap_u8(&args[4].1), unwrap_u8(&args[5].1), unwrap_u8(&args[6].1), unwrap_u8(&args[7].1), unwrap_u8(&args[8].1), unwrap_u8(&args[9].1), unwrap_u8(&args[10].1))
+    }
+
+    pub fn from_string_args(args: &[&str]) -> Self {
+        Self(args[0].parse().unwrap(), args[1].parse().unwrap(), args[2].parse().unwrap(), args[3].parse().unwrap(), args[4].parse().unwrap(), args[5].parse().unwrap(), args[6].parse().unwrap(), args[7].parse().unwrap(), args[8].parse().unwrap(), args[9].parse().unwrap(), args[10].parse().unwrap())
+    }
 }
 
-pub fn type_def_generics(reader: &Reader, def: TypeDef) -> Vec<Type> {
-    reader.type_def_generics(def).map(Type::GenericParam).collect()
+impl std::fmt::Debug for Guid {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:08x?}-{:04x?}-{:04x?}-{:02x?}{:02x?}-{:02x?}{:02x?}{:02x?}{:02x?}{:02x?}{:02x?}", self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10)
+    }
+}
+
+pub fn type_def_invoke_method(row: TypeDef) -> MethodDef {
+    row.methods().find(|method| method.name() == "Invoke").expect("`Invoke` method not found")
+}
+
+pub fn type_def_generics(def: TypeDef) -> Vec<Type> {
+    def.generics().map(Type::GenericParam).collect()
 }
 
 // TODO: namespace should not be required - it's a hack to accomodate Win32 metadata
 // TODO: this is very Rust-specific and Win32-metadata specific with all of its translation. Replace with literal signature parser that just returns slice of types.
 pub fn method_def_signature(reader: &Reader, namespace: &str, row: MethodDef, generics: &[Type]) -> Signature {
-    let mut blob = reader.row_blob(row, 4);
+    let mut blob = row.blob(4);
     let call_flags = MethodCallAttributes(blob.read_usize() as u8);
     let _param_count = blob.read_usize();
     let mut return_type = reader.type_from_blob(&mut blob, None, generics);
 
-    let mut params: Vec<SignatureParam> = reader
-        .method_def_params(row)
+    let mut params: Vec<SignatureParam> = row
+        .params()
         .filter_map(|param| {
-            let param_is_const = reader.has_attribute(param, "ConstAttribute");
-            if reader.param_sequence(param) == 0 {
+            let param_is_const = param.has_attribute("ConstAttribute");
+            if param.sequence() == 0 {
                 if param_is_const {
                     return_type = return_type.clone().to_const_type();
                 }
                 None
             } else {
-                let is_output = reader.param_flags(param).contains(ParamAttributes::Out);
+                let is_output = param.flags().contains(ParamAttributes::Out);
                 let mut ty = reader.type_from_blob(&mut blob, None, generics);
 
-                if let Some(name) = param_or_enum(reader, param) {
-                    let def = reader.get_type_def(TypeName::new(namespace, &name)).next().expect("Enum not found");
+                if let Some(name) = param_or_enum(param) {
+                    let def = reader.get_type_def(namespace, &name).next().expect("Enum not found");
                     ty = Type::PrimitiveOrEnum(Box::new(ty), Box::new(Type::TypeDef(def, Vec::new())));
                 }
 
@@ -116,7 +153,7 @@ pub fn method_def_signature(reader: &Reader, namespace: &str, row: MethodDef, ge
                 if !is_output {
                     ty = ty.to_const_ptr();
                 }
-                let kind = param_kind(reader, param);
+                let kind = param_kind(param);
                 Some(SignatureParam { def: param, ty, kind })
             }
         })
@@ -127,14 +164,14 @@ pub fn method_def_signature(reader: &Reader, namespace: &str, row: MethodDef, ge
         match params[position].kind {
             SignatureParamKind::ArrayRelativeLen(relative) | SignatureParamKind::ArrayRelativeByteLen(relative) => {
                 // The len params must be input only.
-                if !reader.param_flags(params[relative].def).contains(ParamAttributes::Out) && position != relative && !params[relative].ty.is_pointer() {
+                if !params[relative].def.flags().contains(ParamAttributes::Out) && position != relative && !params[relative].ty.is_pointer() {
                     params[relative].kind = SignatureParamKind::ArrayRelativePtr(position);
                 } else {
                     params[position].kind = SignatureParamKind::Other;
                 }
             }
             SignatureParamKind::ArrayFixed(_) => {
-                if reader.has_attribute(params[position].def, "FreeWithAttribute") {
+                if params[position].def.has_attribute("FreeWithAttribute") {
                     params[position].kind = SignatureParamKind::Other;
                 }
             }
@@ -177,16 +214,16 @@ pub fn method_def_signature(reader: &Reader, namespace: &str, row: MethodDef, ge
     for param in &mut params {
         if param.kind == SignatureParamKind::Other {
             if signature_param_is_convertible(reader, param) {
-                if type_is_non_exclusive_winrt_interface(reader, &param.ty) {
+                if type_is_non_exclusive_winrt_interface(&param.ty) {
                     param.kind = SignatureParamKind::TryInto;
                 } else {
                     param.kind = SignatureParamKind::IntoParam;
                 }
             } else {
-                let flags = reader.param_flags(param.def);
-                if param.ty.is_pointer() && (flags.contains(ParamAttributes::Optional) || reader.has_attribute(param.def, "ReservedAttribute")) {
+                let flags = param.def.flags();
+                if param.ty.is_pointer() && (flags.contains(ParamAttributes::Optional) || param.def.has_attribute("ReservedAttribute")) {
                     param.kind = SignatureParamKind::OptionalPointer;
-                } else if type_is_primitive(reader, &param.ty) && (!param.ty.is_pointer() || type_is_blittable(reader, &param.ty.deref())) {
+                } else if type_is_primitive(&param.ty) && (!param.ty.is_pointer() || type_is_blittable(reader, &param.ty.deref())) {
                     param.kind = SignatureParamKind::ValueType;
                 } else if type_is_blittable(reader, &param.ty) {
                     param.kind = SignatureParamKind::Blittable;
@@ -198,11 +235,11 @@ pub fn method_def_signature(reader: &Reader, namespace: &str, row: MethodDef, ge
     Signature { def: row, params, return_type, call_flags }
 }
 
-fn param_kind(reader: &Reader, row: Param) -> SignatureParamKind {
-    for attribute in reader.attributes(row) {
-        match reader.attribute_name(attribute) {
+fn param_kind(row: Param) -> SignatureParamKind {
+    for attribute in row.attributes() {
+        match attribute.name() {
             "NativeArrayInfoAttribute" => {
-                for (_, value) in reader.attribute_args(attribute) {
+                for (_, value) in attribute.args() {
                     match value {
                         Value::I16(value) => return SignatureParamKind::ArrayRelativeLen(value as usize),
                         Value::I32(value) => return SignatureParamKind::ArrayFixed(value as usize),
@@ -211,7 +248,7 @@ fn param_kind(reader: &Reader, row: Param) -> SignatureParamKind {
                 }
             }
             "MemorySizeAttribute" => {
-                for (_, value) in reader.attribute_args(attribute) {
+                for (_, value) in attribute.args() {
                     if let Value::I16(value) = value {
                         return SignatureParamKind::ArrayRelativeByteLen(value as usize);
                     }
@@ -224,9 +261,9 @@ fn param_kind(reader: &Reader, row: Param) -> SignatureParamKind {
 }
 
 // TODO: this is a terribly broken Win32 metadata attribute - need to get rid of it.
-fn param_or_enum(reader: &Reader, row: Param) -> Option<String> {
-    reader.find_attribute(row, "AssociatedEnumAttribute").and_then(|attribute| {
-        for (_, arg) in reader.attribute_args(attribute) {
+fn param_or_enum(row: Param) -> Option<String> {
+    row.find_attribute("AssociatedEnumAttribute").and_then(|attribute| {
+        for (_, arg) in attribute.args() {
             if let Value::String(name) = arg {
                 return Some(name);
             }
@@ -236,13 +273,13 @@ fn param_or_enum(reader: &Reader, row: Param) -> Option<String> {
 }
 
 pub fn signature_param_is_convertible(reader: &Reader, param: &SignatureParam) -> bool {
-    !reader.param_flags(param.def).contains(ParamAttributes::Out) && !param.ty.is_winrt_array() && !param.ty.is_pointer() && !param.kind.is_array() && (type_is_borrowed(reader, &param.ty) || type_is_non_exclusive_winrt_interface(reader, &param.ty) || type_is_trivially_convertible(reader, &param.ty))
+    !param.def.flags().contains(ParamAttributes::Out) && !param.ty.is_winrt_array() && !param.ty.is_pointer() && !param.kind.is_array() && (type_is_borrowed(reader, &param.ty) || type_is_non_exclusive_winrt_interface(&param.ty) || type_is_trivially_convertible(&param.ty))
 }
 
-fn signature_param_is_retval(reader: &Reader, param: &SignatureParam) -> bool {
+fn signature_param_is_retval(param: &SignatureParam) -> bool {
     // The Win32 metadata uses `RetValAttribute` to call out retval methods but it is employed
     // very sparingly, so this heuristic is used to apply the transformation more uniformly.
-    if reader.has_attribute(param.def, "RetValAttribute") {
+    if param.def.has_attribute("RetValAttribute") {
         return true;
     }
     if !param.ty.is_pointer() {
@@ -251,66 +288,66 @@ fn signature_param_is_retval(reader: &Reader, param: &SignatureParam) -> bool {
     if param.ty.is_void() {
         return false;
     }
-    let flags = reader.param_flags(param.def);
+    let flags = param.def.flags();
     if flags.contains(ParamAttributes::In) || !flags.contains(ParamAttributes::Out) || flags.contains(ParamAttributes::Optional) || param.kind.is_array() {
         return false;
     }
-    if param_kind(reader, param.def).is_array() {
+    if param_kind(param.def).is_array() {
         return false;
     }
     // If it's bigger than 128 bits, best to pass as a reference.
-    if reader.type_size(&param.ty.deref()) > 16 {
+    if param.ty.deref().size() > 16 {
         return false;
     }
     // Win32 callbacks are defined as `Option<T>` so we don't include them here to avoid
     // producing the `Result<Option<T>>` anti-pattern.
     match param.ty.deref() {
-        Type::TypeDef(def, _) => !type_def_is_callback(reader, def),
+        Type::TypeDef(def, _) => !type_def_is_callback(def),
         _ => true,
     }
 }
 
-pub fn signature_kind(reader: &Reader, signature: &Signature) -> SignatureKind {
-    if reader.has_attribute(signature.def, "CanReturnMultipleSuccessValuesAttribute") {
+pub fn signature_kind(signature: &Signature) -> SignatureKind {
+    if signature.def.has_attribute("CanReturnMultipleSuccessValuesAttribute") {
         return SignatureKind::PreserveSig;
     }
     match &signature.return_type {
-        Type::Void if signature_is_retval(reader, signature) => SignatureKind::ReturnValue,
+        Type::Void if signature_is_retval(signature) => SignatureKind::ReturnValue,
         Type::Void => SignatureKind::ReturnVoid,
         Type::HRESULT => {
             if signature.params.len() >= 2 {
-                if let Some((guid, object)) = signature_param_is_query(reader, &signature.params) {
-                    if reader.param_flags(signature.params[object].def).contains(ParamAttributes::Optional) {
+                if let Some((guid, object)) = signature_param_is_query(&signature.params) {
+                    if signature.params[object].def.flags().contains(ParamAttributes::Optional) {
                         return SignatureKind::QueryOptional(QueryPosition { object, guid });
                     } else {
                         return SignatureKind::Query(QueryPosition { object, guid });
                     }
                 }
             }
-            if signature_is_retval(reader, signature) {
+            if signature_is_retval(signature) {
                 SignatureKind::ResultValue
             } else {
                 SignatureKind::ResultVoid
             }
         }
-        Type::TypeDef(def, _) if reader.type_def_type_name(*def) == TypeName::WIN32_ERROR => SignatureKind::ResultVoid,
-        Type::TypeDef(def, _) if reader.type_def_type_name(*def) == TypeName::BOOL && method_def_last_error(reader, signature.def) => SignatureKind::ResultVoid,
-        _ if type_is_struct(reader, &signature.return_type) => SignatureKind::ReturnStruct,
+        Type::TypeDef(def, _) if def.type_name() == TypeName::WIN32_ERROR => SignatureKind::ResultVoid,
+        Type::TypeDef(def, _) if def.type_name() == TypeName::BOOL && method_def_last_error(signature.def) => SignatureKind::ResultVoid,
+        _ if type_is_struct(&signature.return_type) => SignatureKind::ReturnStruct,
         _ => SignatureKind::PreserveSig,
     }
 }
 
-fn signature_is_retval(reader: &Reader, signature: &Signature) -> bool {
-    signature.params.last().map_or(false, |param| signature_param_is_retval(reader, param))
+fn signature_is_retval(signature: &Signature) -> bool {
+    signature.params.last().map_or(false, signature_param_is_retval)
         && signature.params[..signature.params.len() - 1].iter().all(|param| {
-            let flags = reader.param_flags(param.def);
+            let flags = param.def.flags();
             !flags.contains(ParamAttributes::Out)
         })
 }
 
-fn signature_param_is_query(reader: &Reader, params: &[SignatureParam]) -> Option<(usize, usize)> {
-    if let Some(guid) = params.iter().rposition(|param| param.ty == Type::ConstPtr(Box::new(Type::GUID), 1) && !reader.param_flags(param.def).contains(ParamAttributes::Out)) {
-        if let Some(object) = params.iter().rposition(|param| param.ty == Type::MutPtr(Box::new(Type::Void), 2) && reader.has_attribute(param.def, "ComOutPtrAttribute")) {
+fn signature_param_is_query(params: &[SignatureParam]) -> Option<(usize, usize)> {
+    if let Some(guid) = params.iter().rposition(|param| param.ty == Type::ConstPtr(Box::new(Type::GUID), 1) && !param.def.flags().contains(ParamAttributes::Out)) {
+        if let Some(object) = params.iter().rposition(|param| param.ty == Type::MutPtr(Box::new(Type::Void), 2) && param.def.has_attribute("ComOutPtrAttribute")) {
             return Some((guid, object));
         }
     }
@@ -318,9 +355,9 @@ fn signature_param_is_query(reader: &Reader, params: &[SignatureParam]) -> Optio
     None
 }
 
-fn method_def_last_error(reader: &Reader, row: MethodDef) -> bool {
-    if let Some(map) = reader.method_def_impl_map(row) {
-        reader.impl_map_flags(map).contains(PInvokeAttributes::SupportsLastError)
+fn method_def_last_error(row: MethodDef) -> bool {
+    if let Some(map) = row.impl_map() {
+        map.flags().contains(PInvokeAttributes::SupportsLastError)
     } else {
         false
     }
@@ -334,16 +371,16 @@ pub fn type_is_borrowed(reader: &Reader, ty: &Type) -> bool {
     }
 }
 
-pub fn type_is_non_exclusive_winrt_interface(reader: &Reader, ty: &Type) -> bool {
+pub fn type_is_non_exclusive_winrt_interface(ty: &Type) -> bool {
     match ty {
         Type::TypeDef(row, _) => {
-            let flags = reader.type_def_flags(*row);
+            let flags = row.flags();
             if !flags.contains(TypeAttributes::WindowsRuntime) {
                 false
             } else {
-                match reader.type_def_kind(*row) {
-                    TypeKind::Interface => !type_def_is_exclusive(reader, *row),
-                    TypeKind::Class => reader.has_attribute(*row, "ComposableAttribute"),
+                match row.kind() {
+                    TypeKind::Interface => !type_def_is_exclusive(*row),
+                    TypeKind::Class => row.has_attribute("ComposableAttribute"),
                     _ => false,
                 }
             }
@@ -352,18 +389,18 @@ pub fn type_is_non_exclusive_winrt_interface(reader: &Reader, ty: &Type) -> bool
     }
 }
 
-fn type_is_trivially_convertible(reader: &Reader, ty: &Type) -> bool {
+fn type_is_trivially_convertible(ty: &Type) -> bool {
     match ty {
-        Type::TypeDef(row, _) => match reader.type_def_kind(*row) {
-            TypeKind::Struct => type_def_is_handle(reader, *row),
+        Type::TypeDef(row, _) => match row.kind() {
+            TypeKind::Struct => type_def_is_handle(*row),
             _ => false,
         },
         _ => false,
     }
 }
 
-fn type_def_is_callback(reader: &Reader, row: TypeDef) -> bool {
-    !reader.type_def_flags(row).contains(TypeAttributes::WindowsRuntime) && reader.type_def_kind(row) == TypeKind::Delegate
+fn type_def_is_callback(row: TypeDef) -> bool {
+    !row.flags().contains(TypeAttributes::WindowsRuntime) && row.kind() == TypeKind::Delegate
 }
 
 pub fn type_has_callback(reader: &Reader, ty: &Type) -> bool {
@@ -374,23 +411,23 @@ pub fn type_has_callback(reader: &Reader, ty: &Type) -> bool {
     }
 }
 pub fn type_def_has_callback(reader: &Reader, row: TypeDef) -> bool {
-    if type_def_is_callback(reader, row) {
+    if type_def_is_callback(row) {
         return true;
     }
-    if reader.type_def_kind(row) != TypeKind::Struct {
+    if row.kind() != TypeKind::Struct {
         return false;
     }
     fn check(reader: &Reader, row: TypeDef) -> bool {
-        if reader.type_def_fields(row).any(|field| type_has_callback(reader, &reader.field_type(field, Some(row)))) {
+        if row.fields().any(|field| type_has_callback(reader, &field.ty(Some(row)))) {
             return true;
         }
         false
     }
-    let type_name = reader.type_def_type_name(row);
+    let type_name = row.type_name();
     if type_name.namespace.is_empty() {
         check(reader, row)
     } else {
-        for row in reader.get_type_def(type_name) {
+        for row in reader.get_type_def(type_name.namespace, type_name.name) {
             if check(reader, row) {
                 return true;
             }
@@ -402,13 +439,10 @@ pub fn type_def_has_callback(reader: &Reader, row: TypeDef) -> bool {
 pub fn type_interfaces(reader: &Reader, ty: &Type) -> Vec<Interface> {
     // TODO: collect into btree map and then return collected vec
     // This will both sort the results and should make finding dupes faster
-    fn walk(reader: &Reader, result: &mut Vec<Interface>, parent: &Type, is_base: bool) {
+    fn walk(result: &mut Vec<Interface>, parent: &Type, is_base: bool) {
         if let Type::TypeDef(row, generics) = parent {
-            for imp in reader.type_def_interface_impls(*row) {
-                let mut child = Interface {
-                    ty: reader.interface_impl_type(imp, generics),
-                    kind: if reader.has_attribute(imp, "DefaultAttribute") { InterfaceKind::Default } else { InterfaceKind::None },
-                };
+            for imp in row.interface_impls() {
+                let mut child = Interface { ty: imp.ty(generics), kind: if imp.has_attribute("DefaultAttribute") { InterfaceKind::Default } else { InterfaceKind::None } };
 
                 child.kind = if !is_base && child.kind == InterfaceKind::Default {
                     InterfaceKind::Default
@@ -429,25 +463,26 @@ pub fn type_interfaces(reader: &Reader, ty: &Type) -> Vec<Interface> {
                     }
                 }
                 if !found {
-                    walk(reader, result, &child.ty, is_base);
+                    walk(result, &child.ty, is_base);
                     result.push(child);
                 }
             }
         }
     }
     let mut result = Vec::new();
-    walk(reader, &mut result, ty, false);
+    walk(&mut result, ty, false);
     if let Type::TypeDef(row, _) = ty {
-        if reader.type_def_kind(*row) == TypeKind::Class {
+        if row.kind() == TypeKind::Class {
             for base in type_def_bases(reader, *row) {
-                walk(reader, &mut result, &Type::TypeDef(base, Vec::new()), true);
+                walk(&mut result, &Type::TypeDef(base, Vec::new()), true);
             }
-            for attribute in reader.attributes(*row) {
-                match reader.attribute_name(attribute) {
+            for attribute in row.attributes() {
+                match attribute.name() {
                     "StaticAttribute" | "ActivatableAttribute" => {
-                        for (_, arg) in reader.attribute_args(attribute) {
+                        for (_, arg) in attribute.args() {
                             if let Value::TypeName(type_name) = arg {
-                                let def = reader.get_type_def(TypeName::parse(&type_name)).next().expect("Type not found");
+                                let type_name = parse_type_name(&type_name);
+                                let def = reader.get_type_def(type_name.0, type_name.1).next().expect("Type not found");
                                 result.push(Interface { ty: Type::TypeDef(def, Vec::new()), kind: InterfaceKind::Static });
                                 break;
                             }
@@ -458,23 +493,23 @@ pub fn type_interfaces(reader: &Reader, ty: &Type) -> Vec<Interface> {
             }
         }
     }
-    result.sort_by(|a, b| type_name(reader, &a.ty).cmp(type_name(reader, &b.ty)));
+    result.sort_by(|a, b| type_name(&a.ty).cmp(type_name(&b.ty)));
     result
 }
 
-fn type_name<'a>(reader: &Reader<'a>, ty: &Type) -> &'a str {
+fn type_name<'a>(ty: &Type) -> &'a str {
     match ty {
-        Type::TypeDef(row, _) => reader.type_def_name(*row),
+        Type::TypeDef(row, _) => row.name(),
         _ => "",
     }
 }
 
 pub fn field_is_blittable(reader: &Reader, row: Field, enclosing: TypeDef) -> bool {
-    type_is_blittable(reader, &reader.field_type(row, Some(enclosing)))
+    type_is_blittable(reader, &row.ty(Some(enclosing)))
 }
 
 pub fn field_is_copyable(reader: &Reader, row: Field, enclosing: TypeDef) -> bool {
-    type_is_copyable(reader, &reader.field_type(row, Some(enclosing)))
+    type_is_copyable(reader, &row.ty(Some(enclosing)))
 }
 
 pub fn type_is_blittable(reader: &Reader, ty: &Type) -> bool {
@@ -498,56 +533,56 @@ fn type_is_copyable(reader: &Reader, ty: &Type) -> bool {
 }
 
 pub fn type_def_is_blittable(reader: &Reader, row: TypeDef) -> bool {
-    match reader.type_def_kind(row) {
+    match row.kind() {
         TypeKind::Struct => {
-            if reader.type_def_flags(row).contains(TypeAttributes::WindowsRuntime) {
-                reader.type_def_fields(row).all(|field| field_is_blittable(reader, field, row))
+            if row.flags().contains(TypeAttributes::WindowsRuntime) {
+                row.fields().all(|field| field_is_blittable(reader, field, row))
             } else {
                 true
             }
         }
         TypeKind::Enum => true,
-        TypeKind::Delegate => !reader.type_def_flags(row).contains(TypeAttributes::WindowsRuntime),
+        TypeKind::Delegate => !row.flags().contains(TypeAttributes::WindowsRuntime),
         _ => false,
     }
 }
 
 pub fn type_def_is_copyable(reader: &Reader, row: TypeDef) -> bool {
-    match reader.type_def_kind(row) {
-        TypeKind::Struct => reader.type_def_fields(row).all(|field| field_is_copyable(reader, field, row)),
+    match row.kind() {
+        TypeKind::Struct => row.fields().all(|field| field_is_copyable(reader, field, row)),
         TypeKind::Enum => true,
-        TypeKind::Delegate => !reader.type_def_flags(row).contains(TypeAttributes::WindowsRuntime),
+        TypeKind::Delegate => !row.flags().contains(TypeAttributes::WindowsRuntime),
         _ => false,
     }
 }
 
-pub fn type_def_is_exclusive(reader: &Reader, row: TypeDef) -> bool {
-    reader.has_attribute(row, "ExclusiveToAttribute")
+pub fn type_def_is_exclusive(row: TypeDef) -> bool {
+    row.has_attribute("ExclusiveToAttribute")
 }
 
-pub fn type_is_struct(reader: &Reader, ty: &Type) -> bool {
+pub fn type_is_struct(ty: &Type) -> bool {
     // This check is used to detect virtual functions that return C-style PODs that affect how the stack is packed for x86.
     // It could be defined as a struct with more than one field but that check is complicated as it would have to detect
     // nested structs. Fortunately, this is rare enough that this check is sufficient.
     match ty {
-        Type::TypeDef(row, _) => reader.type_def_kind(*row) == TypeKind::Struct && !type_def_is_handle(reader, *row),
+        Type::TypeDef(row, _) => row.kind() == TypeKind::Struct && !type_def_is_handle(*row),
         Type::GUID => true,
         _ => false,
     }
 }
 
-fn type_def_is_primitive(reader: &Reader, row: TypeDef) -> bool {
-    match reader.type_def_kind(row) {
+fn type_def_is_primitive(row: TypeDef) -> bool {
+    match row.kind() {
         TypeKind::Enum => true,
-        TypeKind::Struct => type_def_is_handle(reader, row),
-        TypeKind::Delegate => !reader.type_def_flags(row).contains(TypeAttributes::WindowsRuntime),
+        TypeKind::Struct => type_def_is_handle(row),
+        TypeKind::Delegate => !row.flags().contains(TypeAttributes::WindowsRuntime),
         _ => false,
     }
 }
 
-pub fn type_is_primitive(reader: &Reader, ty: &Type) -> bool {
+pub fn type_is_primitive(ty: &Type) -> bool {
     match ty {
-        Type::TypeDef(row, _) => type_def_is_primitive(reader, *row),
+        Type::TypeDef(row, _) => type_def_is_primitive(*row),
         Type::Bool | Type::Char | Type::I8 | Type::U8 | Type::I16 | Type::U16 | Type::I32 | Type::U32 | Type::I64 | Type::U64 | Type::F32 | Type::F64 | Type::ISize | Type::USize | Type::HRESULT | Type::ConstPtr(_, _) | Type::MutPtr(_, _) => true,
         _ => false,
     }
@@ -562,23 +597,23 @@ fn type_has_explicit_layout(reader: &Reader, ty: &Type) -> bool {
 }
 
 pub fn type_def_has_explicit_layout(reader: &Reader, row: TypeDef) -> bool {
-    if reader.type_def_kind(row) != TypeKind::Struct {
+    if row.kind() != TypeKind::Struct {
         return false;
     }
     fn check(reader: &Reader, row: TypeDef) -> bool {
-        if reader.type_def_flags(row).contains(TypeAttributes::ExplicitLayout) {
+        if row.flags().contains(TypeAttributes::ExplicitLayout) {
             return true;
         }
-        if reader.type_def_fields(row).any(|field| type_has_explicit_layout(reader, &reader.field_type(field, Some(row)))) {
+        if row.fields().any(|field| type_has_explicit_layout(reader, &field.ty(Some(row)))) {
             return true;
         }
         false
     }
-    let type_name = reader.type_def_type_name(row);
+    let type_name = row.type_name();
     if type_name.namespace.is_empty() {
         check(reader, row)
     } else {
-        for row in reader.get_type_def(type_name) {
+        for row in reader.get_type_def(type_name.namespace, type_name.name) {
             if check(reader, row) {
                 return true;
             }
@@ -596,23 +631,23 @@ fn type_has_packing(reader: &Reader, ty: &Type) -> bool {
 }
 
 pub fn type_def_has_packing(reader: &Reader, row: TypeDef) -> bool {
-    if reader.type_def_kind(row) != TypeKind::Struct {
+    if row.kind() != TypeKind::Struct {
         return false;
     }
     fn check(reader: &Reader, row: TypeDef) -> bool {
-        if reader.type_def_class_layout(row).is_some() {
+        if row.class_layout().is_some() {
             return true;
         }
-        if reader.type_def_fields(row).any(|field| type_has_packing(reader, &reader.field_type(field, Some(row)))) {
+        if row.fields().any(|field| type_has_packing(reader, &field.ty(Some(row)))) {
             return true;
         }
         false
     }
-    let type_name = reader.type_def_type_name(row);
+    let type_name = row.type_name();
     if type_name.namespace.is_empty() {
         check(reader, row)
     } else {
-        for row in reader.get_type_def(type_name) {
+        for row in reader.get_type_def(type_name.namespace, type_name.name) {
             if check(reader, row) {
                 return true;
             }
@@ -621,8 +656,8 @@ pub fn type_def_has_packing(reader: &Reader, row: TypeDef) -> bool {
     }
 }
 
-pub fn type_def_default_interface(reader: &Reader, row: TypeDef) -> Option<Type> {
-    reader.type_def_interface_impls(row).find_map(move |row| if reader.has_attribute(row, "DefaultAttribute") { Some(reader.interface_impl_type(row, &[])) } else { None })
+pub fn type_def_default_interface(row: TypeDef) -> Option<Type> {
+    row.interface_impls().find_map(move |row| if row.has_attribute("DefaultAttribute") { Some(row.ty(&[])) } else { None })
 }
 
 fn type_signature(reader: &Reader, ty: &Type) -> String {
@@ -651,21 +686,21 @@ fn type_signature(reader: &Reader, ty: &Type) -> String {
 }
 
 pub fn type_def_signature(reader: &Reader, row: TypeDef, generics: &[Type]) -> String {
-    match reader.type_def_kind(row) {
+    match row.kind() {
         TypeKind::Interface => type_def_interface_signature(reader, row, generics),
         TypeKind::Class => {
-            if let Some(Type::TypeDef(default, generics)) = type_def_default_interface(reader, row) {
-                format!("rc({};{})", reader.type_def_type_name(row), type_def_interface_signature(reader, default, &generics))
+            if let Some(Type::TypeDef(default, generics)) = type_def_default_interface(row) {
+                format!("rc({};{})", row.type_name(), type_def_interface_signature(reader, default, &generics))
             } else {
                 unimplemented!();
             }
         }
-        TypeKind::Enum => format!("enum({};{})", reader.type_def_type_name(row), type_signature(reader, &reader.type_def_underlying_type(row))),
+        TypeKind::Enum => format!("enum({};{})", row.type_name(), type_signature(reader, &row.underlying_type())),
         TypeKind::Struct => {
-            let mut result = format!("struct({}", reader.type_def_type_name(row));
-            for field in reader.type_def_fields(row) {
+            let mut result = format!("struct({}", row.type_name());
+            for field in row.fields() {
                 result.push(';');
-                result.push_str(&type_signature(reader, &reader.field_type(field, Some(row))));
+                result.push_str(&type_signature(reader, &field.ty(Some(row))));
             }
             result.push(')');
             result
@@ -681,7 +716,7 @@ pub fn type_def_signature(reader: &Reader, row: TypeDef, generics: &[Type]) -> S
 }
 
 fn type_def_interface_signature(reader: &Reader, row: TypeDef, generics: &[Type]) -> String {
-    let guid = type_def_guid(reader, row).unwrap();
+    let guid = type_def_guid(row).unwrap();
     if generics.is_empty() {
         format!("{{{guid:#?}}}")
     } else {
@@ -695,20 +730,20 @@ fn type_def_interface_signature(reader: &Reader, row: TypeDef, generics: &[Type]
     }
 }
 
-pub fn type_def_is_handle(reader: &Reader, row: TypeDef) -> bool {
-    reader.has_attribute(row, "NativeTypedefAttribute")
+pub fn type_def_is_handle(row: TypeDef) -> bool {
+    row.has_attribute("NativeTypedefAttribute")
 }
 
-pub fn type_def_guid(reader: &Reader, row: TypeDef) -> Option<GUID> {
-    reader.find_attribute(row, "GuidAttribute").map(|attribute| GUID::from_args(&reader.attribute_args(attribute)))
+pub fn type_def_guid(row: TypeDef) -> Option<Guid> {
+    row.find_attribute("GuidAttribute").map(|attribute| Guid::from_args(&attribute.args()))
 }
 
 pub fn type_def_bases(reader: &Reader, mut row: TypeDef) -> Vec<TypeDef> {
     let mut bases = Vec::new();
     loop {
-        match reader.type_def_extends(row) {
+        match row.extends() {
             Some(base) if base != TypeName::Object => {
-                row = reader.get_type_def(base).next().expect("Type not found");
+                row = reader.get_type_def(base.namespace, base.name).next().expect("Type not found");
                 bases.push(row);
             }
             _ => break,
@@ -717,11 +752,11 @@ pub fn type_def_bases(reader: &Reader, mut row: TypeDef) -> Vec<TypeDef> {
     bases
 }
 
-pub fn type_def_invalid_values(reader: &Reader, row: TypeDef) -> Vec<i64> {
+pub fn type_def_invalid_values(row: TypeDef) -> Vec<i64> {
     let mut values = Vec::new();
-    for attribute in reader.attributes(row) {
-        if reader.attribute_name(attribute) == "InvalidHandleValueAttribute" {
-            if let Some((_, Value::I64(value))) = reader.attribute_args(attribute).get(0) {
+    for attribute in row.attributes() {
+        if attribute.name() == "InvalidHandleValueAttribute" {
+            if let Some((_, Value::I64(value))) = attribute.args().get(0) {
                 values.push(*value);
             }
         }
@@ -729,34 +764,34 @@ pub fn type_def_invalid_values(reader: &Reader, row: TypeDef) -> Vec<i64> {
     values
 }
 
-fn type_def_is_nullable(reader: &Reader, row: TypeDef) -> bool {
-    match reader.type_def_kind(row) {
+fn type_def_is_nullable(row: TypeDef) -> bool {
+    match row.kind() {
         TypeKind::Interface | TypeKind::Class => true,
         // Win32 callbacks are defined as `Option<T>` so we don't include them here to avoid them
         // from being doubly wrapped in `Option`.
-        TypeKind::Delegate => reader.type_def_flags(row).contains(TypeAttributes::WindowsRuntime),
+        TypeKind::Delegate => row.flags().contains(TypeAttributes::WindowsRuntime),
         _ => false,
     }
 }
 
-pub fn type_is_nullable(reader: &Reader, ty: &Type) -> bool {
+pub fn type_is_nullable(ty: &Type) -> bool {
     match ty {
-        Type::TypeDef(row, _) => type_def_is_nullable(reader, *row),
+        Type::TypeDef(row, _) => type_def_is_nullable(*row),
         Type::IInspectable | Type::IUnknown => true,
         _ => false,
     }
 }
 
-pub fn type_def_vtables(reader: &Reader, row: TypeDef) -> Vec<Type> {
+pub fn type_def_vtables(row: TypeDef) -> Vec<Type> {
     let mut result = Vec::new();
-    if reader.type_def_flags(row).contains(TypeAttributes::WindowsRuntime) {
+    if row.flags().contains(TypeAttributes::WindowsRuntime) {
         result.push(Type::IUnknown);
-        if reader.type_def_kind(row) != TypeKind::Delegate {
+        if row.kind() != TypeKind::Delegate {
             result.push(Type::IInspectable);
         }
     } else {
         let mut next = row;
-        while let Some(base) = type_def_interfaces(reader, next, &[]).next() {
+        while let Some(base) = type_def_interfaces(next, &[]).next() {
             match base {
                 Type::TypeDef(row, _) => {
                     next = row;
@@ -778,6 +813,6 @@ pub fn type_def_vtables(reader: &Reader, row: TypeDef) -> Vec<Type> {
     result
 }
 
-pub fn type_def_interfaces<'a>(reader: &'a Reader<'a>, row: TypeDef, generics: &'a [Type]) -> impl Iterator<Item = Type> + 'a {
-    reader.type_def_interface_impls(row).map(move |row| reader.interface_impl_type(row, generics))
+pub fn type_def_interfaces(row: TypeDef, generics: &[Type]) -> impl Iterator<Item = Type> + '_ {
+    row.interface_impls().map(move |row| row.ty(generics))
 }
diff --git a/crates/libs/bindgen/src/rdl/from_reader.rs b/crates/libs/bindgen/src/rdl/from_reader.rs
index 136430a9aa..59b4543ba2 100644
--- a/crates/libs/bindgen/src/rdl/from_reader.rs
+++ b/crates/libs/bindgen/src/rdl/from_reader.rs
@@ -1,7 +1,7 @@
 use super::*;
 use crate::tokens::{quote, to_ident, TokenStream};
 use crate::{rdl, Error, Result, Tree};
-use metadata::RowReader;
+use metadata::*;
 
 pub fn from_reader(reader: &metadata::Reader, filter: &metadata::Filter, mut config: std::collections::BTreeMap<&str, &str>, output: &str) -> Result<()> {
     let dialect = match config.remove("type") {
@@ -58,7 +58,7 @@ enum Dialect {
 }
 
 struct Writer<'a> {
-    reader: &'a metadata::Reader<'a>,
+    reader: &'a metadata::Reader,
     filter: &'a metadata::Filter<'a>,
     namespace: &'a str,
     dialect: Dialect,
@@ -137,7 +137,7 @@ impl<'a> Writer<'a> {
         if !tree.namespace.is_empty() {
             for item in self.reader.namespace_items(tree.namespace, self.filter).filter(|item| match item {
                 metadata::Item::Type(def) => {
-                    let winrt = self.reader.type_def_flags(*def).contains(metadata::TypeAttributes::WindowsRuntime);
+                    let winrt = def.flags().contains(metadata::TypeAttributes::WindowsRuntime);
                     match self.dialect {
                         Dialect::Win32 => !winrt,
                         Dialect::WinRT => winrt,
@@ -148,7 +148,7 @@ impl<'a> Writer<'a> {
                 match item {
                     metadata::Item::Type(def) => types.push(self.type_def(def)),
                     metadata::Item::Const(field) => constants.push(self.constant(field)),
-                    metadata::Item::Fn(method, namespace) => functions.push(self.function(method, &namespace)),
+                    metadata::Item::Fn(method, namespace) => functions.push(self.function(method, namespace)),
                 }
             }
         }
@@ -161,17 +161,17 @@ impl<'a> Writer<'a> {
     }
 
     fn function(&self, def: metadata::MethodDef, _namespace: &str) -> TokenStream {
-        let name = to_ident(self.reader.method_def_name(def));
+        let name = to_ident(def.name());
         quote! { fn #name(); }
     }
 
     fn constant(&self, def: metadata::Field) -> TokenStream {
-        let name = to_ident(self.reader.field_name(def));
+        let name = to_ident(def.name());
         quote! { const #name: i32 = 0; }
     }
 
     fn type_def(&self, def: metadata::TypeDef) -> TokenStream {
-        if let Some(extends) = self.reader.type_def_extends(def) {
+        if let Some(extends) = def.extends() {
             if extends.namespace == "System" {
                 if extends.name == "Enum" {
                     self.enum_def(def)
@@ -191,7 +191,7 @@ impl<'a> Writer<'a> {
     }
 
     fn enum_def(&self, def: metadata::TypeDef) -> TokenStream {
-        let name = to_ident(self.reader.type_def_name(def));
+        let name = to_ident(def.name());
 
         quote! {
             struct #name {
@@ -201,11 +201,11 @@ impl<'a> Writer<'a> {
     }
 
     fn struct_def(&self, def: metadata::TypeDef) -> TokenStream {
-        let name = to_ident(self.reader.type_def_name(def));
+        let name = to_ident(def.name());
 
-        let fields = self.reader.type_def_fields(def).map(|field| {
-            let name = to_ident(self.reader.field_name(field));
-            let ty = self.ty(&self.reader.field_type(field, Some(def)));
+        let fields = def.fields().map(|field| {
+            let name = to_ident(field.name());
+            let ty = self.ty(&field.ty(Some(def)));
             quote! {
                 #name: #ty
             }
@@ -219,7 +219,7 @@ impl<'a> Writer<'a> {
     }
 
     fn delegate_def(&self, def: metadata::TypeDef) -> TokenStream {
-        let name = to_ident(self.reader.type_def_name(def));
+        let name = to_ident(def.name());
 
         quote! {
             struct #name {
@@ -229,7 +229,7 @@ impl<'a> Writer<'a> {
     }
 
     fn class_def(&self, def: metadata::TypeDef) -> TokenStream {
-        let name = to_ident(self.reader.type_def_name(def));
+        let name = to_ident(def.name());
         let implements = self.implements(def, &[]);
 
         quote! {
@@ -238,20 +238,20 @@ impl<'a> Writer<'a> {
     }
 
     fn interface_def(&self, def: metadata::TypeDef) -> TokenStream {
-        let name = to_ident(self.reader.type_def_name(def));
-        let generics = &metadata::type_def_generics(self.reader, def);
+        let name = to_ident(def.name());
+        let generics = &metadata::type_def_generics(def);
         let implements = self.implements(def, generics);
 
-        let methods = self.reader.type_def_methods(def).map(|method| {
-            let name = to_ident(self.reader.method_def_name(method));
+        let methods = def.methods().map(|method| {
+            let name = to_ident(method.name());
 
             // TODO: use reader.method_def_signature instead
-            let signature = metadata::method_def_signature(self.reader, self.reader.type_def_namespace(def), method, generics);
+            let signature = metadata::method_def_signature(self.reader, def.namespace(), method, generics);
 
             let return_type = self.return_type(&signature.return_type);
 
             let params = signature.params.iter().map(|param| {
-                let name = to_ident(self.reader.param_name(param.def));
+                let name = to_ident(param.def.name());
                 let ty = self.ty(&param.ty);
                 quote! { #name: #ty }
             });
@@ -287,16 +287,16 @@ impl<'a> Writer<'a> {
         // TODO: then list default interface first
         // Then everything else
 
-        for imp in self.reader.type_def_interface_impls(def) {
-            let ty = self.reader.interface_impl_type(imp, generics);
-            if self.reader.has_attribute(imp, "DefaultAttribute") {
+        for imp in def.interface_impls() {
+            let ty = imp.ty(generics);
+            if imp.has_attribute("DefaultAttribute") {
                 types.insert(0, self.ty(&ty));
             } else {
                 types.push(self.ty(&ty));
             }
         }
 
-        if let Some(type_name) = self.reader.type_def_extends(def) {
+        if let Some(type_name) = def.extends() {
             if type_name != metadata::TypeName::Object {
                 let namespace = self.namespace(type_name.namespace);
                 let name = to_ident(type_name.name);
@@ -349,8 +349,8 @@ impl<'a> Writer<'a> {
             metadata::Type::IUnknown => quote! { IUnknown },
 
             metadata::Type::TypeDef(def, generics) => {
-                let namespace = self.namespace(self.reader.type_def_namespace(*def));
-                let name = to_ident(self.reader.type_def_name(*def));
+                let namespace = self.namespace(def.namespace());
+                let name = to_ident(def.name());
                 if generics.is_empty() {
                     quote! { #namespace #name }
                 } else {
@@ -360,13 +360,13 @@ impl<'a> Writer<'a> {
             }
 
             metadata::Type::TypeRef(code) => {
-                let type_name = self.reader.type_def_or_ref(*code);
+                let type_name = code.type_name();
                 let namespace = self.namespace(type_name.namespace);
                 let name = to_ident(type_name.name);
                 quote! { #namespace #name }
             }
 
-            metadata::Type::GenericParam(generic) => self.reader.generic_param_name(*generic).into(),
+            metadata::Type::GenericParam(generic) => generic.name().into(),
             metadata::Type::WinrtArray(ty) => self.ty(ty),
             metadata::Type::WinrtArrayRef(ty) => self.ty(ty),
             metadata::Type::ConstRef(ty) => self.ty(ty),
diff --git a/crates/libs/bindgen/src/rust/cfg.rs b/crates/libs/bindgen/src/rust/cfg.rs
index db77497bf9..5e4a820831 100644
--- a/crates/libs/bindgen/src/rust/cfg.rs
+++ b/crates/libs/bindgen/src/rust/cfg.rs
@@ -30,19 +30,19 @@ impl<'a> Cfg<'a> {
     }
 }
 
-pub fn field_cfg<'a>(reader: &'a Reader<'a>, row: Field) -> Cfg<'a> {
+pub fn field_cfg(reader: &Reader, row: Field) -> Cfg {
     let mut cfg = Cfg::default();
     field_cfg_combine(reader, row, None, &mut cfg);
     cfg
 }
 fn field_cfg_combine<'a>(reader: &'a Reader, row: Field, enclosing: Option<TypeDef>, cfg: &mut Cfg<'a>) {
-    type_cfg_combine(reader, &reader.field_type(row, enclosing), cfg)
+    type_cfg_combine(reader, &row.ty(enclosing), cfg)
 }
 
 pub fn type_def_cfg<'a>(reader: &'a Reader, row: TypeDef, generics: &[Type]) -> Cfg<'a> {
     let mut cfg = Cfg::default();
     type_def_cfg_combine(reader, row, generics, &mut cfg);
-    cfg_add_attributes(reader, &mut cfg, row);
+    cfg_add_attributes(&mut cfg, row);
     cfg
 }
 pub fn type_def_cfg_impl<'a>(reader: &'a Reader, def: TypeDef, generics: &[Type]) -> Cfg<'a> {
@@ -51,73 +51,73 @@ pub fn type_def_cfg_impl<'a>(reader: &'a Reader, def: TypeDef, generics: &[Type]
     fn combine<'a>(reader: &'a Reader, def: TypeDef, generics: &[Type], cfg: &mut Cfg<'a>) {
         type_def_cfg_combine(reader, def, generics, cfg);
 
-        for method in reader.type_def_methods(def) {
-            signature_cfg_combine(reader, &reader.method_def_signature(method, generics), cfg);
+        for method in def.methods() {
+            signature_cfg_combine(reader, &method.signature(generics), cfg);
         }
     }
 
     combine(reader, def, generics, &mut cfg);
 
-    for def in type_def_vtables(reader, def) {
+    for def in type_def_vtables(def) {
         if let Type::TypeDef(def, generics) = def {
             combine(reader, def, &generics, &mut cfg);
         }
     }
 
-    if reader.type_def_flags(def).contains(TypeAttributes::WindowsRuntime) {
-        for interface in type_def_interfaces(reader, def, generics) {
+    if def.flags().contains(TypeAttributes::WindowsRuntime) {
+        for interface in type_def_interfaces(def, generics) {
             if let Type::TypeDef(def, generics) = interface {
                 combine(reader, def, &generics, &mut cfg);
             }
         }
     }
 
-    cfg_add_attributes(reader, &mut cfg, def);
+    cfg_add_attributes(&mut cfg, def);
     cfg
 }
 pub fn type_def_cfg_combine<'a>(reader: &'a Reader, row: TypeDef, generics: &[Type], cfg: &mut Cfg<'a>) {
-    let type_name = reader.type_def_type_name(row);
+    let type_name = row.type_name();
 
     for generic in generics {
         type_cfg_combine(reader, generic, cfg);
     }
 
     if cfg.types.entry(type_name.namespace).or_default().insert(row) {
-        match reader.type_def_kind(row) {
+        match row.kind() {
             TypeKind::Class => {
-                if let Some(default_interface) = type_def_default_interface(reader, row) {
+                if let Some(default_interface) = type_def_default_interface(row) {
                     type_cfg_combine(reader, &default_interface, cfg);
                 }
             }
             TypeKind::Interface => {
-                if !reader.type_def_flags(row).contains(TypeAttributes::WindowsRuntime) {
-                    for def in type_def_vtables(reader, row) {
+                if !row.flags().contains(TypeAttributes::WindowsRuntime) {
+                    for def in type_def_vtables(row) {
                         if let Type::TypeDef(def, _) = def {
-                            cfg.add_feature(reader.type_def_namespace(def));
+                            cfg.add_feature(def.namespace());
                         }
                     }
                 }
             }
             TypeKind::Struct => {
-                reader.type_def_fields(row).for_each(|field| field_cfg_combine(reader, field, Some(row), cfg));
+                row.fields().for_each(|field| field_cfg_combine(reader, field, Some(row), cfg));
                 if !type_name.namespace.is_empty() {
-                    for def in reader.get_type_def(type_name) {
+                    for def in reader.get_type_def(type_name.namespace, type_name.name) {
                         if def != row {
                             type_def_cfg_combine(reader, def, &[], cfg);
                         }
                     }
                 }
             }
-            TypeKind::Delegate => signature_cfg_combine(reader, &reader.method_def_signature(type_def_invoke_method(reader, row), generics), cfg),
+            TypeKind::Delegate => signature_cfg_combine(reader, &type_def_invoke_method(row).signature(generics), cfg),
             _ => {}
         }
     }
 }
 
-pub fn signature_cfg<'a>(reader: &'a Reader, method: MethodDef) -> Cfg<'a> {
+pub fn signature_cfg(reader: &Reader, method: MethodDef) -> Cfg {
     let mut cfg = Cfg::default();
-    signature_cfg_combine(reader, &reader.method_def_signature(method, &[]), &mut cfg);
-    cfg_add_attributes(reader, &mut cfg, method);
+    signature_cfg_combine(reader, &method.signature(&[]), &mut cfg);
+    cfg_add_attributes(&mut cfg, method);
     cfg
 }
 fn signature_cfg_combine<'a>(reader: &'a Reader, signature: &MethodDefSig, cfg: &mut Cfg<'a>) {
@@ -125,11 +125,11 @@ fn signature_cfg_combine<'a>(reader: &'a Reader, signature: &MethodDefSig, cfg:
     signature.params.iter().for_each(|param| type_cfg_combine(reader, param, cfg));
 }
 
-fn cfg_add_attributes<R: AsRow + Into<HasAttribute>>(reader: &Reader, cfg: &mut Cfg, row: R) {
-    for attribute in reader.attributes(row) {
-        match reader.attribute_name(attribute) {
+fn cfg_add_attributes<R: AsRow + Into<HasAttribute>>(cfg: &mut Cfg, row: R) {
+    for attribute in row.attributes() {
+        match attribute.name() {
             "SupportedArchitectureAttribute" => {
-                if let Some((_, Value::EnumDef(_, value))) = reader.attribute_args(attribute).get(0) {
+                if let Some((_, Value::EnumDef(_, value))) = attribute.args().get(0) {
                     if let Value::I32(value) = **value {
                         if value & 1 == 1 {
                             cfg.arches.insert("x86");
diff --git a/crates/libs/bindgen/src/rust/classes.rs b/crates/libs/bindgen/src/rust/classes.rs
index b20d99beaa..2ff96ef1f2 100644
--- a/crates/libs/bindgen/src/rust/classes.rs
+++ b/crates/libs/bindgen/src/rust/classes.rs
@@ -2,8 +2,8 @@ use super::*;
 
 pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
     if writer.sys {
-        if type_def_has_default_interface(writer.reader, def) {
-            let name = to_ident(writer.reader.type_def_name(def));
+        if type_def_has_default_interface(def) {
+            let name = to_ident(def.name());
             quote! {
                 pub type #name = *mut ::core::ffi::c_void;
             }
@@ -16,11 +16,11 @@ pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
 }
 
 fn gen_class(writer: &Writer, def: TypeDef) -> TokenStream {
-    if writer.reader.type_def_extends(def) == Some(TypeName::Attribute) {
+    if def.extends() == Some(TypeName::Attribute) {
         return TokenStream::new();
     }
 
-    let name = to_ident(writer.reader.type_def_name(def));
+    let name = to_ident(def.name());
     let interfaces = type_interfaces(writer.reader, &Type::TypeDef(def, Vec::new()));
     let mut methods = quote! {};
     let mut method_names = MethodNames::new();
@@ -33,7 +33,7 @@ fn gen_class(writer: &Writer, def: TypeDef) -> TokenStream {
         if let Type::TypeDef(def, generics) = &interface.ty {
             let mut virtual_names = MethodNames::new();
 
-            for method in writer.reader.type_def_methods(*def) {
+            for method in def.methods() {
                 methods.combine(&winrt_methods::writer(writer, *def, generics, interface.kind, method, &mut method_names, &mut virtual_names));
             }
         }
@@ -42,7 +42,7 @@ fn gen_class(writer: &Writer, def: TypeDef) -> TokenStream {
     let factories = interfaces.iter().filter_map(|interface| match interface.kind {
         InterfaceKind::Static => {
             if let Type::TypeDef(def, generics) = &interface.ty {
-                if writer.reader.type_def_methods(*def).next().is_some() {
+                if def.methods().next().is_some() {
                     let interface_type = writer.type_name(&interface.ty);
                     let features = writer.cfg_features(&type_def_cfg(writer.reader, *def, generics));
 
@@ -64,8 +64,8 @@ fn gen_class(writer: &Writer, def: TypeDef) -> TokenStream {
         _ => None,
     });
 
-    if type_def_has_default_interface(writer.reader, def) {
-        let new = if type_def_has_default_constructor(writer.reader, def) {
+    if type_def_has_default_interface(def) {
+        let new = if type_def_has_default_constructor(def) {
             quote! {
                 pub fn new() -> ::windows_core::Result<Self> {
                     Self::IActivationFactory(|f| f.ActivateInstance::<Self>())
@@ -129,7 +129,7 @@ fn gen_conversions(writer: &Writer, def: TypeDef, name: &TokenStream, interfaces
     };
 
     for interface in interfaces {
-        if type_is_exclusive(writer.reader, &interface.ty) {
+        if type_is_exclusive(&interface.ty) {
             continue;
         }
 
@@ -159,10 +159,10 @@ fn gen_conversions(writer: &Writer, def: TypeDef, name: &TokenStream, interfaces
     tokens
 }
 
-fn type_def_has_default_constructor(reader: &Reader, row: TypeDef) -> bool {
-    for attribute in reader.attributes(row) {
-        if reader.attribute_name(attribute) == "ActivatableAttribute" {
-            if reader.attribute_args(attribute).iter().any(|arg| matches!(arg.1, Value::TypeName(_))) {
+fn type_def_has_default_constructor(row: TypeDef) -> bool {
+    for attribute in row.attributes() {
+        if attribute.name() == "ActivatableAttribute" {
+            if attribute.args().iter().any(|arg| matches!(arg.1, Value::TypeName(_))) {
                 continue;
             } else {
                 return true;
@@ -172,13 +172,13 @@ fn type_def_has_default_constructor(reader: &Reader, row: TypeDef) -> bool {
     false
 }
 
-fn type_def_has_default_interface(reader: &Reader, row: TypeDef) -> bool {
-    reader.type_def_interface_impls(row).any(|imp| reader.has_attribute(imp, "DefaultAttribute"))
+fn type_def_has_default_interface(row: TypeDef) -> bool {
+    row.interface_impls().any(|imp| imp.has_attribute("DefaultAttribute"))
 }
 
-fn type_is_exclusive(reader: &Reader, ty: &Type) -> bool {
+fn type_is_exclusive(ty: &Type) -> bool {
     match ty {
-        Type::TypeDef(row, _) => type_def_is_exclusive(reader, *row),
+        Type::TypeDef(row, _) => type_def_is_exclusive(*row),
         _ => false,
     }
 }
diff --git a/crates/libs/bindgen/src/rust/com_methods.rs b/crates/libs/bindgen/src/rust/com_methods.rs
index 132e7f2202..4a0b0374c0 100644
--- a/crates/libs/bindgen/src/rust/com_methods.rs
+++ b/crates/libs/bindgen/src/rust/com_methods.rs
@@ -1,14 +1,14 @@
 use super::*;
 
 pub fn writer(writer: &Writer, def: TypeDef, kind: InterfaceKind, method: MethodDef, method_names: &mut MethodNames, virtual_names: &mut MethodNames, base_count: usize) -> TokenStream {
-    let signature = method_def_signature(writer.reader, writer.reader.type_def_namespace(def), method, &[]);
+    let signature = method_def_signature(writer.reader, def.namespace(), method, &[]);
 
-    let name = method_names.add(writer, method);
-    let vname = virtual_names.add(writer, method);
+    let name = method_names.add(method);
+    let vname = virtual_names.add(method);
     let generics = writer.constraint_generics(&signature.params);
     let where_clause = writer.where_clause(&signature.params);
     let mut cfg = signature_cfg(writer.reader, method);
-    cfg.add_feature(writer.reader.type_def_namespace(def));
+    cfg.add_feature(def.namespace());
     let doc = writer.cfg_method_doc(&cfg);
     let features = writer.cfg_features(&cfg);
 
@@ -22,7 +22,7 @@ pub fn writer(writer: &Writer, def: TypeDef, kind: InterfaceKind, method: Method
         bases.combine(&quote! { .base__ });
     }
 
-    let kind = signature_kind(writer.reader, &signature);
+    let kind = signature_kind(&signature);
     match kind {
         SignatureKind::Query(_) => {
             let args = writer.win32_args(&signature.params, kind);
@@ -84,7 +84,7 @@ pub fn writer(writer: &Writer, def: TypeDef, kind: InterfaceKind, method: Method
             let args = writer.win32_args(&signature.params, kind);
             let params = writer.win32_params(&signature.params, kind);
             let return_type = signature.params[signature.params.len() - 1].ty.deref();
-            let is_nullable = type_is_nullable(writer.reader, &return_type);
+            let is_nullable = type_is_nullable(&return_type);
             let return_type = writer.type_name(&return_type);
 
             if is_nullable {
@@ -153,7 +153,7 @@ pub fn writer(writer: &Writer, def: TypeDef, kind: InterfaceKind, method: Method
 }
 
 pub fn gen_upcall(writer: &Writer, sig: &Signature, inner: TokenStream) -> TokenStream {
-    match signature_kind(writer.reader, sig) {
+    match signature_kind(sig) {
         SignatureKind::ResultValue => {
             let invoke_args = sig.params[..sig.params.len() - 1].iter().map(|param| gen_win32_invoke_arg(writer, param));
 
@@ -197,9 +197,9 @@ pub fn gen_upcall(writer: &Writer, sig: &Signature, inner: TokenStream) -> Token
 fn gen_win32_invoke_arg(writer: &Writer, param: &SignatureParam) -> TokenStream {
     let name = writer.param_name(param.def);
 
-    if writer.reader.param_flags(param.def).contains(ParamAttributes::In) && type_is_nullable(writer.reader, &param.ty) {
+    if param.def.flags().contains(ParamAttributes::In) && type_is_nullable(&param.ty) {
         quote! { ::windows_core::from_raw_borrowed(&#name) }
-    } else if (!param.ty.is_pointer() && type_is_nullable(writer.reader, &param.ty)) || (writer.reader.param_flags(param.def).contains(ParamAttributes::In) && !type_is_primitive(writer.reader, &param.ty)) {
+    } else if (!param.ty.is_pointer() && type_is_nullable(&param.ty)) || (param.def.flags().contains(ParamAttributes::In) && !type_is_primitive(&param.ty)) {
         quote! { ::core::mem::transmute(&#name) }
     } else {
         quote! { ::core::mem::transmute_copy(&#name) }
diff --git a/crates/libs/bindgen/src/rust/constants.rs b/crates/libs/bindgen/src/rust/constants.rs
index 1943cd8809..d4ade7b3a9 100644
--- a/crates/libs/bindgen/src/rust/constants.rs
+++ b/crates/libs/bindgen/src/rust/constants.rs
@@ -1,27 +1,27 @@
 use super::*;
 
 pub fn writer(writer: &Writer, def: Field) -> TokenStream {
-    let name = to_ident(writer.reader.field_name(def));
-    let ty = writer.reader.field_type(def, None).to_const_type();
+    let name = to_ident(def.name());
+    let ty = def.ty(None).to_const_type();
     let cfg = field_cfg(writer.reader, def);
     let doc = writer.cfg_doc(&cfg);
     let features = writer.cfg_features(&cfg);
 
-    if let Some(constant) = writer.reader.field_constant(def) {
-        let constant_type = writer.reader.constant_type(constant);
+    if let Some(constant) = def.constant() {
+        let constant_type = constant.ty();
 
         if ty == constant_type {
             if ty == Type::String {
                 let crate_name = writer.crate_name();
-                if field_is_ansi(writer.reader, def) {
-                    let value = writer.value(&writer.reader.constant_value(constant));
+                if field_is_ansi(def) {
+                    let value = writer.value(&constant.value());
                     quote! {
                         #doc
                         #features
                         pub const #name: #crate_name PCSTR = #crate_name s!(#value);
                     }
                 } else {
-                    let value = writer.value(&writer.reader.constant_value(constant));
+                    let value = writer.value(&constant.value());
                     quote! {
                         #doc
                         #features
@@ -29,7 +29,7 @@ pub fn writer(writer: &Writer, def: Field) -> TokenStream {
                     }
                 }
             } else {
-                let value = writer.typed_value(&writer.reader.constant_value(constant));
+                let value = writer.typed_value(&constant.value());
                 quote! {
                     #doc
                     #features
@@ -38,8 +38,8 @@ pub fn writer(writer: &Writer, def: Field) -> TokenStream {
             }
         } else {
             let kind = writer.type_default_name(&ty);
-            let value = writer.value(&writer.reader.constant_value(constant));
-            let underlying_type = type_underlying_type(writer.reader, &ty);
+            let value = writer.value(&constant.value());
+            let underlying_type = type_underlying_type(&ty);
 
             let value = if underlying_type == constant_type {
                 value
@@ -49,7 +49,7 @@ pub fn writer(writer: &Writer, def: Field) -> TokenStream {
                 quote! { #value as _ }
             };
 
-            if !writer.sys && type_has_replacement(writer.reader, &ty) {
+            if !writer.sys && type_has_replacement(&ty) {
                 quote! {
                     #doc
                     #features
@@ -63,7 +63,7 @@ pub fn writer(writer: &Writer, def: Field) -> TokenStream {
                 }
             }
         }
-    } else if let Some(guid) = field_guid(writer.reader, def) {
+    } else if let Some(guid) = field_guid(def) {
         let value = writer.guid(&guid);
         let guid = writer.type_name(&Type::GUID);
         quote! {
@@ -84,19 +84,19 @@ pub fn writer(writer: &Writer, def: Field) -> TokenStream {
 }
 
 fn initializer(writer: &Writer, def: Field) -> Option<TokenStream> {
-    let Some(value) = constant(writer, def) else {
+    let Some(value) = constant(def) else {
         return None;
     };
 
     let mut input = value.as_str();
 
-    let Type::TypeDef(def, _) = writer.reader.field_type(def, None) else {
+    let Type::TypeDef(def, _) = def.ty(None) else {
         unimplemented!();
     };
 
     let mut result = quote! {};
 
-    for field in writer.reader.type_def_fields(def) {
+    for field in def.fields() {
         let (value, rest) = field_initializer(writer, field, input);
         input = rest;
         result.combine(&value);
@@ -106,12 +106,12 @@ fn initializer(writer: &Writer, def: Field) -> Option<TokenStream> {
 }
 
 fn field_initializer<'a>(writer: &Writer, field: Field, input: &'a str) -> (TokenStream, &'a str) {
-    let name = to_ident(writer.reader.field_name(field));
+    let name = to_ident(field.name());
 
-    match writer.reader.field_type(field, None) {
+    match field.ty(None) {
         Type::GUID => {
             let (literals, rest) = read_literal_array(input, 11);
-            let value = writer.guid(&GUID::from_string_args(&literals));
+            let value = writer.guid(&Guid::from_string_args(&literals));
             (quote! { #name: #value, }, rest)
         }
         Type::Win32Array(_, len) => {
@@ -127,9 +127,9 @@ fn field_initializer<'a>(writer: &Writer, field: Field, input: &'a str) -> (Toke
     }
 }
 
-fn constant(writer: &Writer, def: Field) -> Option<String> {
-    writer.reader.find_attribute(def, "ConstantAttribute").map(|attribute| {
-        let args = writer.reader.attribute_args(attribute);
+fn constant(def: Field) -> Option<String> {
+    def.find_attribute("ConstantAttribute").map(|attribute| {
+        let args = attribute.args();
         match &args[0].1 {
             Value::String(value) => value.clone(),
             rest => unimplemented!("{rest:?}"),
@@ -184,25 +184,25 @@ fn read_literal_array(input: &str, len: usize) -> (Vec<&str>, &str) {
     (result, read_token(input, b'}'))
 }
 
-fn field_guid(reader: &Reader, row: Field) -> Option<GUID> {
-    reader.find_attribute(row, "GuidAttribute").map(|attribute| GUID::from_args(&reader.attribute_args(attribute)))
+fn field_guid(row: Field) -> Option<Guid> {
+    row.find_attribute("GuidAttribute").map(|attribute| Guid::from_args(&attribute.args()))
 }
 
-fn field_is_ansi(reader: &Reader, row: Field) -> bool {
-    reader.find_attribute(row, "NativeEncodingAttribute").is_some_and(|attribute| matches!(reader.attribute_args(attribute).get(0), Some((_, Value::String(encoding))) if encoding == "ansi"))
+fn field_is_ansi(row: Field) -> bool {
+    row.find_attribute("NativeEncodingAttribute").is_some_and(|attribute| matches!(attribute.args().get(0), Some((_, Value::String(encoding))) if encoding == "ansi"))
 }
 
-fn type_has_replacement(reader: &Reader, ty: &Type) -> bool {
+fn type_has_replacement(ty: &Type) -> bool {
     match ty {
         Type::HRESULT | Type::PCSTR | Type::PCWSTR => true,
-        Type::TypeDef(row, _) => type_def_is_handle(reader, *row) || reader.type_def_kind(*row) == TypeKind::Enum,
+        Type::TypeDef(row, _) => type_def_is_handle(*row) || row.kind() == TypeKind::Enum,
         _ => false,
     }
 }
 
-fn type_underlying_type(reader: &Reader, ty: &Type) -> Type {
+fn type_underlying_type(ty: &Type) -> Type {
     match ty {
-        Type::TypeDef(row, _) => reader.type_def_underlying_type(*row),
+        Type::TypeDef(row, _) => row.underlying_type(),
         Type::HRESULT => Type::I32,
         _ => ty.clone(),
     }
diff --git a/crates/libs/bindgen/src/rust/delegates.rs b/crates/libs/bindgen/src/rust/delegates.rs
index f601c303f6..01d79a1166 100644
--- a/crates/libs/bindgen/src/rust/delegates.rs
+++ b/crates/libs/bindgen/src/rust/delegates.rs
@@ -1,7 +1,7 @@
 use super::*;
 
 pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
-    if writer.reader.type_def_flags(def).contains(TypeAttributes::WindowsRuntime) {
+    if def.flags().contains(TypeAttributes::WindowsRuntime) {
         gen_delegate(writer, def)
     } else {
         gen_callback(writer, def)
@@ -9,10 +9,10 @@ pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
 }
 
 fn gen_callback(writer: &Writer, def: TypeDef) -> TokenStream {
-    let name = to_ident(writer.reader.type_def_name(def));
-    let method = type_def_invoke_method(writer.reader, def);
+    let name = to_ident(def.name());
+    let method = type_def_invoke_method(def);
 
-    let signature = method_def_signature(writer.reader, writer.reader.type_def_namespace(def), method, &[]);
+    let signature = method_def_signature(writer.reader, def.namespace(), method, &[]);
 
     let return_type = writer.return_sig(&signature);
     let cfg = type_def_cfg(writer.reader, def, &[]);
@@ -34,7 +34,7 @@ fn gen_callback(writer: &Writer, def: TypeDef) -> TokenStream {
 
 fn gen_delegate(writer: &Writer, def: TypeDef) -> TokenStream {
     if writer.sys {
-        let name = to_ident(writer.reader.type_def_name(def));
+        let name = to_ident(def.name());
         quote! {
             pub type #name = *mut ::core::ffi::c_void;
         }
@@ -44,20 +44,20 @@ fn gen_delegate(writer: &Writer, def: TypeDef) -> TokenStream {
 }
 
 fn gen_win_delegate(writer: &Writer, def: TypeDef) -> TokenStream {
-    let name = to_ident(writer.reader.type_def_name(def));
+    let name = to_ident(def.name());
     let vtbl = name.join("_Vtbl");
     let boxed = name.join("Box");
 
-    let generics = &type_def_generics(writer.reader, def);
+    let generics = &type_def_generics(def);
     let phantoms = writer.generic_phantoms(generics);
     let named_phantoms = writer.generic_named_phantoms(generics);
     let constraints = writer.generic_constraints(generics);
     let generic_names = writer.generic_names(generics);
 
     let ident = writer.type_def_name(def, generics);
-    let method = type_def_invoke_method(writer.reader, def);
+    let method = type_def_invoke_method(def);
 
-    let signature = method_def_signature(writer.reader, writer.reader.type_def_namespace(def), method, generics);
+    let signature = method_def_signature(writer.reader, def.namespace(), method, generics);
 
     let fn_constraint = gen_fn_constraint(writer, def, &signature);
     let cfg = type_def_cfg(writer.reader, def, generics);
diff --git a/crates/libs/bindgen/src/rust/enums.rs b/crates/libs/bindgen/src/rust/enums.rs
index 344ca28ae2..ad4b677fa0 100644
--- a/crates/libs/bindgen/src/rust/enums.rs
+++ b/crates/libs/bindgen/src/rust/enums.rs
@@ -1,26 +1,25 @@
 use super::*;
 
 pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
-    let type_name = writer.reader.type_def_type_name(def);
+    let type_name = def.type_name();
     let ident = to_ident(type_name.name);
-    let underlying_type = writer.reader.type_def_underlying_type(def);
+    let underlying_type = def.underlying_type();
     let underlying_type = writer.type_name(&underlying_type);
 
     // TODO: unscoped enums should be removed from metadata
-    let is_scoped = writer.reader.type_def_flags(def).contains(TypeAttributes::WindowsRuntime) || writer.reader.has_attribute(def, "ScopedEnumAttribute");
+    let is_scoped = def.flags().contains(TypeAttributes::WindowsRuntime) || def.has_attribute("ScopedEnumAttribute");
 
     let cfg = type_def_cfg(writer.reader, def, &[]);
     let doc = writer.cfg_doc(&cfg);
     let features = writer.cfg_features(&cfg);
 
-    let fields: Vec<(TokenStream, TokenStream)> = writer
-        .reader
-        .type_def_fields(def)
+    let fields: Vec<(TokenStream, TokenStream)> = def
+        .fields()
         .filter_map(|field| {
-            if writer.reader.field_flags(field).contains(FieldAttributes::Literal) {
-                let field_name = to_ident(writer.reader.field_name(field));
-                let constant = writer.reader.field_constant(field).unwrap();
-                let value = writer.value(&writer.reader.constant_value(constant));
+            if field.flags().contains(FieldAttributes::Literal) {
+                let field_name = to_ident(field.name());
+                let constant = field.constant().unwrap();
+                let value = writer.value(&constant.value());
 
                 Some((field_name, value))
             } else {
@@ -111,7 +110,7 @@ pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
         // Win32 enums use the Flags attribute. WinRT enums don't have the Flags attribute but are paritioned merely based
         // on whether they are signed.
         // TODO: Win32 metadata should just follow WinRT's example here.
-        let type_def_is_flags = writer.reader.has_attribute(def, "FlagsAttribute") || (writer.reader.type_def_flags(def).contains(TypeAttributes::WindowsRuntime) && writer.reader.type_def_underlying_type(def) == Type::U32);
+        let type_def_is_flags = def.has_attribute("FlagsAttribute") || (def.flags().contains(TypeAttributes::WindowsRuntime) && def.underlying_type() == Type::U32);
 
         if type_def_is_flags {
             tokens.combine(&quote! {
@@ -160,7 +159,7 @@ pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
             });
         }
 
-        if writer.reader.type_def_flags(def).contains(TypeAttributes::WindowsRuntime) {
+        if def.flags().contains(TypeAttributes::WindowsRuntime) {
             let signature = Literal::byte_string(type_def_signature(writer.reader, def, &[]).as_bytes());
 
             tokens.combine(&quote! {
diff --git a/crates/libs/bindgen/src/rust/functions.rs b/crates/libs/bindgen/src/rust/functions.rs
index e790a34ed2..f0e79bbf75 100644
--- a/crates/libs/bindgen/src/rust/functions.rs
+++ b/crates/libs/bindgen/src/rust/functions.rs
@@ -2,13 +2,13 @@ use super::*;
 
 pub fn writer(writer: &Writer, namespace: &str, def: MethodDef) -> TokenStream {
     // TODO: remove inline functions from metadata
-    if writer.reader.method_def_module_name(def) == "forceinline" {
+    if def.module_name() == "forceinline" {
         return quote! {};
     }
 
     // TODO: remove ordinal functions from metadata
-    if let Some(impl_map) = writer.reader.method_def_impl_map(def) {
-        if writer.reader.impl_map_import_name(impl_map).starts_with('#') {
+    if let Some(impl_map) = def.impl_map() {
+        if impl_map.import_name().starts_with('#') {
             return quote! {};
         }
     }
@@ -29,7 +29,7 @@ fn gen_sys_function(writer: &Writer, namespace: &str, def: MethodDef) -> TokenSt
 }
 
 fn gen_win_function(writer: &Writer, namespace: &str, def: MethodDef) -> TokenStream {
-    let name = to_ident(writer.reader.method_def_name(def));
+    let name = to_ident(def.name());
     let signature = method_def_signature(writer.reader, namespace, def, &[]);
     let generics = writer.constraint_generics(&signature.params);
     let where_clause = writer.where_clause(&signature.params);
@@ -39,7 +39,7 @@ fn gen_win_function(writer: &Writer, namespace: &str, def: MethodDef) -> TokenSt
     let features = writer.cfg_features(&cfg);
     let link = gen_link(writer, namespace, &signature, &cfg);
 
-    let kind = signature_kind(writer.reader, &signature);
+    let kind = signature_kind(&signature);
     match kind {
         SignatureKind::Query(_) => {
             let args = writer.win32_args(&signature.params, kind);
@@ -109,7 +109,7 @@ fn gen_win_function(writer: &Writer, namespace: &str, def: MethodDef) -> TokenSt
             let args = writer.win32_args(&signature.params, kind);
             let params = writer.win32_params(&signature.params, kind);
             let return_type = signature.params[signature.params.len() - 1].ty.deref();
-            let is_nullable = type_is_nullable(writer.reader, &return_type);
+            let is_nullable = type_is_nullable(&return_type);
             let return_type = writer.type_name(&return_type);
 
             if is_nullable {
@@ -139,7 +139,7 @@ fn gen_win_function(writer: &Writer, namespace: &str, def: MethodDef) -> TokenSt
             }
         }
         SignatureKind::ReturnStruct | SignatureKind::PreserveSig => {
-            if handle_last_error(writer, def, &signature) {
+            if handle_last_error(def, &signature) {
                 let args = writer.win32_args(&signature.params, kind);
                 let params = writer.win32_params(&signature.params, kind);
                 let return_type = writer.type_name(&signature.return_type);
@@ -172,7 +172,7 @@ fn gen_win_function(writer: &Writer, namespace: &str, def: MethodDef) -> TokenSt
         SignatureKind::ReturnVoid => {
             let args = writer.win32_args(&signature.params, kind);
             let params = writer.win32_params(&signature.params, kind);
-            let does_not_return = does_not_return(writer, def);
+            let does_not_return = does_not_return(def);
 
             quote! {
                 #doc
@@ -188,12 +188,12 @@ fn gen_win_function(writer: &Writer, namespace: &str, def: MethodDef) -> TokenSt
 }
 
 fn gen_link(writer: &Writer, namespace: &str, signature: &Signature, cfg: &Cfg) -> TokenStream {
-    let name = writer.reader.method_def_name(signature.def);
+    let name = signature.def.name();
     let ident = to_ident(name);
-    let library = writer.reader.method_def_module_name(signature.def);
-    let abi = method_def_extern_abi(writer.reader, signature.def);
+    let library = signature.def.module_name();
+    let abi = method_def_extern_abi(signature.def);
 
-    let symbol = if let Some(impl_map) = writer.reader.method_def_impl_map(signature.def) { writer.reader.impl_map_import_name(impl_map) } else { name };
+    let symbol = if let Some(impl_map) = signature.def.impl_map() { impl_map.import_name() } else { name };
 
     let link_name = if symbol != name {
         quote! { #[link_name = #symbol] }
@@ -240,23 +240,23 @@ fn gen_link(writer: &Writer, namespace: &str, signature: &Signature, cfg: &Cfg)
     }
 }
 
-fn does_not_return(writer: &Writer, def: MethodDef) -> TokenStream {
-    if writer.reader.has_attribute(def, "DoesNotReturnAttribute") {
+fn does_not_return(def: MethodDef) -> TokenStream {
+    if def.has_attribute("DoesNotReturnAttribute") {
         quote! { -> ! }
     } else {
         quote! {}
     }
 }
 
-fn handle_last_error(writer: &Writer, def: MethodDef, signature: &Signature) -> bool {
-    if let Some(map) = writer.reader.method_def_impl_map(def) {
-        if writer.reader.impl_map_flags(map).contains(PInvokeAttributes::SupportsLastError) {
+fn handle_last_error(def: MethodDef, signature: &Signature) -> bool {
+    if let Some(map) = def.impl_map() {
+        if map.flags().contains(PInvokeAttributes::SupportsLastError) {
             if let Type::TypeDef(return_type, _) = &signature.return_type {
-                if type_def_is_handle(writer.reader, *return_type) {
-                    if writer.reader.type_def_underlying_type(*return_type).is_pointer() {
+                if type_def_is_handle(*return_type) {
+                    if return_type.underlying_type().is_pointer() {
                         return true;
                     }
-                    if !type_def_invalid_values(writer.reader, *return_type).is_empty() {
+                    if !type_def_invalid_values(*return_type).is_empty() {
                         return true;
                     }
                 }
@@ -266,9 +266,9 @@ fn handle_last_error(writer: &Writer, def: MethodDef, signature: &Signature) ->
     false
 }
 
-fn method_def_extern_abi(reader: &Reader, def: MethodDef) -> &'static str {
-    let impl_map = reader.method_def_impl_map(def).expect("ImplMap not found");
-    let flags = reader.impl_map_flags(impl_map);
+fn method_def_extern_abi(def: MethodDef) -> &'static str {
+    let impl_map = def.impl_map().expect("ImplMap not found");
+    let flags = impl_map.flags();
 
     if flags.contains(PInvokeAttributes::CallConvPlatformapi) {
         "system"
diff --git a/crates/libs/bindgen/src/rust/handles.rs b/crates/libs/bindgen/src/rust/handles.rs
index 7e067a492c..b984ca2a4e 100644
--- a/crates/libs/bindgen/src/rust/handles.rs
+++ b/crates/libs/bindgen/src/rust/handles.rs
@@ -9,8 +9,8 @@ pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
 }
 
 pub fn gen_sys_handle(writer: &Writer, def: TypeDef) -> TokenStream {
-    let ident = to_ident(writer.reader.type_def_name(def));
-    match writer.reader.type_def_underlying_type(def) {
+    let ident = to_ident(def.name());
+    match def.underlying_type() {
         Type::ISize if writer.std => quote! {
             pub type #ident = *mut ::core::ffi::c_void;
         },
@@ -25,9 +25,9 @@ pub fn gen_sys_handle(writer: &Writer, def: TypeDef) -> TokenStream {
 }
 
 pub fn gen_win_handle(writer: &Writer, def: TypeDef) -> TokenStream {
-    let name = writer.reader.type_def_name(def);
+    let name = def.name();
     let ident = to_ident(name);
-    let underlying_type = writer.reader.type_def_underlying_type(def);
+    let underlying_type = def.underlying_type();
     let signature = writer.type_default_name(&underlying_type);
     let check = if underlying_type.is_pointer() {
         quote! {
@@ -38,7 +38,7 @@ pub fn gen_win_handle(writer: &Writer, def: TypeDef) -> TokenStream {
             }
         }
     } else {
-        let invalid = type_def_invalid_values(writer.reader, def);
+        let invalid = type_def_invalid_values(def);
 
         if !invalid.is_empty() {
             let invalid = invalid.iter().map(|value| {
@@ -90,7 +90,7 @@ pub fn gen_win_handle(writer: &Writer, def: TypeDef) -> TokenStream {
     };
 
     if let Some(dependency) = type_def_usable_for(writer.reader, def) {
-        let type_name = writer.reader.type_def_type_name(dependency);
+        let type_name = dependency.type_name();
         let mut dependency = writer.namespace(type_name.namespace);
         dependency.push_str(type_name.name);
 
@@ -108,9 +108,9 @@ pub fn gen_win_handle(writer: &Writer, def: TypeDef) -> TokenStream {
 }
 
 fn type_def_usable_for(reader: &Reader, row: TypeDef) -> Option<TypeDef> {
-    if let Some(attribute) = reader.find_attribute(row, "AlsoUsableForAttribute") {
-        if let Some((_, Value::String(name))) = reader.attribute_args(attribute).get(0) {
-            return reader.get_type_def(TypeName::new(reader.type_def_namespace(row), name.as_str())).next();
+    if let Some(attribute) = row.find_attribute("AlsoUsableForAttribute") {
+        if let Some((_, Value::String(name))) = attribute.args().get(0) {
+            return reader.get_type_def(row.namespace(), name.as_str()).next();
         }
     }
     None
diff --git a/crates/libs/bindgen/src/rust/implements.rs b/crates/libs/bindgen/src/rust/implements.rs
index f4a0b4b794..c2b43c2059 100644
--- a/crates/libs/bindgen/src/rust/implements.rs
+++ b/crates/libs/bindgen/src/rust/implements.rs
@@ -1,12 +1,12 @@
 use super::*;
 
 pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
-    if writer.reader.type_def_kind(def) != TypeKind::Interface || (!writer.implement && writer.reader.has_attribute(def, "ExclusiveToAttribute")) {
+    if def.kind() != TypeKind::Interface || (!writer.implement && def.has_attribute("ExclusiveToAttribute")) {
         return quote! {};
     }
 
-    let generics = &type_def_generics(writer.reader, def);
-    let type_ident = to_ident(writer.reader.type_def_name(def));
+    let generics = &type_def_generics(def);
+    let type_ident = to_ident(def.name());
     let impl_ident = type_ident.join("_Impl");
     let vtbl_ident = type_ident.join("_Vtbl");
     let implvtbl_ident = impl_ident.join("Vtbl");
@@ -18,7 +18,7 @@ pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
     let features = writer.cfg_features(&cfg);
     let mut requires = quote! {};
     let type_ident = quote! { #type_ident<#generic_names> };
-    let vtables = type_def_vtables(writer.reader, def);
+    let vtables = type_def_vtables(def);
     let has_unknown_base = matches!(vtables.first(), Some(Type::IUnknown));
 
     fn gen_required_trait(writer: &Writer, def: TypeDef, generics: &[Type]) -> TokenStream {
@@ -44,7 +44,7 @@ pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
         }
     }
 
-    if writer.reader.type_def_flags(def).contains(TypeAttributes::WindowsRuntime) {
+    if def.flags().contains(TypeAttributes::WindowsRuntime) {
         // TODO: this awkward wrapping of TypeDefs needs fixing
         for interface in type_interfaces(writer.reader, &Type::TypeDef(def, generics.to_vec())) {
             if let Type::TypeDef(def, generics) = interface.ty {
@@ -56,26 +56,26 @@ pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
     let runtime_name = writer.runtime_name_trait(def, generics, &type_ident, &constraints, &features);
 
     let mut method_names = MethodNames::new();
-    method_names.add_vtable_types(writer, def);
+    method_names.add_vtable_types(def);
 
-    let method_traits = writer.reader.type_def_methods(def).map(|method| {
-        let name = method_names.add(writer, method);
+    let method_traits = def.methods().map(|method| {
+        let name = method_names.add(method);
 
-        let signature = method_def_signature(writer.reader, writer.reader.type_def_namespace(def), method, generics);
+        let signature = method_def_signature(writer.reader, def.namespace(), method, generics);
 
         let signature_tokens = writer.impl_signature(def, &signature);
         quote! { fn #name #signature_tokens; }
     });
 
     let mut method_names = MethodNames::new();
-    method_names.add_vtable_types(writer, def);
+    method_names.add_vtable_types(def);
 
-    let method_impls = writer.reader.type_def_methods(def).map(|method| {
-        let name = method_names.add(writer, method);
-        let signature = method_def_signature(writer.reader, writer.reader.type_def_namespace(def), method, generics);
+    let method_impls = def.methods().map(|method| {
+        let name = method_names.add(method);
+        let signature = method_def_signature(writer.reader, def.namespace(), method, generics);
         let vtbl_signature = writer.vtbl_signature(def, generics, &signature);
 
-        let invoke_upcall = if writer.reader.type_def_flags(def).contains(TypeAttributes::WindowsRuntime) { winrt_methods::gen_upcall(writer, &signature, quote! { this.#name }) } else { com_methods::gen_upcall(writer, &signature, quote! { this.#name }) };
+        let invoke_upcall = if def.flags().contains(TypeAttributes::WindowsRuntime) { winrt_methods::gen_upcall(writer, &signature, quote! { this.#name }) } else { com_methods::gen_upcall(writer, &signature, quote! { this.#name }) };
 
         if has_unknown_base {
             quote! {
@@ -114,10 +114,10 @@ pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
     }
 
     let mut method_names = MethodNames::new();
-    method_names.add_vtable_types(writer, def);
+    method_names.add_vtable_types(def);
 
-    for method in writer.reader.type_def_methods(def) {
-        let name = method_names.add(writer, method);
+    for method in def.methods() {
+        let name = method_names.add(method);
         if has_unknown_base {
             methods.combine(&quote! { #name: #name::<#generic_names Identity, Impl, OFFSET>, });
         } else {
diff --git a/crates/libs/bindgen/src/rust/interfaces.rs b/crates/libs/bindgen/src/rust/interfaces.rs
index 5082fd1483..fa62d58f02 100644
--- a/crates/libs/bindgen/src/rust/interfaces.rs
+++ b/crates/libs/bindgen/src/rust/interfaces.rs
@@ -2,17 +2,17 @@ use super::*;
 
 pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
     if writer.sys {
-        gen_sys_interface(writer, def)
+        gen_sys_interface(def)
     } else {
         gen_win_interface(writer, def)
     }
 }
 
-fn gen_sys_interface(writer: &Writer, def: TypeDef) -> TokenStream {
-    let name = writer.reader.type_def_name(def);
+fn gen_sys_interface(def: TypeDef) -> TokenStream {
+    let name = def.name();
     let ident = to_ident(name);
 
-    if type_def_is_exclusive(writer.reader, def) {
+    if type_def_is_exclusive(def) {
         quote! {}
     } else {
         quote! {
@@ -22,16 +22,16 @@ fn gen_sys_interface(writer: &Writer, def: TypeDef) -> TokenStream {
 }
 
 fn gen_win_interface(writer: &Writer, def: TypeDef) -> TokenStream {
-    let generics = &type_def_generics(writer.reader, def);
+    let generics = &type_def_generics(def);
     let ident = writer.type_def_name(def, generics);
-    let is_exclusive = type_def_is_exclusive(writer.reader, def);
+    let is_exclusive = type_def_is_exclusive(def);
     let phantoms = writer.generic_phantoms(generics);
     let constraints = writer.generic_constraints(generics);
     let cfg = type_def_cfg(writer.reader, def, &[]);
     let doc = writer.cfg_doc(&cfg);
     let features = writer.cfg_features(&cfg);
     let interfaces = type_interfaces(writer.reader, &Type::TypeDef(def, generics.to_vec()));
-    let vtables = type_def_vtables(writer.reader, def);
+    let vtables = type_def_vtables(def);
     let has_unknown_base = matches!(vtables.first(), Some(Type::IUnknown));
 
     let mut tokens = if is_exclusive {
@@ -63,13 +63,13 @@ fn gen_win_interface(writer: &Writer, def: TypeDef) -> TokenStream {
         let method_names = &mut MethodNames::new();
         let virtual_names = &mut MethodNames::new();
 
-        if writer.reader.type_def_flags(def).contains(TypeAttributes::WindowsRuntime) {
-            for method in writer.reader.type_def_methods(def) {
+        if def.flags().contains(TypeAttributes::WindowsRuntime) {
+            for method in def.methods() {
                 methods.combine(&winrt_methods::writer(writer, def, generics, InterfaceKind::Default, method, method_names, virtual_names));
             }
             for interface in &interfaces {
                 if let Type::TypeDef(def, generics) = &interface.ty {
-                    for method in writer.reader.type_def_methods(*def) {
+                    for method in def.methods() {
                         methods.combine(&winrt_methods::writer(writer, *def, generics, InterfaceKind::None, method, method_names, virtual_names));
                     }
                 }
@@ -80,8 +80,8 @@ fn gen_win_interface(writer: &Writer, def: TypeDef) -> TokenStream {
                 match ty {
                     Type::IUnknown | Type::IInspectable => {}
                     Type::TypeDef(def, _) => {
-                        let kind = if writer.reader.type_def_type_name(*def) == TypeName::IDispatch { InterfaceKind::None } else { InterfaceKind::Default };
-                        for method in writer.reader.type_def_methods(*def) {
+                        let kind = if def.type_name() == TypeName::IDispatch { InterfaceKind::None } else { InterfaceKind::Default };
+                        for method in def.methods() {
                             methods.combine(&com_methods::writer(writer, *def, kind, method, method_names, virtual_names, bases));
                         }
                     }
@@ -90,7 +90,7 @@ fn gen_win_interface(writer: &Writer, def: TypeDef) -> TokenStream {
 
                 bases -= 1;
             }
-            for method in writer.reader.type_def_methods(def) {
+            for method in def.methods() {
                 methods.combine(&com_methods::writer(writer, def, InterfaceKind::Default, method, method_names, virtual_names, 0));
             }
         }
@@ -127,7 +127,7 @@ fn gen_win_interface(writer: &Writer, def: TypeDef) -> TokenStream {
             }
         }
 
-        if writer.reader.type_def_flags(def).contains(TypeAttributes::WindowsRuntime) {
+        if def.flags().contains(TypeAttributes::WindowsRuntime) {
             for interface in &interfaces {
                 let into = writer.type_name(&interface.ty);
                 let cfg = writer.cfg_features(&cfg.union(&type_cfg(writer.reader, &interface.ty)));
diff --git a/crates/libs/bindgen/src/rust/iterators.rs b/crates/libs/bindgen/src/rust/iterators.rs
index 63ba56aaf9..89f58df5fe 100644
--- a/crates/libs/bindgen/src/rust/iterators.rs
+++ b/crates/libs/bindgen/src/rust/iterators.rs
@@ -1,7 +1,7 @@
 use super::*;
 
 pub fn writer(writer: &Writer, def: TypeDef, generics: &[Type], ident: &TokenStream, constraints: &TokenStream, _phantoms: &TokenStream, cfg: &Cfg) -> TokenStream {
-    match writer.reader.type_def_type_name(def) {
+    match def.type_name() {
         // If the type is IIterator<T> then simply implement the Iterator trait over top.
         TypeName::IIterator => {
             return quote! {
@@ -149,7 +149,7 @@ pub fn writer(writer: &Writer, def: TypeDef, generics: &[Type], ident: &TokenStr
     // implements any one of them. Here is where we favor IVectorView/IVector over IIterable.
     for interface in interfaces {
         if let Type::TypeDef(interface, interface_generics) = &interface.ty {
-            match writer.reader.type_def_type_name(*interface) {
+            match interface.type_name() {
                 TypeName::IVectorView => {
                     let item = writer.type_name(&interface_generics[0]);
                     let mut cfg = cfg.clone();
diff --git a/crates/libs/bindgen/src/rust/method_names.rs b/crates/libs/bindgen/src/rust/method_names.rs
index 9271e8c021..14a9d6501e 100644
--- a/crates/libs/bindgen/src/rust/method_names.rs
+++ b/crates/libs/bindgen/src/rust/method_names.rs
@@ -7,8 +7,8 @@ impl MethodNames {
         Self(BTreeMap::new())
     }
 
-    pub fn add(&mut self, writer: &Writer, method: MethodDef) -> TokenStream {
-        let name = method_def_special_name(writer.reader, method);
+    pub fn add(&mut self, method: MethodDef) -> TokenStream {
+        let name = method_def_special_name(method);
         let overload = self.0.entry(name.to_string()).or_insert(0);
         *overload += 1;
         if *overload > 1 {
@@ -18,20 +18,20 @@ impl MethodNames {
         }
     }
 
-    pub fn add_vtable_types(&mut self, writer: &Writer, def: TypeDef) {
-        for def in type_def_vtables(writer.reader, def) {
+    pub fn add_vtable_types(&mut self, def: TypeDef) {
+        for def in type_def_vtables(def) {
             if let Type::TypeDef(def, _) = def {
-                for method in writer.reader.type_def_methods(def) {
-                    self.add(writer, method);
+                for method in def.methods() {
+                    self.add(method);
                 }
             }
         }
     }
 }
 
-fn method_def_special_name(reader: &Reader, row: MethodDef) -> String {
-    let name = reader.method_def_name(row);
-    if reader.method_def_flags(row).contains(MethodAttributes::SpecialName) {
+fn method_def_special_name(row: MethodDef) -> String {
+    let name = row.name();
+    if row.flags().contains(MethodAttributes::SpecialName) {
         if name.starts_with("get") {
             name[4..].to_string()
         } else if name.starts_with("put") {
@@ -44,8 +44,8 @@ fn method_def_special_name(reader: &Reader, row: MethodDef) -> String {
             name.to_string()
         }
     } else {
-        if let Some(attribute) = reader.find_attribute(row, "OverloadAttribute") {
-            for (_, arg) in reader.attribute_args(attribute) {
+        if let Some(attribute) = row.find_attribute("OverloadAttribute") {
+            for (_, arg) in attribute.args() {
                 if let Value::String(name) = arg {
                     return name;
                 }
diff --git a/crates/libs/bindgen/src/rust/mod.rs b/crates/libs/bindgen/src/rust/mod.rs
index 92817ae2b1..199ac642dc 100644
--- a/crates/libs/bindgen/src/rust/mod.rs
+++ b/crates/libs/bindgen/src/rust/mod.rs
@@ -165,7 +165,7 @@ fn namespace(writer: &Writer, tree: &Tree) -> String {
     for item in writer.reader.namespace_items(writer.namespace, writer.filter) {
         match item {
             Item::Type(def) => {
-                let type_name = writer.reader.type_def_type_name(def);
+                let type_name = def.type_name();
                 if REMAP_TYPES.iter().any(|(x, _)| x == &type_name) {
                     continue;
                 }
@@ -173,18 +173,18 @@ fn namespace(writer: &Writer, tree: &Tree) -> String {
                     continue;
                 }
                 let name = type_name.name;
-                let kind = writer.reader.type_def_kind(def);
+                let kind = def.kind();
                 match kind {
                     TypeKind::Class => {
-                        if writer.reader.type_def_flags(def).contains(TypeAttributes::WindowsRuntime) {
+                        if def.flags().contains(TypeAttributes::WindowsRuntime) {
                             types.entry(kind).or_default().insert(name, classes::writer(writer, def));
                         }
                     }
                     TypeKind::Interface => types.entry(kind).or_default().entry(name).or_default().combine(&interfaces::writer(writer, def)),
                     TypeKind::Enum => types.entry(kind).or_default().entry(name).or_default().combine(&enums::writer(writer, def)),
                     TypeKind::Struct => {
-                        if writer.reader.type_def_fields(def).next().is_none() {
-                            if let Some(guid) = type_def_guid(writer.reader, def) {
+                        if def.fields().next().is_none() {
+                            if let Some(guid) = type_def_guid(def) {
                                 let ident = to_ident(name);
                                 let value = writer.guid(&guid);
                                 let guid = writer.type_name(&Type::GUID);
@@ -204,11 +204,11 @@ fn namespace(writer: &Writer, tree: &Tree) -> String {
                 }
             }
             Item::Fn(def, namespace) => {
-                let name = writer.reader.method_def_name(def);
-                functions.entry(name).or_default().combine(&functions::writer(writer, &namespace, def));
+                let name = def.name();
+                functions.entry(name).or_default().combine(&functions::writer(writer, namespace, def));
             }
             Item::Const(def) => {
-                let name = writer.reader.field_name(def);
+                let name = def.name();
                 types.entry(TypeKind::Class).or_default().entry(name).or_default().combine(&constants::writer(writer, def));
             }
         }
@@ -238,11 +238,11 @@ fn namespace_impl(writer: &Writer, tree: &Tree) -> String {
 
     for item in writer.reader.namespace_items(tree.namespace, writer.filter) {
         if let Item::Type(def) = item {
-            let type_name = writer.reader.type_def_type_name(def);
+            let type_name = def.type_name();
             if CORE_TYPES.iter().any(|(x, _)| x == &type_name) {
                 continue;
             }
-            if writer.reader.type_def_kind(def) != TypeKind::Interface {
+            if def.kind() != TypeKind::Interface {
                 continue;
             }
             let tokens = implements::writer(writer, def);
diff --git a/crates/libs/bindgen/src/rust/standalone.rs b/crates/libs/bindgen/src/rust/standalone.rs
index f74c34647b..57583a83a2 100644
--- a/crates/libs/bindgen/src/rust/standalone.rs
+++ b/crates/libs/bindgen/src/rust/standalone.rs
@@ -10,7 +10,7 @@ pub fn standalone_imp(writer: &Writer) -> String {
 
         match item {
             Item::Type(_) => {}
-            Item::Fn(def, namespace) => _ = functions.insert((def, namespace.clone())),
+            Item::Fn(def, namespace) => _ = functions.insert((def, namespace)),
             Item::Const(def) => _ = constants.insert(def),
         }
     }
@@ -54,10 +54,10 @@ pub fn standalone_imp(writer: &Writer) -> String {
                 );
             }
             Type::TypeDef(def, _) => {
-                let kind = writer.reader.type_def_kind(def);
+                let kind = def.kind();
                 match kind {
                     TypeKind::Class => {
-                        let name = writer.reader.type_def_name(def);
+                        let name = def.name();
                         if writer.sys {
                             let ident = to_ident(name);
                             sorted.insert(name, quote! { pub type #ident = *mut ::core::ffi::c_void; });
@@ -66,7 +66,7 @@ pub fn standalone_imp(writer: &Writer) -> String {
                         }
                     }
                     TypeKind::Interface => {
-                        let name = writer.reader.type_def_name(def);
+                        let name = def.name();
                         if writer.sys {
                             let ident = to_ident(name);
                             sorted.insert(name, quote! { pub type #ident = *mut ::core::ffi::c_void; });
@@ -75,12 +75,12 @@ pub fn standalone_imp(writer: &Writer) -> String {
                         }
                     }
                     TypeKind::Enum => {
-                        sorted.insert(writer.reader.type_def_name(def), enums::writer(writer, def));
+                        sorted.insert(def.name(), enums::writer(writer, def));
                     }
                     TypeKind::Struct => {
-                        let name = writer.reader.type_def_name(def);
-                        if writer.reader.type_def_fields(def).next().is_none() {
-                            if let Some(guid) = type_def_guid(writer.reader, def) {
+                        let name = def.name();
+                        if def.fields().next().is_none() {
+                            if let Some(guid) = type_def_guid(def) {
                                 let ident = to_ident(name);
                                 let value = writer.guid(&guid);
                                 let guid = writer.type_name(&Type::GUID);
@@ -96,7 +96,7 @@ pub fn standalone_imp(writer: &Writer) -> String {
                         sorted.insert(name, structs::writer(writer, def));
                     }
                     TypeKind::Delegate => {
-                        sorted.insert(writer.reader.type_def_name(def), delegates::writer(writer, def));
+                        sorted.insert(def.name(), delegates::writer(writer, def));
                     }
                 }
             }
@@ -105,11 +105,11 @@ pub fn standalone_imp(writer: &Writer) -> String {
     }
 
     for (function, namespace) in functions {
-        sorted.insert(&format!(".{}.{}", writer.reader.method_def_module_name(function), writer.reader.method_def_name(function)), functions::writer(writer, &namespace, function));
+        sorted.insert(&format!(".{}.{}", function.module_name(), function.name()), functions::writer(writer, namespace, function));
     }
 
     for constant in constants {
-        sorted.insert(writer.reader.field_name(constant), constants::writer(writer, constant));
+        sorted.insert(constant.name(), constants::writer(writer, constant));
     }
 
     let mut tokens = TokenStream::new();
@@ -129,9 +129,9 @@ impl SortedTokens {
 fn item_collect_standalone(reader: &Reader, item: Item, set: &mut BTreeSet<Type>) {
     match item {
         Item::Type(def) => type_collect_standalone(reader, &Type::TypeDef(def, vec![]), set),
-        Item::Const(def) => type_collect_standalone(reader, &reader.field_type(def, None).to_const_type(), set),
+        Item::Const(def) => type_collect_standalone(reader, &def.ty(None).to_const_type(), set),
         Item::Fn(def, namespace) => {
-            let signature = method_def_signature(reader, &namespace, def, &[]);
+            let signature = method_def_signature(reader, namespace, def, &[]);
             type_collect_standalone(reader, &signature.return_type, set);
             signature.params.iter().for_each(|param| type_collect_standalone(reader, &param.ty, set));
         }
@@ -157,9 +157,9 @@ fn type_collect_standalone(reader: &Reader, ty: &Type, set: &mut BTreeSet<Type>)
     //
     // Note this is a bit overeager as we can collect a typedef that is used
     // by one architecture but not by another
-    let type_name = reader.type_def_type_name(def);
+    let type_name = def.type_name();
     if !type_name.namespace.is_empty() {
-        for row in reader.get_type_def(type_name) {
+        for row in reader.get_type_def(type_name.namespace, type_name.name) {
             if def != row {
                 type_collect_standalone(reader, &Type::TypeDef(row, Vec::new()), set);
             }
@@ -169,28 +169,28 @@ fn type_collect_standalone(reader: &Reader, ty: &Type, set: &mut BTreeSet<Type>)
     for generic in generics {
         type_collect_standalone(reader, generic, set);
     }
-    for field in reader.type_def_fields(def) {
-        let ty = reader.field_type(field, Some(def));
+    for field in def.fields() {
+        let ty = field.ty(Some(def));
         if let Type::TypeDef(def, _) = &ty {
-            if reader.type_def_namespace(*def).is_empty() {
+            if def.namespace().is_empty() {
                 continue;
             }
         }
         type_collect_standalone(reader, &ty, set);
     }
-    for method in reader.type_def_methods(def) {
+    for method in def.methods() {
         // Skip delegate pseudo-constructors.
-        if reader.method_def_name(method) == ".ctor" {
+        if method.name() == ".ctor" {
             continue;
         }
-        let signature = method_def_signature(reader, reader.type_def_namespace(def), method, generics);
+        let signature = method_def_signature(reader, def.namespace(), method, generics);
         type_collect_standalone(reader, &signature.return_type, set);
         signature.params.iter().for_each(|param| type_collect_standalone(reader, &param.ty, set));
     }
     for interface in type_interfaces(reader, &ty) {
         type_collect_standalone(reader, &interface.ty, set);
     }
-    if reader.type_def_kind(def) == TypeKind::Struct && reader.type_def_fields(def).next().is_none() && type_def_guid(reader, def).is_some() {
+    if def.kind() == TypeKind::Struct && def.fields().next().is_none() && type_def_guid(def).is_some() {
         set.insert(Type::GUID);
     }
 
@@ -201,12 +201,12 @@ fn type_collect_standalone_nested(reader: &Reader, td: TypeDef, set: &mut BTreeS
     for nested in reader.nested_types(td) {
         type_collect_standalone_nested(reader, nested, set);
 
-        for field in reader.type_def_fields(nested) {
-            let ty = reader.field_type(field, Some(nested));
+        for field in nested.fields() {
+            let ty = field.ty(Some(nested));
             if let Type::TypeDef(def, _) = &ty {
                 // Skip the fields that actually refer to the anonymous nested
                 // type, otherwise it will get added to the typeset and emitted
-                if reader.type_def_namespace(*def).is_empty() {
+                if def.namespace().is_empty() {
                     continue;
                 }
 
diff --git a/crates/libs/bindgen/src/rust/structs.rs b/crates/libs/bindgen/src/rust/structs.rs
index 249b293dc4..13047d2197 100644
--- a/crates/libs/bindgen/src/rust/structs.rs
+++ b/crates/libs/bindgen/src/rust/structs.rs
@@ -1,21 +1,21 @@
 use super::*;
 
 pub fn writer(writer: &Writer, def: TypeDef) -> TokenStream {
-    if writer.reader.has_attribute(def, "ApiContractAttribute") {
+    if def.has_attribute("ApiContractAttribute") {
         return quote! {};
     }
 
-    if type_def_is_handle(writer.reader, def) {
+    if type_def_is_handle(def) {
         return handles::writer(writer, def);
     }
 
-    gen_struct_with_name(writer, def, writer.reader.type_def_name(def), &Cfg::default())
+    gen_struct_with_name(writer, def, def.name(), &Cfg::default())
 }
 
 fn gen_struct_with_name(writer: &Writer, def: TypeDef, struct_name: &str, cfg: &Cfg) -> TokenStream {
     let name = to_ident(struct_name);
 
-    if writer.reader.type_def_fields(def).next().is_none() {
+    if def.fields().next().is_none() {
         let mut tokens = quote! {
             #[repr(C)]
             pub struct #name(pub u8);
@@ -36,21 +36,21 @@ fn gen_struct_with_name(writer: &Writer, def: TypeDef, struct_name: &str, cfg: &
         return tokens;
     }
 
-    let flags = writer.reader.type_def_flags(def);
+    let flags = def.flags();
     let cfg = cfg.union(&type_def_cfg(writer.reader, def, &[]));
 
-    let repr = if let Some(layout) = writer.reader.type_def_class_layout(def) {
-        let packing = Literal::usize_unsuffixed(writer.reader.class_layout_packing_size(layout));
+    let repr = if let Some(layout) = def.class_layout() {
+        let packing = Literal::usize_unsuffixed(layout.packing_size());
         quote! { #[repr(C, packed(#packing))] }
     } else {
         quote! { #[repr(C)] }
     };
 
-    let fields = writer.reader.type_def_fields(def).map(|f| {
-        let name = to_ident(writer.reader.field_name(f));
-        let ty = writer.reader.field_type(f, Some(def));
+    let fields = def.fields().map(|f| {
+        let name = to_ident(f.name());
+        let ty = f.ty(Some(def));
 
-        if writer.reader.field_flags(f).contains(FieldAttributes::Literal) {
+        if f.flags().contains(FieldAttributes::Literal) {
             quote! {}
         } else if !writer.sys && flags.contains(TypeAttributes::ExplicitLayout) && !field_is_copyable(writer.reader, f, def) {
             let ty = writer.type_default_name(&ty);
@@ -130,7 +130,7 @@ fn gen_windows_traits(writer: &Writer, def: TypeDef, name: &TokenStream, cfg: &C
             }
         };
 
-        if writer.reader.type_def_flags(def).contains(TypeAttributes::WindowsRuntime) {
+        if def.flags().contains(TypeAttributes::WindowsRuntime) {
             let signature = Literal::byte_string(type_def_signature(writer.reader, def, &[]).as_bytes());
 
             tokens.combine(&quote! {
@@ -151,9 +151,9 @@ fn gen_compare_traits(writer: &Writer, def: TypeDef, name: &TokenStream, cfg: &C
     if writer.sys || type_def_has_explicit_layout(writer.reader, def) || type_def_has_packing(writer.reader, def) || type_def_has_callback(writer.reader, def) {
         quote! {}
     } else {
-        let fields = writer.reader.type_def_fields(def).filter_map(|f| {
-            let name = to_ident(writer.reader.field_name(f));
-            if writer.reader.field_flags(f).contains(FieldAttributes::Literal) {
+        let fields = def.fields().filter_map(|f| {
+            let name = to_ident(f.name());
+            if f.flags().contains(FieldAttributes::Literal) {
                 None
             } else {
                 Some(quote! { self.#name == other.#name })
@@ -180,13 +180,13 @@ fn gen_debug(writer: &Writer, def: TypeDef, ident: &TokenStream, cfg: &Cfg) -> T
         let name = ident.as_str();
         let features = writer.cfg_features(cfg);
 
-        let fields = writer.reader.type_def_fields(def).filter_map(|f| {
-            if writer.reader.field_flags(f).contains(FieldAttributes::Literal) {
+        let fields = def.fields().filter_map(|f| {
+            if f.flags().contains(FieldAttributes::Literal) {
                 None
             } else {
-                let name = writer.reader.field_name(f);
+                let name = f.name();
                 let ident = to_ident(name);
-                let ty = writer.reader.field_type(f, Some(def));
+                let ty = f.ty(Some(def));
                 if type_has_callback(writer.reader, &ty) {
                     None
                 } else {
@@ -220,10 +220,10 @@ fn gen_copy_clone(writer: &Writer, def: TypeDef, name: &TokenStream, cfg: &Cfg)
                 }
             }
         }
-    } else if writer.reader.type_def_class_layout(def).is_some() {
+    } else if def.class_layout().is_some() {
         // Don't support copy/clone of packed structs: https://github.com/rust-lang/rust/issues/82523
         quote! {}
-    } else if !writer.reader.type_def_flags(def).contains(TypeAttributes::WindowsRuntime) {
+    } else if !def.flags().contains(TypeAttributes::WindowsRuntime) {
         quote! {
             #features
             impl ::core::clone::Clone for #name {
@@ -233,9 +233,9 @@ fn gen_copy_clone(writer: &Writer, def: TypeDef, name: &TokenStream, cfg: &Cfg)
             }
         }
     } else {
-        let fields = writer.reader.type_def_fields(def).map(|f| {
-            let name = to_ident(writer.reader.field_name(f));
-            if writer.reader.field_flags(f).contains(FieldAttributes::Literal) {
+        let fields = def.fields().map(|f| {
+            let name = to_ident(f.name());
+            if f.flags().contains(FieldAttributes::Literal) {
                 quote! {}
             } else if field_is_blittable(writer.reader, f, def) {
                 quote! { #name: self.#name }
@@ -258,11 +258,11 @@ fn gen_copy_clone(writer: &Writer, def: TypeDef, name: &TokenStream, cfg: &Cfg)
 fn gen_struct_constants(writer: &Writer, def: TypeDef, struct_name: &TokenStream, cfg: &Cfg) -> TokenStream {
     let features = writer.cfg_features(cfg);
 
-    let constants = writer.reader.type_def_fields(def).filter_map(|f| {
-        if writer.reader.field_flags(f).contains(FieldAttributes::Literal) {
-            if let Some(constant) = writer.reader.field_constant(f) {
-                let name = to_ident(writer.reader.field_name(f));
-                let value = writer.typed_value(&writer.reader.constant_value(constant));
+    let constants = def.fields().filter_map(|f| {
+        if f.flags().contains(FieldAttributes::Literal) {
+            if let Some(constant) = f.constant() {
+                let name = to_ident(f.name());
+                let value = writer.typed_value(&constant.value());
 
                 return Some(quote! {
                     pub const #name: #value;
diff --git a/crates/libs/bindgen/src/rust/winrt_methods.rs b/crates/libs/bindgen/src/rust/winrt_methods.rs
index a2f1ca7234..1aac3038a5 100644
--- a/crates/libs/bindgen/src/rust/winrt_methods.rs
+++ b/crates/libs/bindgen/src/rust/winrt_methods.rs
@@ -2,11 +2,11 @@ use super::*;
 
 // TODO take Signature instead of MethodDef (wherever MethodDef is found)
 pub fn writer(writer: &Writer, def: TypeDef, generic_types: &[Type], kind: InterfaceKind, method: MethodDef, method_names: &mut MethodNames, virtual_names: &mut MethodNames) -> TokenStream {
-    let signature = method_def_signature(writer.reader, writer.reader.type_def_namespace(def), method, generic_types);
+    let signature = method_def_signature(writer.reader, def.namespace(), method, generic_types);
     let params = &signature.params;
-    let name = method_names.add(writer, method);
+    let name = method_names.add(method);
     let interface_name = writer.type_def_name(def, generic_types);
-    let vname = virtual_names.add(writer, method);
+    let vname = virtual_names.add(method);
     let generics = writer.constraint_generics(params);
     let where_clause = writer.where_clause(params);
     let mut cfg = signature_cfg(writer.reader, method);
@@ -106,7 +106,7 @@ fn gen_winrt_params(writer: &Writer, params: &[SignatureParam]) -> TokenStream {
         let kind = writer.type_name(&param.ty);
         let default_type = writer.type_default_name(&param.ty);
 
-        if writer.reader.param_flags(param.def).contains(ParamAttributes::In) {
+        if param.def.flags().contains(ParamAttributes::In) {
             if param.ty.is_winrt_array() {
                 result.combine(&quote! { #name: &[#default_type], });
             } else if signature_param_is_convertible(writer.reader, param) {
@@ -135,14 +135,14 @@ fn gen_winrt_abi_args(writer: &Writer, params: &[SignatureParam]) -> TokenStream
     for param in params {
         let name = writer.param_name(param.def);
 
-        let param = if writer.reader.param_flags(param.def).contains(ParamAttributes::In) {
+        let param = if param.def.flags().contains(ParamAttributes::In) {
             if param.ty.is_winrt_array() {
                 if type_is_blittable(writer.reader, &param.ty) {
                     quote! { #name.len() as u32, #name.as_ptr(), }
                 } else {
                     quote! { #name.len() as u32, ::core::mem::transmute(#name.as_ptr()), }
                 }
-            } else if type_is_non_exclusive_winrt_interface(writer.reader, &param.ty) {
+            } else if type_is_non_exclusive_winrt_interface(&param.ty) {
                 quote! { #name.try_into_param()?.abi(), }
             } else if type_is_borrowed(writer.reader, &param.ty) {
                 quote! { #name.into_param().abi(), }
@@ -218,16 +218,16 @@ pub fn gen_upcall(writer: &Writer, sig: &Signature, inner: TokenStream) -> Token
 
 fn gen_winrt_invoke_arg(writer: &Writer, param: &SignatureParam) -> TokenStream {
     let name = writer.param_name(param.def);
-    let abi_size_name: TokenStream = format!("{}_array_size", writer.reader.param_name(param.def)).into();
+    let abi_size_name: TokenStream = format!("{}_array_size", param.def.name()).into();
 
-    if writer.reader.param_flags(param.def).contains(ParamAttributes::In) {
+    if param.def.flags().contains(ParamAttributes::In) {
         if param.ty.is_winrt_array() {
             quote! { ::core::slice::from_raw_parts(::core::mem::transmute_copy(&#name), #abi_size_name as usize) }
-        } else if type_is_primitive(writer.reader, &param.ty) {
+        } else if type_is_primitive(&param.ty) {
             quote! { #name }
         } else if param.ty.is_const_ref() {
             quote! { ::core::mem::transmute_copy(&#name) }
-        } else if type_is_nullable(writer.reader, &param.ty) {
+        } else if type_is_nullable(&param.ty) {
             quote! { ::windows_core::from_raw_borrowed(&#name) }
         } else {
             quote! { ::core::mem::transmute(&#name) }
diff --git a/crates/libs/bindgen/src/winmd/from_reader.rs b/crates/libs/bindgen/src/winmd/from_reader.rs
index b535caed09..b315da514f 100644
--- a/crates/libs/bindgen/src/winmd/from_reader.rs
+++ b/crates/libs/bindgen/src/winmd/from_reader.rs
@@ -1,6 +1,5 @@
 use super::*;
 use crate::winmd::{self, writer};
-use metadata::RowReader;
 
 pub fn from_reader(reader: &metadata::Reader, filter: &metadata::Filter, config: std::collections::BTreeMap<&str, &str>, output: &str) -> crate::Result<()> {
     let mut writer = winmd::Writer::new(output);
@@ -22,31 +21,31 @@ pub fn from_reader(reader: &metadata::Reader, filter: &metadata::Filter, config:
             continue;
         };
 
-        let generics = &metadata::type_def_generics(reader, def);
+        let generics = &metadata::type_def_generics(def);
 
-        let extends = if let Some(extends) = reader.type_def_extends(def) { writer.insert_type_ref(extends.namespace, extends.name) } else { 0 };
+        let extends = if let Some(extends) = def.extends() { writer.insert_type_ref(extends.namespace, extends.name) } else { 0 };
 
         writer.tables.TypeDef.push(writer::TypeDef {
             Extends: extends,
             FieldList: writer.tables.Field.len() as u32,
-            Flags: reader.type_def_flags(def).0,
+            Flags: def.flags().0,
             MethodList: writer.tables.MethodDef.len() as u32,
-            TypeName: writer.strings.insert(reader.type_def_name(def)),
-            TypeNamespace: writer.strings.insert(reader.type_def_namespace(def)),
+            TypeName: writer.strings.insert(def.name()),
+            TypeNamespace: writer.strings.insert(def.namespace()),
         });
 
-        for generic in reader.type_def_generics(def) {
+        for generic in def.generics() {
             writer.tables.GenericParam.push(writer::GenericParam {
-                Number: reader.generic_param_number(generic),
+                Number: generic.number(),
                 Flags: 0,
                 Owner: writer::TypeOrMethodDef::TypeDef(writer.tables.TypeDef.len() as u32 - 1).encode(),
-                Name: writer.strings.insert(reader.generic_param_name(generic)),
+                Name: writer.strings.insert(generic.name()),
             });
         }
 
-        for imp in reader.type_def_interface_impls(def) {
-            let ty = reader.interface_impl_type(imp, generics);
-            let ty = winmd_type(reader, &ty);
+        for imp in def.interface_impls() {
+            let ty = imp.ty(generics);
+            let ty = winmd_type(&ty);
 
             let reference = match &ty {
                 winmd::Type::TypeRef(type_name) if type_name.generics.is_empty() => writer.insert_type_ref(&type_name.namespace, &type_name.name),
@@ -61,31 +60,31 @@ pub fn from_reader(reader: &metadata::Reader, filter: &metadata::Filter, config:
 
         // TODO: if the class is "Apis" then should we sort the fields (constants) and methods (functions) for stability
 
-        for field in reader.type_def_fields(def) {
-            let ty = winmd_type(reader, &reader.field_type(field, Some(def)));
+        for field in def.fields() {
+            let ty = winmd_type(&field.ty(Some(def)));
             let signature = writer.insert_field_sig(&ty);
 
-            writer.tables.Field.push(writer::Field { Flags: reader.field_flags(field).0, Name: writer.strings.insert(reader.field_name(field)), Signature: signature });
+            writer.tables.Field.push(writer::Field { Flags: field.flags().0, Name: writer.strings.insert(field.name()), Signature: signature });
         }
 
-        for method in reader.type_def_methods(def) {
-            let signature = reader.method_def_signature(method, generics);
-            let return_type = winmd_type(reader, &signature.return_type);
-            let param_types: Vec<Type> = signature.params.iter().map(|param| winmd_type(reader, param)).collect();
+        for method in def.methods() {
+            let signature = method.signature(generics);
+            let return_type = winmd_type(&signature.return_type);
+            let param_types: Vec<Type> = signature.params.iter().map(winmd_type).collect();
 
             let signature = writer.insert_method_sig(signature.call_flags, &return_type, &param_types);
 
             writer.tables.MethodDef.push(winmd::MethodDef {
                 RVA: 0,
-                ImplFlags: reader.method_def_impl_flags(method).0,
-                Flags: reader.method_def_flags(method).0,
-                Name: writer.strings.insert(reader.method_def_name(method)),
+                ImplFlags: method.impl_flags().0,
+                Flags: method.flags().0,
+                Name: writer.strings.insert(method.name()),
                 Signature: signature,
                 ParamList: writer.tables.Param.len() as u32,
             });
 
-            for param in reader.method_def_params(method) {
-                writer.tables.Param.push(writer::Param { Flags: reader.param_flags(param).0, Sequence: reader.param_sequence(param), Name: writer.strings.insert(reader.param_name(param)) });
+            for param in method.params() {
+                writer.tables.Param.push(writer::Param { Flags: param.flags().0, Sequence: param.sequence(), Name: writer.strings.insert(param.name()) });
             }
         }
     }
@@ -96,7 +95,7 @@ pub fn from_reader(reader: &metadata::Reader, filter: &metadata::Filter, config:
 }
 
 // TODO: keep the basic type conversion
-fn winmd_type(reader: &metadata::Reader, ty: &metadata::Type) -> winmd::Type {
+fn winmd_type(ty: &metadata::Type) -> winmd::Type {
     match ty {
         metadata::Type::Void => winmd::Type::Void,
         metadata::Type::Bool => winmd::Type::Bool,
@@ -124,18 +123,14 @@ fn winmd_type(reader: &metadata::Reader, ty: &metadata::Type) -> winmd::Type {
         metadata::Type::PCWSTR => winmd::Type::PCWSTR,
         metadata::Type::BSTR => winmd::Type::BSTR,
         metadata::Type::TypeName => winmd::Type::TypeName,
-        metadata::Type::TypeDef(def, generics) => winmd::Type::TypeRef(winmd::TypeName {
-            namespace: reader.type_def_namespace(*def).to_string(),
-            name: reader.type_def_name(*def).to_string(),
-            generics: generics.iter().map(|ty| winmd_type(reader, ty)).collect(),
-        }),
-        metadata::Type::GenericParam(generic) => winmd::Type::GenericParam(reader.generic_param_number(*generic)),
-        metadata::Type::ConstRef(ty) => winmd::Type::ConstRef(Box::new(winmd_type(reader, ty))),
-        metadata::Type::WinrtArrayRef(ty) => winmd::Type::WinrtArrayRef(Box::new(winmd_type(reader, ty))),
-        metadata::Type::WinrtArray(ty) => winmd::Type::WinrtArray(Box::new(winmd_type(reader, ty))),
-        metadata::Type::MutPtr(ty, pointers) => winmd::Type::MutPtr(Box::new(winmd_type(reader, ty)), *pointers),
-        metadata::Type::ConstPtr(ty, pointers) => winmd::Type::ConstPtr(Box::new(winmd_type(reader, ty)), *pointers),
-        metadata::Type::Win32Array(ty, len) => winmd::Type::Win32Array(Box::new(winmd_type(reader, ty)), *len),
+        metadata::Type::TypeDef(def, generics) => winmd::Type::TypeRef(winmd::TypeName { namespace: def.namespace().to_string(), name: def.name().to_string(), generics: generics.iter().map(winmd_type).collect() }),
+        metadata::Type::GenericParam(generic) => winmd::Type::GenericParam(generic.number()),
+        metadata::Type::ConstRef(ty) => winmd::Type::ConstRef(Box::new(winmd_type(ty))),
+        metadata::Type::WinrtArrayRef(ty) => winmd::Type::WinrtArrayRef(Box::new(winmd_type(ty))),
+        metadata::Type::WinrtArray(ty) => winmd::Type::WinrtArray(Box::new(winmd_type(ty))),
+        metadata::Type::MutPtr(ty, pointers) => winmd::Type::MutPtr(Box::new(winmd_type(ty)), *pointers),
+        metadata::Type::ConstPtr(ty, pointers) => winmd::Type::ConstPtr(Box::new(winmd_type(ty)), *pointers),
+        metadata::Type::Win32Array(ty, len) => winmd::Type::Win32Array(Box::new(winmd_type(ty)), *len),
         rest => unimplemented!("{rest:?}"),
     }
 }
diff --git a/crates/libs/bindgen/src/winmd/verify.rs b/crates/libs/bindgen/src/winmd/verify.rs
index 42b1fc32b8..5a856445f3 100644
--- a/crates/libs/bindgen/src/winmd/verify.rs
+++ b/crates/libs/bindgen/src/winmd/verify.rs
@@ -1,5 +1,4 @@
 use super::*;
-use metadata::RowReader;
 
 pub fn verify(reader: &metadata::Reader, filter: &metadata::Filter) -> crate::Result<()> {
     let unused: Vec<&str> = filter.unused(reader).collect();
@@ -20,24 +19,24 @@ pub fn verify(reader: &metadata::Reader, filter: &metadata::Filter) -> crate::Re
             continue;
         };
 
-        let generics = &metadata::type_def_generics(reader, def);
+        let generics = &metadata::type_def_generics(def);
 
-        reader.type_def_fields(def).try_for_each(|field| not_type_ref(reader, &reader.field_type(field, Some(def))))?;
+        def.fields().try_for_each(|field| not_type_ref(&field.ty(Some(def))))?;
 
-        reader.type_def_methods(def).try_for_each(|method| {
-            let sig = reader.method_def_signature(method, generics);
-            not_type_ref(reader, &sig.return_type)?;
+        def.methods().try_for_each(|method| {
+            let sig = method.signature(generics);
+            not_type_ref(&sig.return_type)?;
 
-            sig.params.iter().try_for_each(|param| not_type_ref(reader, param))
+            sig.params.iter().try_for_each(not_type_ref)
         })?;
     }
 
     Ok(())
 }
 
-fn not_type_ref(reader: &metadata::Reader, ty: &metadata::Type) -> crate::Result<()> {
+fn not_type_ref(ty: &metadata::Type) -> crate::Result<()> {
     if let metadata::Type::TypeRef(ty) = ty {
-        return Err(crate::Error::new(&format!("missing type definition `{}`", reader.type_def_or_ref(*ty))));
+        return Err(crate::Error::new(&format!("missing type definition `{}`", ty.type_name())));
     }
     Ok(())
 }
diff --git a/crates/libs/bindgen/src/winmd/writer/file.rs b/crates/libs/bindgen/src/winmd/writer/file.rs
index b452ba5595..204358d94d 100644
--- a/crates/libs/bindgen/src/winmd/writer/file.rs
+++ b/crates/libs/bindgen/src/winmd/writer/file.rs
@@ -1,5 +1,5 @@
 use super::*;
-use metadata::imp::*;
+use metadata::*;
 use std::mem::*;
 
 pub fn write(mut tables: Vec<u8>, mut strings: Vec<u8>, mut blobs: Vec<u8>) -> Vec<u8> {
diff --git a/crates/libs/bindgen/src/winmd/writer/mod.rs b/crates/libs/bindgen/src/winmd/writer/mod.rs
index af49ecfeb0..bd5f12f5bb 100644
--- a/crates/libs/bindgen/src/winmd/writer/mod.rs
+++ b/crates/libs/bindgen/src/winmd/writer/mod.rs
@@ -9,7 +9,6 @@ mod r#type;
 use super::*;
 use blobs::Blobs;
 pub use codes::*;
-use metadata::imp::*;
 pub use r#type::*;
 use std::collections::HashMap;
 use strings::Strings;
@@ -150,39 +149,39 @@ impl Writer {
 
     fn type_blob(&mut self, ty: &Type, blob: &mut Vec<u8>) {
         match ty {
-            Type::Void => blob.push(ELEMENT_TYPE_VOID),
-            Type::Bool => blob.push(ELEMENT_TYPE_BOOLEAN),
-            Type::Char => blob.push(ELEMENT_TYPE_CHAR),
-            Type::I8 => blob.push(ELEMENT_TYPE_I1),
-            Type::U8 => blob.push(ELEMENT_TYPE_U1),
-            Type::I16 => blob.push(ELEMENT_TYPE_I2),
-            Type::U16 => blob.push(ELEMENT_TYPE_U2),
-            Type::I32 => blob.push(ELEMENT_TYPE_I4),
-            Type::U32 => blob.push(ELEMENT_TYPE_U4),
-            Type::I64 => blob.push(ELEMENT_TYPE_I8),
-            Type::U64 => blob.push(ELEMENT_TYPE_U8),
-            Type::F32 => blob.push(ELEMENT_TYPE_R4),
-            Type::F64 => blob.push(ELEMENT_TYPE_R8),
-            Type::ISize => blob.push(ELEMENT_TYPE_I),
-            Type::USize => blob.push(ELEMENT_TYPE_U),
-            Type::String => blob.push(ELEMENT_TYPE_STRING),
-            Type::IInspectable => blob.push(ELEMENT_TYPE_OBJECT),
+            Type::Void => blob.push(metadata::ELEMENT_TYPE_VOID),
+            Type::Bool => blob.push(metadata::ELEMENT_TYPE_BOOLEAN),
+            Type::Char => blob.push(metadata::ELEMENT_TYPE_CHAR),
+            Type::I8 => blob.push(metadata::ELEMENT_TYPE_I1),
+            Type::U8 => blob.push(metadata::ELEMENT_TYPE_U1),
+            Type::I16 => blob.push(metadata::ELEMENT_TYPE_I2),
+            Type::U16 => blob.push(metadata::ELEMENT_TYPE_U2),
+            Type::I32 => blob.push(metadata::ELEMENT_TYPE_I4),
+            Type::U32 => blob.push(metadata::ELEMENT_TYPE_U4),
+            Type::I64 => blob.push(metadata::ELEMENT_TYPE_I8),
+            Type::U64 => blob.push(metadata::ELEMENT_TYPE_U8),
+            Type::F32 => blob.push(metadata::ELEMENT_TYPE_R4),
+            Type::F64 => blob.push(metadata::ELEMENT_TYPE_R8),
+            Type::ISize => blob.push(metadata::ELEMENT_TYPE_I),
+            Type::USize => blob.push(metadata::ELEMENT_TYPE_U),
+            Type::String => blob.push(metadata::ELEMENT_TYPE_STRING),
+            Type::IInspectable => blob.push(metadata::ELEMENT_TYPE_OBJECT),
             Type::GUID => {
                 let code = self.insert_type_ref("System", "Guid");
-                blob.push(ELEMENT_TYPE_VALUETYPE);
+                blob.push(metadata::ELEMENT_TYPE_VALUETYPE);
                 usize_blob(code as usize, blob);
             }
             Type::HRESULT => {
                 let code = self.insert_type_ref("Windows.Foundation", "HResult");
-                blob.push(ELEMENT_TYPE_VALUETYPE);
+                blob.push(metadata::ELEMENT_TYPE_VALUETYPE);
                 usize_blob(code as usize, blob);
             }
             Type::TypeRef(ty) => {
                 if !ty.generics.is_empty() {
-                    blob.push(ELEMENT_TYPE_GENERICINST);
+                    blob.push(metadata::ELEMENT_TYPE_GENERICINST);
                 }
                 let code = self.insert_type_ref(&ty.namespace, &ty.name);
-                blob.push(ELEMENT_TYPE_VALUETYPE);
+                blob.push(metadata::ELEMENT_TYPE_VALUETYPE);
                 usize_blob(code as usize, blob);
 
                 if !ty.generics.is_empty() {
@@ -195,41 +194,41 @@ impl Writer {
             }
             Type::BSTR => {
                 let code = self.insert_type_ref("Windows.Win32.Foundation", "BSTR");
-                blob.push(ELEMENT_TYPE_VALUETYPE);
+                blob.push(metadata::ELEMENT_TYPE_VALUETYPE);
                 usize_blob(code as usize, blob);
             }
             Type::IUnknown => {
                 let code = self.insert_type_ref("Windows.Win32.Foundation", "IUnknown");
-                blob.push(ELEMENT_TYPE_VALUETYPE);
+                blob.push(metadata::ELEMENT_TYPE_VALUETYPE);
                 usize_blob(code as usize, blob);
             }
             Type::PCWSTR | Type::PWSTR => {
                 let code = self.insert_type_ref("Windows.Win32.Foundation", "PWSTR");
-                blob.push(ELEMENT_TYPE_VALUETYPE);
+                blob.push(metadata::ELEMENT_TYPE_VALUETYPE);
                 usize_blob(code as usize, blob);
             }
             Type::PCSTR | Type::PSTR => {
                 let code = self.insert_type_ref("Windows.Win32.Foundation", "PSTR");
-                blob.push(ELEMENT_TYPE_VALUETYPE);
+                blob.push(metadata::ELEMENT_TYPE_VALUETYPE);
                 usize_blob(code as usize, blob);
             }
             Type::ConstRef(ty) => {
-                usize_blob(ELEMENT_TYPE_CMOD_OPT as usize, blob);
+                usize_blob(metadata::ELEMENT_TYPE_CMOD_OPT as usize, blob);
                 usize_blob(self.insert_type_ref("System.Runtime.CompilerServices", "IsConst") as usize, blob);
-                usize_blob(ELEMENT_TYPE_BYREF as usize, blob);
+                usize_blob(metadata::ELEMENT_TYPE_BYREF as usize, blob);
                 self.type_blob(ty, blob);
             }
             Type::WinrtArrayRef(ty) => {
-                usize_blob(ELEMENT_TYPE_BYREF as usize, blob);
-                usize_blob(ELEMENT_TYPE_SZARRAY as usize, blob);
+                usize_blob(metadata::ELEMENT_TYPE_BYREF as usize, blob);
+                usize_blob(metadata::ELEMENT_TYPE_SZARRAY as usize, blob);
                 self.type_blob(ty, blob);
             }
             Type::WinrtArray(ty) => {
-                usize_blob(ELEMENT_TYPE_SZARRAY as usize, blob);
+                usize_blob(metadata::ELEMENT_TYPE_SZARRAY as usize, blob);
                 self.type_blob(ty, blob);
             }
             Type::Win32Array(ty, bounds) => {
-                usize_blob(ELEMENT_TYPE_ARRAY as usize, blob);
+                usize_blob(metadata::ELEMENT_TYPE_ARRAY as usize, blob);
                 self.type_blob(ty, blob);
                 usize_blob(1, blob); // rank
                 usize_blob(1, blob); // count
@@ -237,17 +236,17 @@ impl Writer {
             }
             Type::TypeName => {
                 let code = self.insert_type_ref("System", "Type");
-                blob.push(ELEMENT_TYPE_CLASS);
+                blob.push(metadata::ELEMENT_TYPE_CLASS);
                 usize_blob(code as usize, blob);
             }
             Type::MutPtr(ty, pointers) | Type::ConstPtr(ty, pointers) => {
                 for _ in 0..*pointers {
-                    usize_blob(ELEMENT_TYPE_PTR as usize, blob);
+                    usize_blob(metadata::ELEMENT_TYPE_PTR as usize, blob);
                 }
                 self.type_blob(ty, blob);
             }
             Type::GenericParam(index) => {
-                blob.push(ELEMENT_TYPE_VAR);
+                blob.push(metadata::ELEMENT_TYPE_VAR);
                 usize_blob(*index as usize, blob);
             }
         }
@@ -276,54 +275,54 @@ fn usize_blob(value: usize, blob: &mut Vec<u8>) {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_usize_blob() {
-        let mut blob = vec![];
-        usize_blob(0, &mut blob);
-        usize_blob(1, &mut blob);
-        usize_blob(2, &mut blob);
-
-        usize_blob(0x80 - 2, &mut blob);
-        usize_blob(0x80 - 1, &mut blob);
-        usize_blob(0x80, &mut blob);
-        usize_blob(0x80 + 1, &mut blob);
-        usize_blob(0x80 + 2, &mut blob);
-
-        usize_blob(0x4000 - 2, &mut blob);
-        usize_blob(0x4000 - 1, &mut blob);
-        usize_blob(0x4000, &mut blob);
-        usize_blob(0x4000 + 1, &mut blob);
-        usize_blob(0x4000 + 2, &mut blob);
-
-        usize_blob(0x20000000 - 3, &mut blob);
-        usize_blob(0x20000000 - 2, &mut blob);
-        usize_blob(0x20000000 - 1, &mut blob);
-
-        let mut blob = metadata::Blob::new(0, &blob);
-        assert_eq!(blob.read_usize(), 0);
-        assert_eq!(blob.read_usize(), 1);
-        assert_eq!(blob.read_usize(), 2);
-
-        assert_eq!(blob.read_usize(), 0x80 - 2);
-        assert_eq!(blob.read_usize(), 0x80 - 1);
-        assert_eq!(blob.read_usize(), 0x80);
-        assert_eq!(blob.read_usize(), 0x80 + 1);
-        assert_eq!(blob.read_usize(), 0x80 + 2);
-
-        assert_eq!(blob.read_usize(), 0x4000 - 2);
-        assert_eq!(blob.read_usize(), 0x4000 - 1);
-        assert_eq!(blob.read_usize(), 0x4000);
-        assert_eq!(blob.read_usize(), 0x4000 + 1);
-        assert_eq!(blob.read_usize(), 0x4000 + 2);
-
-        assert_eq!(blob.read_usize(), 0x20000000 - 3);
-        assert_eq!(blob.read_usize(), 0x20000000 - 2);
-        assert_eq!(blob.read_usize(), 0x20000000 - 1);
-
-        assert_eq!(blob.slice.len(), 0);
-    }
-}
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+
+//     #[test]
+//     fn test_usize_blob() {
+//         let mut blob = vec![];
+//         usize_blob(0, &mut blob);
+//         usize_blob(1, &mut blob);
+//         usize_blob(2, &mut blob);
+
+//         usize_blob(0x80 - 2, &mut blob);
+//         usize_blob(0x80 - 1, &mut blob);
+//         usize_blob(0x80, &mut blob);
+//         usize_blob(0x80 + 1, &mut blob);
+//         usize_blob(0x80 + 2, &mut blob);
+
+//         usize_blob(0x4000 - 2, &mut blob);
+//         usize_blob(0x4000 - 1, &mut blob);
+//         usize_blob(0x4000, &mut blob);
+//         usize_blob(0x4000 + 1, &mut blob);
+//         usize_blob(0x4000 + 2, &mut blob);
+
+//         usize_blob(0x20000000 - 3, &mut blob);
+//         usize_blob(0x20000000 - 2, &mut blob);
+//         usize_blob(0x20000000 - 1, &mut blob);
+
+//         let mut blob = metadata::Blob::new(0, &blob);
+//         assert_eq!(blob.read_usize(), 0);
+//         assert_eq!(blob.read_usize(), 1);
+//         assert_eq!(blob.read_usize(), 2);
+
+//         assert_eq!(blob.read_usize(), 0x80 - 2);
+//         assert_eq!(blob.read_usize(), 0x80 - 1);
+//         assert_eq!(blob.read_usize(), 0x80);
+//         assert_eq!(blob.read_usize(), 0x80 + 1);
+//         assert_eq!(blob.read_usize(), 0x80 + 2);
+
+//         assert_eq!(blob.read_usize(), 0x4000 - 2);
+//         assert_eq!(blob.read_usize(), 0x4000 - 1);
+//         assert_eq!(blob.read_usize(), 0x4000);
+//         assert_eq!(blob.read_usize(), 0x4000 + 1);
+//         assert_eq!(blob.read_usize(), 0x4000 + 2);
+
+//         assert_eq!(blob.read_usize(), 0x20000000 - 3);
+//         assert_eq!(blob.read_usize(), 0x20000000 - 2);
+//         assert_eq!(blob.read_usize(), 0x20000000 - 1);
+
+//         assert_eq!(blob.slice.len(), 0);
+//     }
+// }
diff --git a/crates/libs/bindgen/src/winmd/writer/tables.rs b/crates/libs/bindgen/src/winmd/writer/tables.rs
index 4d4b8e354c..a18aceae86 100644
--- a/crates/libs/bindgen/src/winmd/writer/tables.rs
+++ b/crates/libs/bindgen/src/winmd/writer/tables.rs
@@ -2,7 +2,7 @@
 
 use super::Write;
 use super::*;
-use metadata::imp::coded_index_size;
+use metadata::*;
 
 #[derive(Default)]
 pub struct Tables {