Partial code gen refactor (#841)

Author: kennykerr

crates/gen/src/async.rs

@@ -1,7 +1,7 @@
-use super::*;
+use crate::*;
 
 pub fn gen_async(
-    def: &GenericType,
+    def: &tables::TypeDef,
     interfaces: &[InterfaceInfo],
     gen: &Gen,
 ) -> (TokenStream, TokenStream) {
@@ -31,12 +31,12 @@ pub enum AsyncKind {
     OperationWithProgress,
 }
 
-pub fn async_kind(def: &GenericType) -> AsyncKind {
-    if def.def.namespace() != "Windows.Foundation" {
+pub fn async_kind(def: &tables::TypeDef) -> AsyncKind {
+    if def.namespace() != "Windows.Foundation" {
         return AsyncKind::None;
     }
 
-    match def.def.name() {
+    match def.name() {
         "IAsyncAction" => AsyncKind::Action,
         "IAsyncActionWithProgress`1" => AsyncKind::ActionWithProgress,
         "IAsyncOperation`1" => AsyncKind::Operation,
@@ -47,8 +47,8 @@ pub fn async_kind(def: &GenericType) -> AsyncKind {
 
 fn gen_async_kind(
     kind: AsyncKind,
-    name: &GenericType,
-    self_name: &GenericType,
+    name: &tables::TypeDef,
+    self_name: &tables::TypeDef,
     gen: &Gen,
 ) -> (TokenStream, TokenStream) {
     let return_type = match kind {

crates/gen/src/iterator.rs

@@ -5,8 +5,8 @@ use super::*;
 // only falls back to IIterator<T> if nothing faster is available. VectorIterator and
 // VectorViewIterator are faster iterators than IIterator<T> because they only require a single
 // vcall per iteration wheras IIterator<T> requires two.
-pub fn gen_iterator(def: &GenericType, interfaces: &[InterfaceInfo], gen: &Gen) -> TokenStream {
-    let name = def.def.full_name();
+pub fn gen_iterator(def: &tables::TypeDef, interfaces: &[InterfaceInfo], gen: &Gen) -> TokenStream {
+    let name = def.full_name();
 
     // If the type is IIterator<T> then simply implement the Iterator trait over top.
     if name == ("Windows.Foundation.Collections", "IIterator`1") {
@@ -154,7 +154,7 @@ pub fn gen_iterator(def: &GenericType, interfaces: &[InterfaceInfo], gen: &Gen)
     // If the class or interface is not one of the well-known collection interfaces, we then see whether it
     // implements any one of them. Here is where we favor IVectorView/IVector over IIterable.
     for interface in interfaces {
-        let name = interface.def.def.full_name();
+        let name = interface.def.full_name();
 
         if name == ("Windows.Foundation.Collections", "IVectorView`1") {
             let constraints = def.gen_constraints(gen);

crates/gen/src/parser/codes.rs

@@ -4,7 +4,7 @@ pub trait Decode {
     fn decode(file: &'static File, code: u32) -> Self;
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum TypeDefOrRef {
     TypeDef(tables::TypeDef),
     TypeRef(tables::TypeRef),
@@ -15,7 +15,7 @@ impl Decode for TypeDefOrRef {
     fn decode(file: &'static File, code: u32) -> Self {
         let code = (code & ((1 << 2) - 1), (code >> 2) - 1);
         match code.0 {
-            0 => Self::TypeDef(tables::TypeDef(Row::new(code.1, TableIndex::TypeDef, file))),
+            0 => Self::TypeDef(Row::new(code.1, TableIndex::TypeDef, file).into()),
             1 => Self::TypeRef(tables::TypeRef(Row::new(code.1, TableIndex::TypeRef, file))),
             2 => Self::TypeSpec(tables::TypeSpec(Row::new(
                 code.1,
@@ -30,14 +30,14 @@ impl Decode for TypeDefOrRef {
 impl TypeDefOrRef {
     pub fn encode(&self) -> u32 {
         match self {
-            Self::TypeDef(value) => ((value.0.row + 1) << 2),
+            Self::TypeDef(value) => ((value.row.row + 1) << 2),
             Self::TypeRef(value) => ((value.0.row + 1) << 2) | 1,
             Self::TypeSpec(value) => ((value.0.row + 1) << 2) | 2,
         }
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum TypeOrMethodDef {
     TypeDef(tables::TypeDef),
     MethodDef(tables::MethodDef),
@@ -47,7 +47,7 @@ impl Decode for TypeOrMethodDef {
     fn decode(file: &'static File, code: u32) -> Self {
         let code = (code & ((1 << 1) - 1), (code >> 1) - 1);
         match code.0 {
-            0 => Self::TypeDef(tables::TypeDef(Row::new(code.1, TableIndex::TypeDef, file))),
+            0 => Self::TypeDef(Row::new(code.1, TableIndex::TypeDef, file).into()),
             1 => Self::MethodDef(tables::MethodDef(Row::new(
                 code.1,
                 TableIndex::MethodDef,
@@ -61,13 +61,13 @@ impl Decode for TypeOrMethodDef {
 impl TypeOrMethodDef {
     pub fn encode(&self) -> u32 {
         match self {
-            Self::TypeDef(value) => ((value.0.row + 1) << 1),
+            Self::TypeDef(value) => ((value.row.row + 1) << 1),
             Self::MethodDef(value) => ((value.0.row + 1) << 1) | 1,
         }
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum HasAttribute {
     MethodDef(tables::MethodDef),
     Field(tables::Field),
@@ -91,7 +91,7 @@ impl Decode for HasAttribute {
             ))),
             1 => Self::Field(tables::Field(Row::new(code.1, TableIndex::Field, file))),
             2 => Self::TypeRef(tables::TypeRef(Row::new(code.1, TableIndex::TypeRef, file))),
-            3 => Self::TypeDef(tables::TypeDef(Row::new(code.1, TableIndex::TypeDef, file))),
+            3 => Self::TypeDef(Row::new(code.1, TableIndex::TypeDef, file).into()),
             4 => Self::Param(tables::Param(Row::new(code.1, TableIndex::Param, file))),
             5 => Self::InterfaceImpl(tables::InterfaceImpl(Row::new(
                 code.1,
@@ -124,7 +124,7 @@ impl HasAttribute {
             Self::MethodDef(value) => ((value.0.row + 1) << 5),
             Self::Field(value) => ((value.0.row + 1) << 5) | 1,
             Self::TypeRef(value) => ((value.0.row + 1) << 5) | 2,
-            Self::TypeDef(value) => ((value.0.row + 1) << 5) | 3,
+            Self::TypeDef(value) => ((value.row.row + 1) << 5) | 3,
             Self::Param(value) => ((value.0.row + 1) << 5) | 4,
             Self::InterfaceImpl(value) => ((value.0.row + 1) << 5) | 5,
             Self::MemberRef(value) => ((value.0.row + 1) << 5) | 6,
@@ -134,7 +134,7 @@ impl HasAttribute {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum MemberRefParent {
     TypeDef(tables::TypeDef),
     TypeRef(tables::TypeRef),
@@ -146,7 +146,7 @@ impl Decode for MemberRefParent {
     fn decode(file: &'static File, code: u32) -> Self {
         let code = (code & ((1 << 3) - 1), (code >> 3) - 1);
         match code.0 {
-            0 => Self::TypeDef(tables::TypeDef(Row::new(code.1, TableIndex::TypeDef, file))),
+            0 => Self::TypeDef(Row::new(code.1, TableIndex::TypeDef, file).into()),
             1 => Self::TypeRef(tables::TypeRef(Row::new(code.1, TableIndex::TypeRef, file))),
             3 => Self::MethodDef(tables::MethodDef(Row::new(
                 code.1,
@@ -166,15 +166,15 @@ impl Decode for MemberRefParent {
 impl MemberRefParent {
     pub fn encode(&self) -> u32 {
         match self {
-            Self::TypeDef(value) => ((value.0.row + 1) << 3),
+            Self::TypeDef(value) => ((value.row.row + 1) << 3),
             Self::TypeRef(value) => ((value.0.row + 1) << 3) | 1,
             Self::MethodDef(value) => ((value.0.row + 1) << 3) | 3,
             Self::TypeSpec(value) => ((value.0.row + 1) << 3) | 4,
         }
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum HasConstant {
     Field(tables::Field),
     Param(tables::Param),
@@ -200,7 +200,7 @@ impl HasConstant {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum AttributeType {
     MethodDef(tables::MethodDef),
     MemberRef(tables::MemberRef),
@@ -234,7 +234,7 @@ impl AttributeType {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum MemberForwarded {
     Field(tables::Field),
     MethodDef(tables::MethodDef),
@@ -264,7 +264,7 @@ impl MemberForwarded {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum ResolutionScope {
     Module(tables::Module),
     ModuleRef(tables::ModuleRef),
@@ -331,7 +331,7 @@ impl TypeDefOrRef {
 
     pub fn resolve(&self) -> tables::TypeDef {
         match self {
-            Self::TypeDef(value) => *value,
+            Self::TypeDef(value) => value.clone(),
             Self::TypeRef(value) => value.resolve(),
             _ => unexpected!(),
         }