lambdust 0.1.1

A Scheme dialect with gradual typing and effect systems
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

//! Dependency analysis components for program structure analysis.

use crate::ast::Program;
use crate::diagnostics::{Result, Span};
use super::analysis_types::{DefinitionType, DependencyType};
use std::collections::{HashMap, HashSet};

/// Dependency graph representing relationships between definitions.
#[derive(Debug, Clone)]
pub struct DependencyGraph {
    /// Nodes in the graph (definitions)
    pub nodes: HashMap<String, DependencyNode>,
    /// Edges representing dependencies
    pub edges: Vec<DependencyEdge>,
    /// Strongly connected components (cycles)
    pub cycles: Vec<Vec<String>>,
}

/// Node in the dependency graph.
#[derive(Debug, Clone)]
pub struct DependencyNode {
    /// Name of the definition
    pub name: String,
    /// Type of definition
    pub definition_type: DefinitionType,
    /// Source location
    pub location: Option<Span>,
    /// Dependencies (outgoing edges)
    pub dependencies: HashSet<String>,
    /// Dependents (incoming edges)
    pub dependents: HashSet<String>,
}

/// Edge in the dependency graph.
#[derive(Debug, Clone)]
pub struct DependencyEdge {
    /// Source node
    pub from: String,
    /// Target node
    pub to: String,
    /// Type of dependency
    pub dependency_type: DependencyType,
    /// Source location where dependency occurs
    pub location: Option<Span>,
}

/// Dependency analyzer for program dependencies.
#[derive(Debug)]
pub struct DependencyAnalyzer {
    /// Placeholder for internal state
    _internal: (),
}

impl DependencyGraph {
    /// Creates a new empty dependency graph.
    pub fn new() -> Self {
        Self {
            nodes: HashMap::new(),
            edges: Vec::new(),
            cycles: Vec::new(),
        }
    }

    /// Adds a new node to the dependency graph.
    pub fn add_node(&mut self, name: String, def_type: DefinitionType, location: Option<Span>) {
        let node = DependencyNode {
            name: name.clone(),
            definition_type: def_type,
            location,
            dependencies: HashSet::new(),
            dependents: HashSet::new(),
        };
        self.nodes.insert(name, node);
    }

    /// Adds a dependency edge to the graph.
    pub fn add_dependency(&mut self, from: String, to: String, dep_type: DependencyType, location: Option<Span>) {
        // Add edge
        self.edges.push(DependencyEdge {
            from: from.clone(),
            to: to.clone(),
            dependency_type: dep_type,
            location,
        });

        // Update node dependencies
        if let Some(from_node) = self.nodes.get_mut(&from) {
            from_node.dependencies.insert(to.clone());
        }
        if let Some(to_node) = self.nodes.get_mut(&to) {
            to_node.dependents.insert(from);
        }
    }
}

impl Default for DependencyGraph {
    fn default() -> Self {
        Self::new()
    }
}

impl DependencyAnalyzer {
    /// Creates a new dependency analyzer.
    pub fn new() -> Self {
        Self {
            _internal: (),
        }
    }

    /// Analyzes dependencies in a program.
    pub fn analyze_dependencies(&mut self, _program: &Program) -> Result<DependencyGraph> {
        // Temporary implementation - will be filled in when integrating with StaticAnalyzer
        Ok(DependencyGraph::new())
    }
}

impl Default for DependencyAnalyzer {
    fn default() -> Self {
        Self::new()
    }
}