jbuild 0.1.8

High-performance Java build tool supporting Maven and Gradle
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

//! FullIdent utility for extracting fully qualified names from AST

use crate::checkstyle::api::ast::DetailAst;
use std::sync::Arc;

/// Represents a fully qualified identifier (e.g., "java.util.List")
pub struct FullIdent {
    /// The full text of the identifier
    pub text: String,
    /// The detail AST node
    pub detail_ast: Option<Arc<dyn DetailAst>>,
}

impl FullIdent {
    /// Create a FullIdent from an AST node
    ///
    /// This traverses the AST starting from the given node, collecting
    /// IDENT and DOT tokens to build the full identifier string.
    pub fn create_full_ident(ast: &Arc<dyn DetailAst>) -> Self {
        let mut text_parts = Vec::new();
        let mut current: Option<Arc<dyn DetailAst>> = Some(ast.clone());
        let mut first_ast: Option<Arc<dyn DetailAst>> = None;

        while let Some(node) = current {
            let node_type = node.get_type();

            if node_type == crate::checkstyle::api::ast::token_types::IDENT {
                if first_ast.is_none() {
                    first_ast = Some(node.clone());
                }
                text_parts.push(node.get_text().to_string());
                // Move to next sibling
                current = node.get_next_sibling_arc();
            } else if node_type == crate::checkstyle::api::ast::token_types::DOT {
                text_parts.push(".".to_string());
                // Move to next sibling
                current = node.get_next_sibling_arc();
            } else {
                // For other node types, try to find IDENT in children
                if let Some(child) = node.get_first_child_arc() {
                    current = Some(child);
                } else {
                    break;
                }
            }
        }

        let text = text_parts.join("");

        Self {
            text,
            detail_ast: first_ast,
        }
    }

    /// Get the text of the full identifier
    pub fn get_text(&self) -> &str {
        &self.text
    }

    /// Get the detail AST node (the first IDENT)
    pub fn get_detail_ast(&self) -> Option<&Arc<dyn DetailAst>> {
        self.detail_ast.as_ref()
    }

    /// Create a FullIdent starting from the first child of the specified node
    /// This is equivalent to FullIdent.createFullIdentBelow in Java Checkstyle
    pub fn create_full_ident_below(ast: &Arc<dyn DetailAst>) -> Self {
        if let Some(first_child) = ast.get_first_child_arc() {
            Self::create_full_ident(&first_child)
        } else {
            Self {
                text: String::new(),
                detail_ast: None,
            }
        }
    }
}