Merge pull request gtk-rs#694 from sdroege/final-types

Implement configuration/detection for final types and use that inform…

Author: EPashkin

README.md

@@ -136,8 +136,10 @@ name = "Gtk.SomeClass"
 status = "generate"
 # replace the parameter name for the child in child properties (instead "child")
 child_name = "item"
-# don't generate trait SomeClassExt for this object, but implement all functions in impl SomeClass
-trait = false
+# mark object as final type, i.e. one without any further subclasses. this
+# will not generate trait SomeClassExt for this object, but implement all
+# functions in impl SomeClass
+final_type = true
 # allow rename result file
 module_name = "soome_class"
 # override starting version

src/analysis/bounds.rs

@@ -9,7 +9,7 @@ use analysis::out_parameters::use_function_return_for_result;
 use analysis::rust_type::{bounds_rust_type, rust_type};
 use consts::TYPE_PARAMETERS_START;
 use env::Env;
-use library::{Function, Fundamental, Nullable, ParameterDirection, Type, TypeId};
+use library::{Class, Function, Fundamental, Nullable, ParameterDirection, Type, TypeId};
 use traits::IntoString;
 
 #[derive(Clone, Eq, Debug, PartialEq)]
@@ -177,8 +177,20 @@ impl Bounds {
             Type::Fundamental(Fundamental::Filename) => Some(AsRef(None)),
             Type::Fundamental(Fundamental::OsString)=> Some(AsRef(None)),
             Type::Fundamental(Fundamental::Utf8) if *nullable => Some(Into(Some('_'), None)),
-            Type::Class(..) if !*nullable => Some(IsA(None)),
-            Type::Class(..) => Some(Into(Some('_'), Some(Box::new(IsA(None))))),
+            Type::Class(Class { final_type, ..}) if !*nullable => {
+                if final_type {
+                    None
+                } else {
+                    Some(IsA(None))
+                }
+            },
+            Type::Class(Class { final_type, ..}) => {
+                if final_type {
+                    Some(Into(Some('_'), None))
+                } else {
+                    Some(Into(Some('_'), Some(Box::new(IsA(None)))))
+                }
+            },
             Type::Interface(..) if !*nullable => Some(IsA(None)),
             Type::Interface(..) => Some(Into(Some('_'), Some(Box::new(IsA(None))))),
             Type::List(_) | Type::SList(_) | Type::CArray(_) => None,

src/analysis/object.rs

@@ -20,6 +20,7 @@ pub struct Info {
     pub get_type: String,
     pub is_interface: bool,
     pub supertypes: Vec<general::StatusedTypeId>,
+    pub final_type: bool,
     pub generate_trait: bool,
     pub trait_name: String,
     pub has_constructors: bool,
@@ -54,22 +55,6 @@ impl Deref for Info {
     }
 }
 
-pub fn has_known_subtypes(env: &Env, class_tid: library::TypeId) -> bool {
-    for child_tid in env.class_hierarchy.subtypes(class_tid) {
-        let child_name = child_tid.full_name(&env.library);
-        let status = env.config
-            .objects
-            .get(&child_name)
-            .map(|o| o.status)
-            .unwrap_or_default();
-        if status.normal() {
-            return true;
-        }
-    }
-
-    false
-}
-
 pub fn class(env: &Env, obj: &GObject, deps: &[library::TypeId]) -> Option<Info> {
     info!("Analyzing class {}", obj.name);
     let full_name = obj.name.clone();
@@ -97,21 +82,12 @@ pub fn class(env: &Env, obj: &GObject, deps: &[library::TypeId]) -> Option<Info>
 
     let supertypes = supertypes::analyze(env, class_tid, &mut imports);
 
-    let mut generate_trait = obj.generate_trait;
+    let final_type = klass.final_type;
     let trait_name = obj.trait_name
         .as_ref()
         .cloned()
         .unwrap_or_else(|| format!("{}Ext", name));
 
-    // Sanity check the user's configuration. It's unlikely that not generating
-    // a trait is wanted if there are subtypes in this very crate
-    if !generate_trait && has_known_subtypes(env, class_tid) {
-        error!(
-            "Not generating trait for {} although subtypes exist",
-            full_name
-        );
-    }
-
     let mut trampolines =
         trampolines::Trampolines::with_capacity(klass.signals.len() + klass.properties.len());
     let mut signatures = Signatures::with_capacity(klass.functions.len());
@@ -120,7 +96,7 @@ pub fn class(env: &Env, obj: &GObject, deps: &[library::TypeId]) -> Option<Info>
         env,
         &klass.functions,
         class_tid,
-        generate_trait,
+        !final_type,
         obj,
         &mut imports,
         Some(&mut signatures),
@@ -145,7 +121,7 @@ pub fn class(env: &Env, obj: &GObject, deps: &[library::TypeId]) -> Option<Info>
         env,
         &klass.signals,
         class_tid,
-        generate_trait,
+        !final_type,
         &mut trampolines,
         obj,
         &mut imports,
@@ -154,7 +130,7 @@ pub fn class(env: &Env, obj: &GObject, deps: &[library::TypeId]) -> Option<Info>
         env,
         &klass.properties,
         class_tid,
-        generate_trait,
+        !final_type,
         &mut trampolines,
         obj,
         &mut imports,
@@ -181,15 +157,11 @@ pub fn class(env: &Env, obj: &GObject, deps: &[library::TypeId]) -> Option<Info>
 
     // There's no point in generating a trait if there are no signals, methods, properties
     // and child properties: it would be empty
-    if generate_trait && !has_signals && !has_methods && properties.is_empty()
-        && child_properties.is_empty()
-    {
-        generate_trait = false;
-    }
+    //
+    // There's also no point in generating a trait for final types: there are no possible subtypes
+    let generate_trait = !final_type && (has_signals || has_methods || !properties.is_empty() || !child_properties.is_empty());
 
-    if generate_trait
-        && (has_methods || !properties.is_empty() || !child_properties.is_empty() || has_signals)
-    {
+    if generate_trait {
         imports.add("glib::object::IsA", None);
     }
 
@@ -233,6 +205,7 @@ pub fn class(env: &Env, obj: &GObject, deps: &[library::TypeId]) -> Option<Info>
         get_type: klass.glib_get_type.clone(),
         is_interface: false,
         supertypes,
+        final_type,
         generate_trait,
         trait_name,
         has_constructors,
@@ -353,6 +326,7 @@ pub fn interface(env: &Env, obj: &GObject, deps: &[library::TypeId]) -> Option<I
         get_type: iface.glib_get_type.clone(),
         is_interface: true,
         supertypes,
+        final_type: false,
         generate_trait: true,
         trait_name,
         has_methods,

src/codegen/object.rs

@@ -133,8 +133,10 @@ pub fn generate(
         try!(writeln!(w, "unsafe impl Sync for {} {{}}", analysis.name));
     }
 
-    try!(writeln!(w));
-    try!(writeln!(w, "pub const NONE_{}: Option<&{}> = None;", analysis.name.to_snake().to_uppercase(), analysis.name));
+    if !analysis.final_type {
+        try!(writeln!(w));
+        try!(writeln!(w, "pub const NONE_{}: Option<&{}> = None;", analysis.name.to_snake().to_uppercase(), analysis.name));
+    }
 
     if need_generate_trait(analysis) {
         try!(writeln!(w));
@@ -279,10 +281,17 @@ pub fn generate_reexports(
     contents.extend_from_slice(&cfgs);
     contents.push(format!("mod {};", module_name));
     contents.extend_from_slice(&cfgs);
+
+    let none_type = if !analysis.final_type {
+        format!(", NONE_{}", analysis.name.to_snake().to_uppercase())
+    } else {
+        String::new()
+    };
+
     if let Some(ref class_name) = analysis.rust_class_type {
-        contents.push(format!("pub use self::{}::{{{}, {}, {}}};", module_name, analysis.name, class_name, format!("NONE_{}", analysis.name.to_snake().to_uppercase())));
+        contents.push(format!("pub use self::{}::{{{}, {}{}}};", module_name, analysis.name, class_name, none_type));
     } else {
-        contents.push(format!("pub use self::{}::{{{}, {}}};", module_name, analysis.name, format!("NONE_{}", analysis.name.to_snake().to_uppercase())));
+        contents.push(format!("pub use self::{}::{{{}{}}};", module_name, analysis.name, none_type));
     }
     if need_generate_trait(analysis) {
         contents.extend_from_slice(&cfgs);

src/config/gobjects.rs

@@ -70,7 +70,7 @@ pub struct GObject {
     pub version: Option<Version>,
     pub cfg_condition: Option<String>,
     pub type_id: Option<TypeId>,
-    pub generate_trait: bool,
+    pub final_type: Option<bool>,
     pub trait_name: Option<String>,
     pub child_properties: Option<ChildProperties>,
     pub concurrency: library::Concurrency,
@@ -97,7 +97,7 @@ impl Default for GObject {
             version: None,
             cfg_condition: None,
             type_id: None,
-            generate_trait: true,
+            final_type: None,
             trait_name: None,
             child_properties: None,
             concurrency: Default::default(),
@@ -183,6 +183,7 @@ fn parse_object(
             "child_prop",
             "child_name",
             "child_type",
+            "final_type",
             "trait",
             "trait_name",
             "cfg_condition",
@@ -236,8 +237,11 @@ fn parse_object(
         .map(|s| s.to_owned());
     let generate_trait = toml_object
         .lookup("trait")
+        .and_then(|v| v.as_bool());
+    let final_type = toml_object
+        .lookup("final_type")
         .and_then(|v| v.as_bool())
-        .unwrap_or(true);
+        .or_else(|| generate_trait.map(|t| !t));
     let trait_name = toml_object
         .lookup("trait_name")
         .and_then(|v| v.as_str())
@@ -281,6 +285,10 @@ fn parse_object(
         warn!("conversion_type configuration used for non-manual object {}", name);
     }
 
+    if generate_trait.is_some() {
+        warn!("`trait` configuration is deprecated and replaced by `final_type` for object {}", name);
+    }
+
     GObject {
         name,
         functions,
@@ -294,7 +302,7 @@ fn parse_object(
         version,
         cfg_condition,
         type_id: None,
-        generate_trait,
+        final_type,
         trait_name,
         child_properties,
         concurrency,

src/library.rs

@@ -466,6 +466,7 @@ pub struct Class {
     pub properties: Vec<Property>,
     pub parent: Option<TypeId>,
     pub implements: Vec<TypeId>,
+    pub final_type: bool,
     pub version: Option<Version>,
     pub deprecated_version: Option<Version>,
     pub doc: Option<String>,

src/library_postprocessing.rs

@@ -5,6 +5,8 @@ use library::*;
 use nameutil;
 use parser::is_empty_c_type;
 use traits::MaybeRefAs;
+use config::Config;
+use config::gobjects::GObject;
 
 impl Namespace {
     fn unresolved(&self) -> Vec<&str> {
@@ -22,14 +24,15 @@ impl Namespace {
 type DetectedCTypes = HashMap<TypeId, String>;
 
 impl Library {
-    pub fn postprocessing(&mut self) {
+    pub fn postprocessing(&mut self, config: &Config) {
         self.fix_gtype();
         self.check_resolved();
         self.fill_empty_signals_c_types();
         self.resolve_class_structs();
         self.correlate_class_structs();
         self.fix_fields();
         self.make_unrepresentable_types_opaque();
+        self.mark_final_types(config);
     }
 
     fn fix_gtype(&mut self) {
@@ -373,4 +376,47 @@ impl Library {
             }
         }
     }
+
+    fn mark_final_types(&mut self, config: &Config) {
+        // Here we mark all class types as final types if configured so in the config or
+        // otherwise if there is no public class struct for the type.
+        //
+        // Final types can't have any subclasses and we handle them slightly different
+        // for that reason.
+        let mut final_types: Vec<TypeId> = Vec::new();
+
+        for (ns_id, ns) in self.namespaces.iter().enumerate() {
+            for (id, type_) in ns.types.iter().enumerate() {
+                let type_ = type_.as_ref().unwrap(); //Always contains something
+
+                if let Type::Class(ref klass) = *type_ {
+                    let tid = TypeId {
+                        ns_id: ns_id as u16,
+                        id: id as u32,
+                    };
+
+                    let full_name = tid.full_name(self);
+                    let obj = config.objects.get(&*full_name);
+
+                    if let Some(GObject { final_type: Some(final_type), ..}) = obj {
+                        // The config might also be used to override a type that is wrongly
+                        // detected as final type otherwise
+                        if *final_type {
+                            final_types.push(tid);
+                        }
+                    } else if klass.c_class_type.is_none() {
+                        final_types.push(tid);
+                    }
+                }
+            }
+        }
+
+        for tid in final_types {
+            if let Type::Class(Class { ref mut final_type, ..}) = *self.type_mut(tid) {
+                *final_type = true;
+            } else {
+                unreachable!();
+            }
+        }
+    }
 }

src/main.rs

@@ -94,7 +94,7 @@ fn do_main() -> Result<(), String> {
 
     {
         let _watcher = statistics.enter("Postprocessing");
-        library.postprocessing();
+        library.postprocessing(&cfg);
     }
 
     {

src/parser.rs

@@ -198,6 +198,7 @@ impl Library {
             properties,
             parent,
             implements: impls,
+            final_type: false, // this will be set during postprocessing
             doc,
             version,
             deprecated_version,