gobject-linter 0.1.2

A fast tree-sitter-based linter for GObject/C code
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use gobject_ast::model::{FileModel, FunctionDeclItem, GObjectType};

use crate::{
    ast_context::AstContext,
    config::Config,
    rules::{Category, Rule, Violation},
};

pub struct MissingExportMacro;

impl Rule for MissingExportMacro {
    fn name(&self) -> &'static str {
        "missing_export_macro"
    }

    fn description(&self) -> &'static str {
        "Detect public API functions and types without export macros"
    }

    fn long_description(&self) -> Option<&'static str> {
        Some(
            "Detects functions and types in public headers that lack export macros.\n\
             Public API should be marked with appropriate export macros (e.g., G_MODULE_EXPORT, \
             CLUTTER_EXPORT, META_EXPORT) to ensure proper symbol visibility.\n\
             Public API should be marked with appropriate export macros (e.g., G_MODULE_EXPORT, \
             CLUTTER_EXPORT, META_EXPORT) to ensure proper symbol visibility.",
        )
    }

    fn category(&self) -> Category {
        Category::Correctness
    }

    fn requires_meson(&self) -> bool {
        true
    }

    fn opt_in(&self) -> bool {
        true
    }

    fn opt_in_reason(&self) -> Option<&'static str> {
        Some(
            "May produce false positives as the parser can misidentify export macros in some codebases",
        )
    }

    fn check_func_decl(
        &self,
        ast_context: &AstContext,
        _config: &Config,
        func: &FunctionDeclItem,
        file: &FileModel,
        violations: &mut Vec<Violation>,
    ) {
        if !ast_context.is_public_header(&file.path).unwrap_or(false) {
            return;
        }

        if func.is_static {
            return;
        }

        if func.export_macros.is_empty() {
            violations.push(self.violation_at(
                &file.path,
                &func.location,
                format!(
                    "Public function '{}' in header is missing an export macro (e.g., G_MODULE_EXPORT, *_EXPORT)",
                    func.name
                ),
            ));
        }
    }

    fn check_gobject_type(
        &self,
        ast_context: &AstContext,
        _config: &Config,
        gobject_type: &GObjectType,
        file: &FileModel,
        violations: &mut Vec<Violation>,
    ) {
        if !ast_context.is_public_header(&file.path).unwrap_or(false) {
            return;
        }

        if !gobject_type.kind.is_declare() {
            return;
        }

        if gobject_type.export_macros.is_empty() {
            violations.push(self.violation_at(
                &file.path,
                &gobject_type.location,
                format!(
                    "'{}' is missing an export macro (e.g., G_MODULE_EXPORT, *_EXPORT)",
                    gobject_type.type_name
                ),
            ));
        }
    }
}