just-lsp 0.2.8

A language server for just
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

use super::*;

/// Detects circular dependency chains between recipes to prevent infinite
/// execution loops.
pub struct RecipeDependencyCycleRule;

impl Rule for RecipeDependencyCycleRule {
  fn display_name(&self) -> &'static str {
    "Recipe Dependency Cycles"
  }

  fn id(&self) -> &'static str {
    "recipe-dependency-cycles"
  }

  fn run(&self, context: &RuleContext<'_>) -> Vec<lsp::Diagnostic> {
    let mut dependency_graph = HashMap::new();
    let mut diagnostics = Vec::new();

    for recipe in context.recipes() {
      dependency_graph.insert(
        recipe.name.clone(),
        recipe
          .dependencies
          .iter()
          .map(|dep| dep.name.clone())
          .collect::<Vec<_>>(),
      );
    }

    let mut reported_recipes = HashSet::new();

    for recipe in context.recipes() {
      let mut path = Vec::new();
      let mut visited = HashSet::new();

      let mut traversal_state = TraversalState {
        visited: &mut visited,
        path: &mut path,
        reported_recipes: &mut reported_recipes,
      };

      self.detect_cycle(
        &recipe.name,
        &dependency_graph,
        &mut diagnostics,
        context,
        &mut traversal_state,
      );
    }

    diagnostics
  }
}

struct TraversalState<'a> {
  path: &'a mut Vec<String>,
  reported_recipes: &'a mut HashSet<String>,
  visited: &'a mut HashSet<String>,
}

impl RecipeDependencyCycleRule {
  fn detect_cycle(
    &self,
    recipe_name: &str,
    graph: &HashMap<String, Vec<String>>,
    diagnostics: &mut Vec<lsp::Diagnostic>,
    context: &RuleContext<'_>,
    traversal: &mut TraversalState<'_>,
  ) {
    if traversal.visited.contains(recipe_name) {
      return;
    }

    if traversal.path.iter().any(|r| r == recipe_name) {
      let cycle_start_idx = traversal
        .path
        .iter()
        .position(|r| r == recipe_name)
        .unwrap();

      let mut cycle = traversal.path[cycle_start_idx..].to_vec();
      cycle.push(recipe_name.to_string());

      if let Some(recipe) = context.recipe(recipe_name) {
        let message = if cycle.len() == 2 && cycle[0] == cycle[1] {
          format!("Recipe `{}` depends on itself", cycle[0])
        } else if cycle[0] == recipe_name {
          format!(
            "Recipe `{}` has circular dependency `{}`",
            recipe_name,
            cycle.join(" -> ")
          )
        } else {
          traversal.path.push(recipe_name.to_string());
          return;
        };

        if !traversal.reported_recipes.insert(recipe_name.to_string()) {
          return;
        }

        diagnostics.push(self.diagnostic(lsp::Diagnostic {
          range: recipe.range,
          severity: Some(lsp::DiagnosticSeverity::ERROR),
          message,
          ..Default::default()
        }));
      }

      return;
    }

    if !graph.contains_key(recipe_name) {
      return;
    }

    traversal.path.push(recipe_name.to_string());

    if let Some(dependencies) = graph.get(recipe_name) {
      for dependency in dependencies {
        self.detect_cycle(dependency, graph, diagnostics, context, traversal);
      }
    }

    traversal.visited.insert(recipe_name.to_string());

    traversal.path.pop();
  }
}