cxx-qt-gen: remove unused members list

ahayzen-kdab · ahayzen-kdab · commit cffa2110a1a6 · 2022-09-02T18:40:17.000+09:00
diff --git a/cxx-qt-gen/src/gen_cpp.rs b/cxx-qt-gen/src/gen_cpp.rs
@@ -168,8 +168,6 @@ struct CppSignal {
 }
 /// Describes a C++ property with header and source parts
 struct CppProperty {
-    /// Any members that are required for the property
-    header_members: Vec<String>,
     /// The header meta definition of the invokable
     header_meta: Vec<String>,
     /// The header public definition of the invokable
@@ -354,8 +352,6 @@ fn generate_properties_cpp(
 
         // Build a basic C++ property with parts that are defined if the property is a pointer or not
         let mut cpp_property = CppProperty {
-            // Members are defined later for only the pointer
-            header_members: vec![],
             // Set the Q_PROPERTY for the C++ class
             header_meta: vec![format!("Q_PROPERTY({type_ident} {ident} READ {ident_getter} WRITE {ident_setter} NOTIFY {ident_changed})",
                 ident = parameter.ident,
@@ -540,14 +536,12 @@ pub fn generate_qobject_cpp(obj: &QObject) -> Result<CppObject, TokenStream> {
 
     // TODO: For now we proxy the gen_cpp code into what the writer phase expects
     // later this code will be moved into a generator phase
-    let mut members: Vec<String> = vec![];
     let mut metaobjects: Vec<String> = vec![];
     let mut methods: Vec<CppFragmentPair> = vec![];
     let mut signals: Vec<String> = vec![];
     let mut slots: Vec<CppFragmentPair> = vec![];
 
     for mut property in generate_properties_cpp(&obj.ident, &obj.properties)?.drain(..) {
-        members.append(&mut property.header_members);
         metaobjects.append(&mut property.header_meta);
         methods.append(
             &mut property
@@ -627,7 +621,6 @@ pub fn generate_qobject_cpp(obj: &QObject) -> Result<CppObject, TokenStream> {
         methods,
         slots,
         signals,
-        members,
     };
 
     // Use our writer phase to convert to a string
diff --git a/cxx-qt-gen/src/generator/cpp/mod.rs b/cxx-qt-gen/src/generator/cpp/mod.rs
@@ -31,6 +31,4 @@ pub struct GeneratedCppBlocks {
     pub slots: Vec<CppFragmentPair>,
     /// List of public Q_SIGNALS for the QObject
     pub signals: Vec<String>,
-    /// List of private members for the QObject
-    pub members: Vec<String>,
 }
diff --git a/cxx-qt-gen/src/writer/cpp/header.rs b/cxx-qt-gen/src/writer/cpp/header.rs
@@ -73,8 +73,6 @@ pub fn write_cpp_header(generated: &GeneratedCppBlocks) -> String {
           rust::Box<{rust_ident}> m_rustObj;
           std::shared_ptr<std::mutex> m_rustObjMutex;
           std::shared_ptr<rust::cxxqtlib1::CxxQtGuardedPointer<{ident}>> m_cxxQtThreadObj;
-
-          {members}
         }};
 
         static_assert(std::is_base_of<QObject, {ident}>::value, "{ident} must inherit from QObject");
@@ -107,7 +105,6 @@ pub fn write_cpp_header(generated: &GeneratedCppBlocks) -> String {
     methods = create_block("public", &generated.methods.iter().map(pair_as_header).collect::<Vec<&str>>()),
     slots = create_block("public Q_SLOTS", &generated.slots.iter().map(pair_as_header).collect::<Vec<&str>>()),
     signals = create_block("Q_SIGNALS", &generated.signals.iter().map(AsRef::as_ref).collect::<Vec<&str>>()),
-    members = generated.members.join("\n  "),
     metatype = if generated.namespace.is_empty() {
         generated.ident.clone()
     } else {
diff --git a/cxx-qt-gen/src/writer/cpp/mod.rs b/cxx-qt-gen/src/writer/cpp/mod.rs
@@ -51,7 +51,7 @@ mod tests {
                         int
                         MyObject::count() const
                         {
-                          return m_count;
+                          // getter
                         }
                     "#}
                     .to_owned(),
@@ -62,7 +62,7 @@ mod tests {
                         bool
                         MyObject::toggle() const
                         {
-                          return m_count;
+                          // getter
                         }
                     "#}
                     .to_owned(),
@@ -97,11 +97,7 @@ mod tests {
                         void
                         MyObject::setCount(int count) const
                         {
-                          if (m_count != count) {
-                            m_count = count;
-
-                            Q_EMIT countChanged();
-                          }
+                          // setter
                         }
                     "#}
                     .to_owned(),
@@ -112,11 +108,7 @@ mod tests {
                         void
                         MyObject::setToggle(bool toggle) const
                         {
-                          if (m_toggle != toggle) {
-                            m_toggle = toggle;
-
-                            Q_EMIT toggleChanged();
-                          }
+                          // setter
                         }
                     "#}
                     .to_owned(),
@@ -126,7 +118,6 @@ mod tests {
                 "void countChanged();".to_owned(),
                 "void toggleChanged();".to_owned(),
             ],
-            members: vec!["int m_count;".to_owned(), "bool m_toggle;".to_owned()],
         }
     }
 
@@ -190,9 +181,6 @@ mod tests {
           rust::Box<MyObjectRust> m_rustObj;
           std::shared_ptr<std::mutex> m_rustObjMutex;
           std::shared_ptr<rust::cxxqtlib1::CxxQtGuardedPointer<MyObject>> m_cxxQtThreadObj;
-
-          int m_count;
-          bool m_toggle;
         };
 
         static_assert(std::is_base_of<QObject, MyObject>::value, "MyObject must inherit from QObject");
@@ -259,9 +247,6 @@ mod tests {
           rust::Box<MyObjectRust> m_rustObj;
           std::shared_ptr<std::mutex> m_rustObjMutex;
           std::shared_ptr<rust::cxxqtlib1::CxxQtGuardedPointer<MyObject>> m_cxxQtThreadObj;
-
-          int m_count;
-          bool m_toggle;
         };
 
         static_assert(std::is_base_of<QObject, MyObject>::value, "MyObject must inherit from QObject");
@@ -318,13 +303,13 @@ mod tests {
         int
         MyObject::count() const
         {
-          return m_count;
+          // getter
         }
 
         bool
         MyObject::toggle() const
         {
-          return m_count;
+          // getter
         }
 
         void
@@ -342,21 +327,13 @@ mod tests {
         void
         MyObject::setCount(int count) const
         {
-          if (m_count != count) {
-            m_count = count;
-
-            Q_EMIT countChanged();
-          }
+          // setter
         }
 
         void
         MyObject::setToggle(bool toggle) const
         {
-          if (m_toggle != toggle) {
-            m_toggle = toggle;
-
-            Q_EMIT toggleChanged();
-          }
+          // setter
         }
 
         } // namespace cxx_qt::my_object
@@ -413,13 +390,13 @@ mod tests {
         int
         MyObject::count() const
         {
-          return m_count;
+          // getter
         }
 
         bool
         MyObject::toggle() const
         {
-          return m_count;
+          // getter
         }
 
         void
@@ -437,21 +414,13 @@ mod tests {
         void
         MyObject::setCount(int count) const
         {
-          if (m_count != count) {
-            m_count = count;
-
-            Q_EMIT countChanged();
-          }
+          // setter
         }
 
         void
         MyObject::setToggle(bool toggle) const
         {
-          if (m_toggle != toggle) {
-            m_toggle = toggle;
-
-            Q_EMIT toggleChanged();
-          }
+          // setter
         }
 
 

Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,4 @@ pub struct GeneratedCppBlocks {`
`31`	`31`	`pub slots: Vec<CppFragmentPair>,`
`32`	`32`	`/// List of public Q_SIGNALS for the QObject`
`33`	`33`	`pub signals: Vec<String>,`
`34`		`- /// List of private members for the QObject`
`35`		`- pub members: Vec<String>,`
`36`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ mod tests {`
`51`	`51`	`int`
`52`	`52`	`MyObject::count() const`
`53`	`53`	`{`
`54`		`- return m_count;`
	`54`	`+ // getter`
`55`	`55`	`}`
`56`	`56`	`"#}`
`57`	`57`	`.to_owned(),`
`@@ -62,7 +62,7 @@ mod tests {`
`62`	`62`	`bool`
`63`	`63`	`MyObject::toggle() const`
`64`	`64`	`{`
`65`		`- return m_count;`
	`65`	`+ // getter`
`66`	`66`	`}`
`67`	`67`	`"#}`
`68`	`68`	`.to_owned(),`
`@@ -97,11 +97,7 @@ mod tests {`
`97`	`97`	`void`
`98`	`98`	`MyObject::setCount(int count) const`
`99`	`99`	`{`
`100`		`- if (m_count != count) {`
`101`		`- m_count = count;`
`102`		`-`
`103`		`- Q_EMIT countChanged();`
`104`		`- }`
	`100`	`+ // setter`
`105`	`101`	`}`
`106`	`102`	`"#}`
`107`	`103`	`.to_owned(),`
`@@ -112,11 +108,7 @@ mod tests {`
`112`	`108`	`void`
`113`	`109`	`MyObject::setToggle(bool toggle) const`
`114`	`110`	`{`
`115`		`- if (m_toggle != toggle) {`
`116`		`- m_toggle = toggle;`
`117`		`-`
`118`		`- Q_EMIT toggleChanged();`
`119`		`- }`
	`111`	`+ // setter`
`120`	`112`	`}`
`121`	`113`	`"#}`
`122`	`114`	`.to_owned(),`
`@@ -126,7 +118,6 @@ mod tests {`
`126`	`118`	`"void countChanged();".to_owned(),`
`127`	`119`	`"void toggleChanged();".to_owned(),`
`128`	`120`	`],`
`129`		`- members: vec!["int m_count;".to_owned(), "bool m_toggle;".to_owned()],`
`130`	`121`	`}`
`131`	`122`	`}`
`132`	`123`
`@@ -190,9 +181,6 @@ mod tests {`
`190`	`181`	`rust::Box<MyObjectRust> m_rustObj;`
`191`	`182`	`std::shared_ptr<std::mutex> m_rustObjMutex;`
`192`	`183`	`std::shared_ptr<rust::cxxqtlib1::CxxQtGuardedPointer<MyObject>> m_cxxQtThreadObj;`
`193`		`-`
`194`		`- int m_count;`
`195`		`- bool m_toggle;`
`196`	`184`	`};`
`197`	`185`
`198`	`186`	`static_assert(std::is_base_of<QObject, MyObject>::value, "MyObject must inherit from QObject");`
`@@ -259,9 +247,6 @@ mod tests {`
`259`	`247`	`rust::Box<MyObjectRust> m_rustObj;`
`260`	`248`	`std::shared_ptr<std::mutex> m_rustObjMutex;`
`261`	`249`	`std::shared_ptr<rust::cxxqtlib1::CxxQtGuardedPointer<MyObject>> m_cxxQtThreadObj;`
`262`		`-`
`263`		`- int m_count;`
`264`		`- bool m_toggle;`
`265`	`250`	`};`
`266`	`251`
`267`	`252`	`static_assert(std::is_base_of<QObject, MyObject>::value, "MyObject must inherit from QObject");`
`@@ -318,13 +303,13 @@ mod tests {`
`318`	`303`	`int`
`319`	`304`	`MyObject::count() const`
`320`	`305`	`{`
`321`		`- return m_count;`
	`306`	`+ // getter`
`322`	`307`	`}`
`323`	`308`
`324`	`309`	`bool`
`325`	`310`	`MyObject::toggle() const`
`326`	`311`	`{`
`327`		`- return m_count;`
	`312`	`+ // getter`
`328`	`313`	`}`
`329`	`314`
`330`	`315`	`void`
`@@ -342,21 +327,13 @@ mod tests {`
`342`	`327`	`void`
`343`	`328`	`MyObject::setCount(int count) const`
`344`	`329`	`{`
`345`		`- if (m_count != count) {`
`346`		`- m_count = count;`
`347`		`-`
`348`		`- Q_EMIT countChanged();`
`349`		`- }`
	`330`	`+ // setter`
`350`	`331`	`}`
`351`	`332`
`352`	`333`	`void`
`353`	`334`	`MyObject::setToggle(bool toggle) const`
`354`	`335`	`{`
`355`		`- if (m_toggle != toggle) {`
`356`		`- m_toggle = toggle;`
`357`		`-`
`358`		`- Q_EMIT toggleChanged();`
`359`		`- }`
	`336`	`+ // setter`
`360`	`337`	`}`
`361`	`338`
`362`	`339`	`} // namespace cxx_qt::my_object`
`@@ -413,13 +390,13 @@ mod tests {`
`413`	`390`	`int`
`414`	`391`	`MyObject::count() const`
`415`	`392`	`{`
`416`		`- return m_count;`
	`393`	`+ // getter`
`417`	`394`	`}`
`418`	`395`
`419`	`396`	`bool`
`420`	`397`	`MyObject::toggle() const`
`421`	`398`	`{`
`422`		`- return m_count;`
	`399`	`+ // getter`
`423`	`400`	`}`
`424`	`401`
`425`	`402`	`void`
`@@ -437,21 +414,13 @@ mod tests {`
`437`	`414`	`void`
`438`	`415`	`MyObject::setCount(int count) const`
`439`	`416`	`{`
`440`		`- if (m_count != count) {`
`441`		`- m_count = count;`
`442`		`-`
`443`		`- Q_EMIT countChanged();`
`444`		`- }`
	`417`	`+ // setter`
`445`	`418`	`}`
`446`	`419`
`447`	`420`	`void`
`448`	`421`	`MyObject::setToggle(bool toggle) const`
`449`	`422`	`{`
`450`		`- if (m_toggle != toggle) {`
`451`		`- m_toggle = toggle;`
`452`		`-`
`453`		`- Q_EMIT toggleChanged();`
`454`		`- }`
	`423`	`+ // setter`
`455`	`424`	`}`
`456`	`425`
`457`	`426`