syster-base 0.1.10-alpha

Core library for SysML v2 and KerML parsing, AST, and semantic analysis
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Selection range extraction for SysML files
//!
//! Finds hierarchical selection ranges at a given position in the AST.

use crate::core::{Position, Span};
use crate::syntax::sysml::ast::{
    Definition, DefinitionMember, Element, Package, SysMLFile, Usage, UsageMember,
};

/// Find selection spans at a position in a SysML file
///
/// Returns spans ordered from innermost (smallest) to outermost (largest).
/// Returns empty vector if the position is not within any AST node.
pub fn find_selection_spans(file: &SysMLFile, position: Position) -> Vec<Span> {
    let mut spans: Vec<Span> = Vec::new();

    // Check each top-level element
    for element in &file.elements {
        if collect_containing_spans(element, position, &mut spans) {
            break;
        }
    }

    if spans.is_empty() {
        return Vec::new();
    }

    // Sort by range size (smallest first for innermost)
    spans.sort_by(|a, b| {
        let size_a = range_size(a);
        let size_b = range_size(b);
        size_a.cmp(&size_b)
    });

    spans
}

/// Calculate a rough "size" of a span for sorting
fn range_size(span: &Span) -> usize {
    let lines = span.end.line.saturating_sub(span.start.line);
    let cols = if lines == 0 {
        span.end.column.saturating_sub(span.start.column)
    } else {
        span.end.column + 100
    };
    lines * 100 + cols
}

/// Try to push a span if it contains the position
fn try_push_span(span: &Option<Span>, position: Position, spans: &mut Vec<Span>) -> bool {
    if let Some(span) = span
        && span.contains(position)
    {
        spans.push(*span);
        return true;
    }
    false
}

/// Recursively collect all spans that contain the position
fn collect_containing_spans(element: &Element, position: Position, spans: &mut Vec<Span>) -> bool {
    match element {
        Element::Package(p) => collect_package_spans(p, position, spans),
        Element::Definition(d) => collect_definition_spans(d, position, spans),
        Element::Usage(u) => collect_usage_spans(u, position, spans),
        Element::Comment(c) => try_push_span(&c.span, position, spans),
        Element::Import(i) => try_push_span(&i.span, position, spans),
        Element::Alias(a) => try_push_span(&a.span, position, spans),
    }
}

fn collect_package_spans(package: &Package, position: Position, spans: &mut Vec<Span>) -> bool {
    if !try_push_span(&package.span, position, spans) {
        return false;
    }

    for child in &package.elements {
        if collect_containing_spans(child, position, spans) {
            return true;
        }
    }

    true
}

fn collect_definition_spans(def: &Definition, position: Position, spans: &mut Vec<Span>) -> bool {
    if !try_push_span(&def.span, position, spans) {
        return false;
    }

    for member in &def.body {
        match member {
            DefinitionMember::Usage(u) => {
                if collect_usage_spans(u, position, spans) {
                    return true;
                }
            }
            DefinitionMember::Comment(c) => {
                if try_push_span(&c.span, position, spans) {
                    return true;
                }
            }
        }
    }

    true
}

fn collect_usage_spans(usage: &Usage, position: Position, spans: &mut Vec<Span>) -> bool {
    if !try_push_span(&usage.span, position, spans) {
        return false;
    }

    for member in &usage.body {
        match member {
            UsageMember::Usage(u) => {
                if collect_usage_spans(u, position, spans) {
                    return true;
                }
            }
            UsageMember::Comment(c) => {
                if try_push_span(&c.span, position, spans) {
                    return true;
                }
            }
        }
    }

    true
}