@jbearak/sight 0.10.0 → 0.11.0

package/dist/sight-server.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@jbearak/sight",
-    version: "0.10.0",
+    version: "0.11.0",
     type: "module",
     workspaces: [
       "client"
@@ -926,7 +926,9 @@ var init_schema = __esm(() => {
     "spacedCompoundOperator",
     "invalidOperatorSequence",
     "cStyleLogicalInControlFlow",
-    "mixedLogicalOperators"
+    "mixedLogicalOperators",
+    "chainedComparison",
+    "literalMacroAdjacency"
   ];
   INDENT_STYLES = ["spaces", "tabs"];
   FORMATTER_MODES = ["source-preserving", "ast"];
@@ -2203,6 +2205,8 @@ var init_types = __esm(() => {
     StataDiagnosticCode2["CSTYLE_LOGICAL_IN_CONTROL_FLOW"] = "CSTYLE_LOGICAL_IN_CONTROL_FLOW";
     StataDiagnosticCode2["MIXED_LOGICAL_OPERATORS"] = "MIXED_LOGICAL_OPERATORS";
     StataDiagnosticCode2["SPACED_COMPOUND_OPERATOR"] = "SPACED_COMPOUND_OPERATOR";
+    StataDiagnosticCode2["CHAINED_COMPARISON"] = "CHAINED_COMPARISON";
+    StataDiagnosticCode2["LITERAL_MACRO_ADJACENCY"] = "LITERAL_MACRO_ADJACENCY";
     StataDiagnosticCode2["PATH_CASE_MISMATCH"] = "PATH_CASE_MISMATCH";
     StataDiagnosticCode2["CROSS_FILE_MISSING_FILE"] = "CROSS_FILE_MISSING_FILE";
     StataDiagnosticCode2["CROSS_FILE_TRUNCATED"] = "CROSS_FILE_TRUNCATED";
@@ -26568,7 +26572,31 @@ var init_indentation_diagnostics = __esm(() => {
   FIRST_WORD_RE = /^(\w+)\b/;
 });
 
+// src/utils/diagnostic-severity.ts
+function resolve_diagnostic_severity(my_config_severity, fallback = import_node2.DiagnosticSeverity.Warning) {
+  switch (my_config_severity) {
+    case "error":
+      return import_node2.DiagnosticSeverity.Error;
+    case "warning":
+      return import_node2.DiagnosticSeverity.Warning;
+    case "information":
+      return import_node2.DiagnosticSeverity.Information;
+    case "hint":
+      return import_node2.DiagnosticSeverity.Hint;
+    default:
+      return fallback;
+  }
+}
+var import_node2;
+var init_diagnostic_severity = __esm(() => {
+  import_node2 = __toESM(require_main4(), 1);
+});
+
 // src/providers/operator-sequence-diagnostics.ts
+function is_invalid_operator_sequence_pair(first_value, second_value) {
+  return INVALID_PAIRS.has(`${first_value} ${second_value}`);
+}
+
 class OperatorSequenceAnalyzer {
   analyze(document, config) {
     const malformed_severity = config.diagnostics?.severity?.malformedOperator ?? "warning";
@@ -26629,7 +26657,7 @@ class OperatorSequenceAnalyzer {
       }
       const severity = this.resolve_severity(config_severity, pair_result.default_severity);
       const diagnostic = {
-        range: import_node2.Range.create(first_token.range.start, second_token.range.end),
+        range: import_node3.Range.create(first_token.range.start, second_token.range.end),
         message: pair_result.message,
         severity,
         source: "sight",
@@ -26680,7 +26708,7 @@ class OperatorSequenceAnalyzer {
         second_token,
         pair_key,
         message: `Spaced compound operator '${pair_key}'. Stata treats this as ` + `'${spaced_compound}'; consider writing '${spaced_compound}'.`,
-        default_severity: import_node2.DiagnosticSeverity.Information,
+        default_severity: import_node3.DiagnosticSeverity.Information,
         code: "SPACED_COMPOUND_OPERATOR" /* SPACED_COMPOUND_OPERATOR */
       };
     }
@@ -26692,7 +26720,7 @@ class OperatorSequenceAnalyzer {
         second_token,
         pair_key,
         message: `Malformed operator '${pair_key}'. Did you mean '${malformed_suggestion}'?`,
-        default_severity: import_node2.DiagnosticSeverity.Warning,
+        default_severity: import_node3.DiagnosticSeverity.Warning,
         code: "MALFORMED_OPERATOR" /* MALFORMED_OPERATOR */
       };
     }
@@ -26706,7 +26734,7 @@ class OperatorSequenceAnalyzer {
           second_token,
           pair_key,
           message,
-          default_severity: import_node2.DiagnosticSeverity.Information,
+          default_severity: import_node3.DiagnosticSeverity.Information,
           code: "CSTYLE_LOGICAL_IN_CONTROL_FLOW" /* CSTYLE_LOGICAL_IN_CONTROL_FLOW */
         };
       } else {
@@ -26718,7 +26746,7 @@ class OperatorSequenceAnalyzer {
           second_token,
           pair_key,
           message,
-          default_severity: import_node2.DiagnosticSeverity.Error,
+          default_severity: import_node3.DiagnosticSeverity.Error,
           code: "INVALID_OPERATOR_SEQUENCE" /* INVALID_OPERATOR_SEQUENCE */
         };
       }
@@ -26732,7 +26760,7 @@ class OperatorSequenceAnalyzer {
         second_token,
         pair_key,
         message,
-        default_severity: import_node2.DiagnosticSeverity.Error,
+        default_severity: import_node3.DiagnosticSeverity.Error,
         code: "INVALID_OPERATOR_SEQUENCE" /* INVALID_OPERATOR_SEQUENCE */
       };
     }
@@ -26837,27 +26865,21 @@ class OperatorSequenceAnalyzer {
     return false;
   }
   resolve_severity(config_severity, default_severity) {
-    switch (config_severity) {
-      case "error":
-        return import_node2.DiagnosticSeverity.Error;
-      case "warning":
-        return import_node2.DiagnosticSeverity.Warning;
-      case "information":
-        return import_node2.DiagnosticSeverity.Information;
-      case "hint":
-        return import_node2.DiagnosticSeverity.Hint;
-      case "off":
-        throw new Error('resolve_severity called with "off" - caller must filter before calling');
-      default:
-        return default_severity;
+    if (config_severity === undefined) {
+      return default_severity;
+    }
+    if (config_severity === "off") {
+      throw new Error('resolve_severity called with "off" - caller must filter before calling');
     }
+    return resolve_diagnostic_severity(config_severity, default_severity);
   }
 }
-var import_node2, SPACED_COMPOUND_PAIRS, MALFORMED_OPERATOR_PAIRS, INVALID_PAIRS, CSTYLE_LOGICAL_PAIRS, SPECIAL_MESSAGES, CSTYLE_QUALIFIER_MESSAGES, CSTYLE_CONTROL_FLOW_MESSAGES, ARITHMETIC_OPS, COMPARISON_OPS, NEGATION_OPS, TRIVIA_TYPES, ADJACENCY_BREAKERS;
+var import_node3, SPACED_COMPOUND_PAIRS, MALFORMED_OPERATOR_PAIRS, INVALID_PAIRS, CSTYLE_LOGICAL_PAIRS, SPECIAL_MESSAGES, CSTYLE_QUALIFIER_MESSAGES, CSTYLE_CONTROL_FLOW_MESSAGES, ARITHMETIC_OPS, COMPARISON_OPS, NEGATION_OPS, TRIVIA_TYPES, ADJACENCY_BREAKERS;
 var init_operator_sequence_diagnostics = __esm(() => {
   init_types();
   init_diagnostic_code_description();
-  import_node2 = __toESM(require_main4(), 1);
+  init_diagnostic_severity();
+  import_node3 = __toESM(require_main4(), 1);
   SPACED_COMPOUND_PAIRS = new Map([
     ["< =", "<="],
     ["> =", ">="],
@@ -26902,11 +26924,14 @@ var init_operator_sequence_diagnostics = __esm(() => {
   ARITHMETIC_OPS = new Set(["+", "-", "*", "/", "^"]);
   COMPARISON_OPS = new Set(["<", ">"]);
   NEGATION_OPS = new Set(["!", "~"]);
-  TRIVIA_TYPES = new Set(["WHITESPACE", "CONTINUATION"]);
+  TRIVIA_TYPES = new Set([
+    "WHITESPACE",
+    "CONTINUATION",
+    "COMMENT_BLOCK",
+    "COMMENT_LINE"
+  ]);
   ADJACENCY_BREAKERS = new Set([
-    "STATEMENT_TERMINATOR",
-    "COMMENT_LINE",
-    "COMMENT_BLOCK"
+    "STATEMENT_TERMINATOR"
   ]);
 });
 
@@ -26929,7 +26954,7 @@ class MixedLogicalOperatorAnalyzer {
       return [];
     }
     const my_ignored_lines = document.ignored_lines ?? new Set;
-    const my_severity = this.resolve_severity(my_config_severity);
+    const my_severity = resolve_diagnostic_severity(my_config_severity);
     const my_diagnostics = [];
     let my_state = this.fresh_state();
     let my_in_continuation = false;
@@ -27065,7 +27090,7 @@ class MixedLogicalOperatorAnalyzer {
         continue;
       }
       my_diagnostics.push({
-        range: import_node3.Range.create(my_first_token.range.start, my_last_token.range.end),
+        range: import_node4.Range.create(my_first_token.range.start, my_last_token.range.end),
         message: "Mixed '&' and '|' without parentheses. " + "Use parentheses to clarify precedence " + "(e.g., '(x & y) | z' or 'x & (y | z)')",
         severity: my_severity,
         source: "sight",
@@ -27074,24 +27099,13 @@ class MixedLogicalOperatorAnalyzer {
       });
     }
   }
-  resolve_severity(my_config_severity) {
-    switch (my_config_severity) {
-      case "error":
-        return import_node3.DiagnosticSeverity.Error;
-      case "warning":
-        return import_node3.DiagnosticSeverity.Warning;
-      case "information":
-        return import_node3.DiagnosticSeverity.Information;
-      case "hint":
-        return import_node3.DiagnosticSeverity.Hint;
-    }
-  }
 }
-var import_node3, LOGICAL_OPS, QUALIFIER_BREAKERS, EXPRESSION_BREAKERS;
+var import_node4, LOGICAL_OPS, QUALIFIER_BREAKERS, EXPRESSION_BREAKERS;
 var init_mixed_logical_diagnostics = __esm(() => {
   init_types();
   init_diagnostic_code_description();
-  import_node3 = __toESM(require_main4(), 1);
+  init_diagnostic_severity();
+  import_node4 = __toESM(require_main4(), 1);
   LOGICAL_OPS = new Set(["&", "|"]);
   QUALIFIER_BREAKERS = new Set(["if", "in"]);
   EXPRESSION_BREAKERS = new Set([
@@ -27102,6 +27116,362 @@ var init_mixed_logical_diagnostics = __esm(() => {
   ]);
 });
 
+// src/providers/diagnostic-token-stream.ts
+function normalized_spaced_comparison_operator(first, second) {
+  if (first.type !== "OPERATOR" || second?.type !== "OPERATOR") {
+    return;
+  }
+  const my_compact_operator = SPACED_COMPARISON_OPERATOR_PAIRS.get(`${first.value} ${second.value}`);
+  if (!my_compact_operator) {
+    return;
+  }
+  return {
+    type: "OPERATOR",
+    value: my_compact_operator,
+    range: {
+      start: first.range.start,
+      end: second.range.end
+    }
+  };
+}
+function collect_significant_tokens(tokens) {
+  const the_unfiltered_significant = [];
+  let my_in_continuation = false;
+  for (const my_token of tokens) {
+    if (my_token.type === "STATEMENT_TERMINATOR" && my_in_continuation) {
+      my_in_continuation = false;
+      continue;
+    }
+    if (my_token.type === "WHITESPACE") {
+      continue;
+    }
+    if (my_token.type === "CONTINUATION") {
+      my_in_continuation = true;
+      continue;
+    }
+    if (my_token.type === "COMMENT_BLOCK" || my_token.type === "COMMENT_LINE") {
+      continue;
+    }
+    my_in_continuation = false;
+    the_unfiltered_significant.push(my_token);
+  }
+  const the_significant = [];
+  for (let i = 0;i < the_unfiltered_significant.length; i++) {
+    const my_token = the_unfiltered_significant[i];
+    const my_normalized_operator = normalized_spaced_comparison_operator(my_token, the_unfiltered_significant[i + 1]);
+    if (my_normalized_operator) {
+      the_significant.push(my_normalized_operator);
+      i++;
+      continue;
+    }
+    the_significant.push(my_token);
+  }
+  return the_significant;
+}
+function is_adjacent(first, second) {
+  return first.range.end.line === second.range.start.line && first.range.end.character === second.range.start.character;
+}
+var COMPARISON_OPERATORS, LOGICAL_OPERATORS, SPACED_COMPARISON_OPERATOR_PAIRS;
+var init_diagnostic_token_stream = __esm(() => {
+  COMPARISON_OPERATORS = new Set([
+    "==",
+    "!=",
+    "~=",
+    "<",
+    "<=",
+    ">",
+    ">="
+  ]);
+  LOGICAL_OPERATORS = new Set(["&", "|"]);
+  SPACED_COMPARISON_OPERATOR_PAIRS = new Map([
+    ["< =", "<="],
+    ["> =", ">="],
+    ["! =", "!="],
+    ["~ =", "~="]
+  ]);
+});
+
+// src/providers/chained-comparison-diagnostics.ts
+class ChainedComparisonAnalyzer {
+  analyze(document, config) {
+    const my_config_severity = config.diagnostics?.severity?.chainedComparison ?? "warning";
+    if (my_config_severity === "off") {
+      return [];
+    }
+    const the_tokens = document.tokens;
+    if (!the_tokens || the_tokens.length === 0) {
+      return [];
+    }
+    const the_significant = collect_significant_tokens(the_tokens);
+    const my_ignored_lines = document.ignored_lines ?? new Set;
+    const my_severity = resolve_diagnostic_severity(my_config_severity);
+    const the_chains = [];
+    let run_stack = [[]];
+    let prev_significant = undefined;
+    const incomplete_tail_operators = new WeakSet;
+    const close_run = (my_run) => {
+      if (my_run.length >= 2) {
+        const last_operator = my_run[my_run.length - 1];
+        the_chains.push({
+          first: my_run[0],
+          last: last_operator,
+          incomplete_tail: incomplete_tail_operators.has(last_operator)
+        });
+      }
+      my_run.length = 0;
+    };
+    const flush_all = () => {
+      for (const my_run of run_stack) {
+        close_run(my_run);
+      }
+      run_stack = [[]];
+      prev_significant = undefined;
+    };
+    const is_missing_rhs_after_comparison = (my_next_token) => {
+      if (!my_next_token) {
+        return true;
+      }
+      return EXPRESSION_BREAKERS2.has(my_next_token.type) || my_next_token.type === "COMMA" || my_next_token.type === "EOF" || my_next_token.type === "RPAREN" || my_next_token.type === "RBRACKET";
+    };
+    for (let i = 0;i < the_significant.length; i++) {
+      const my_token = the_significant[i];
+      const next_significant = the_significant[i + 1];
+      if (run_stack.length === 1 && my_token.type === "WORD" && QUALIFIER_BREAKERS2.has(my_token.value)) {
+        flush_all();
+        continue;
+      }
+      if (EXPRESSION_BREAKERS2.has(my_token.type)) {
+        flush_all();
+        continue;
+      }
+      const current_run = run_stack[run_stack.length - 1];
+      if (my_token.type === "COMMA") {
+        close_run(current_run);
+        prev_significant = my_token;
+        continue;
+      }
+      if (my_token.type === "LPAREN" || my_token.type === "LBRACKET") {
+        run_stack.push([]);
+        prev_significant = my_token;
+        continue;
+      }
+      if (my_token.type === "RPAREN" || my_token.type === "RBRACKET") {
+        if (run_stack.length > 1) {
+          const my_closed = run_stack.pop();
+          close_run(my_closed);
+        }
+        prev_significant = my_token;
+        continue;
+      }
+      if (my_token.type === "OPERATOR") {
+        if (LOGICAL_OPERATORS.has(my_token.value)) {
+          close_run(current_run);
+          prev_significant = my_token;
+          continue;
+        }
+        if (COMPARISON_OPERATORS.has(my_token.value)) {
+          if (prev_significant && OPERAND_END_TYPES.has(prev_significant.type)) {
+            if (next_significant?.type === "OPERATOR" && is_invalid_operator_sequence_pair(my_token.value, next_significant.value)) {
+              close_run(current_run);
+            } else {
+              if (is_missing_rhs_after_comparison(next_significant)) {
+                incomplete_tail_operators.add(my_token);
+              }
+              current_run.push(my_token);
+            }
+          } else {
+            close_run(current_run);
+          }
+          prev_significant = my_token;
+          continue;
+        }
+        prev_significant = my_token;
+        continue;
+      }
+      if (prev_significant && OPERAND_END_TYPES.has(prev_significant.type) && !is_adjacent(prev_significant, my_token)) {
+        close_run(current_run);
+      }
+      prev_significant = my_token;
+    }
+    for (const my_run of run_stack) {
+      close_run(my_run);
+    }
+    const the_diagnostics = [];
+    for (const my_chain of the_chains) {
+      if (this.is_range_ignored(my_chain.first.range.start.line, my_chain.last.range.end.line, my_ignored_lines)) {
+        continue;
+      }
+      the_diagnostics.push({
+        range: import_node5.Range.create(my_chain.first.range.start, my_chain.last.range.end),
+        message: my_chain.incomplete_tail ? "Incomplete chained comparison. A later comparison " + "operator has no right-hand operand; complete the " + "comparison or replace the chain with an explicit " + "logical operator (`&`/`|`)." : "Chained comparison is suspicious. Stata evaluates " + "comparisons left-to-right (e.g. `a < b < c` becomes " + "`(a < b) < c`), not as a mathematical chain. Use an " + "explicit logical operator (`&`/`|`) or parentheses to " + "make the intended evaluation clear.",
+        severity: my_severity,
+        source: "sight",
+        code: "CHAINED_COMPARISON" /* CHAINED_COMPARISON */,
+        ...diagnostic_code_description_fields("CHAINED_COMPARISON" /* CHAINED_COMPARISON */)
+      });
+    }
+    return the_diagnostics;
+  }
+  is_range_ignored(start_line, end_line, ignored_lines) {
+    for (let my_line = start_line;my_line <= end_line; my_line++) {
+      if (ignored_lines.has(my_line)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+var import_node5, OPERAND_END_TYPES, EXPRESSION_BREAKERS2, QUALIFIER_BREAKERS2;
+var init_chained_comparison_diagnostics = __esm(() => {
+  init_types();
+  init_diagnostic_code_description();
+  init_diagnostic_severity();
+  init_diagnostic_token_stream();
+  init_operator_sequence_diagnostics();
+  import_node5 = __toESM(require_main4(), 1);
+  OPERAND_END_TYPES = new Set([
+    "WORD",
+    "NUMBER",
+    "STRING",
+    "MACRO_REF_LOCAL",
+    "MACRO_REF_GLOBAL",
+    "RPAREN",
+    "RBRACKET"
+  ]);
+  EXPRESSION_BREAKERS2 = new Set([
+    "STATEMENT_TERMINATOR",
+    "LBRACE",
+    "RBRACE"
+  ]);
+  QUALIFIER_BREAKERS2 = new Set(["if", "in"]);
+});
+
+// src/providers/literal-macro-adjacency-diagnostics.ts
+function is_complete_string(my_token) {
+  const my_value = my_token.value;
+  if (my_value.startsWith('`"') && my_value.endsWith(`"'`)) {
+    return my_value.length >= 4;
+  }
+  return my_value.length >= 2 && my_value.startsWith('"') && my_value.endsWith('"');
+}
+function is_qualifying_literal(my_token) {
+  if (my_token.type === "NUMBER") {
+    return true;
+  }
+  if (my_token.type === "STRING") {
+    return is_complete_string(my_token);
+  }
+  return false;
+}
+function is_expression_operator(my_token) {
+  return my_token !== undefined && my_token.type === "OPERATOR" && (COMPARISON_OPERATORS.has(my_token.value) || LOGICAL_OPERATORS.has(my_token.value));
+}
+function governing_before(the_significant, index) {
+  let my_group_opens = 0;
+  for (let my_i = index - 1;my_i >= 0; my_i--) {
+    const my_token = the_significant[my_i];
+    if (GROUP_OPEN_TYPES.has(my_token.type)) {
+      const my_before_paren = my_i - 1 >= 0 ? the_significant[my_i - 1] : undefined;
+      if (is_call_opener(my_before_paren, my_token)) {
+        return {
+          token: my_before_paren,
+          group_opens: my_group_opens
+        };
+      }
+      my_group_opens++;
+      continue;
+    }
+    if (my_token.type === "OPERATOR" && UNARY_PREFIX_OPERATORS.has(my_token.value)) {
+      continue;
+    }
+    return { token: my_token, group_opens: my_group_opens };
+  }
+  return { token: undefined, group_opens: my_group_opens };
+}
+function is_call_opener(my_token, my_paren) {
+  if (my_token === undefined) {
+    return false;
+  }
+  if (!is_adjacent(my_token, my_paren)) {
+    return false;
+  }
+  if (my_token.type === "RPAREN" || my_token.type === "RBRACKET") {
+    return true;
+  }
+  return my_token.type === "WORD" && !CONDITION_KEYWORDS.has(my_token.value);
+}
+function governing_after(the_significant, index, max_group_closes) {
+  let my_remaining_closes = max_group_closes;
+  for (let my_i = index + 1;my_i < the_significant.length; my_i++) {
+    const my_token = the_significant[my_i];
+    if (GROUP_CLOSE_TYPES.has(my_token.type)) {
+      if (my_remaining_closes > 0) {
+        my_remaining_closes--;
+        continue;
+      }
+      return my_token;
+    }
+    return my_token;
+  }
+  return;
+}
+
+class LiteralMacroAdjacencyAnalyzer {
+  analyze(document, config) {
+    const my_config_severity = config.diagnostics?.severity?.literalMacroAdjacency ?? "hint";
+    if (my_config_severity === "off") {
+      return [];
+    }
+    const the_tokens = document.tokens;
+    if (!the_tokens || the_tokens.length === 0) {
+      return [];
+    }
+    const the_significant = collect_significant_tokens(the_tokens);
+    const my_ignored_lines = document.ignored_lines ?? new Set;
+    const my_severity = resolve_diagnostic_severity(my_config_severity);
+    const the_diagnostics = [];
+    for (let i = 1;i < the_significant.length; i++) {
+      const my_macro = the_significant[i];
+      const my_literal = the_significant[i - 1];
+      if (!MACRO_REF_TYPES.has(my_macro.type) || !is_qualifying_literal(my_literal) || !is_adjacent(my_literal, my_macro)) {
+        continue;
+      }
+      const before = governing_before(the_significant, i - 1);
+      const governor_after = governing_after(the_significant, i, before.group_opens);
+      const operator_before = is_expression_operator(before.token);
+      const operator_after = is_expression_operator(governor_after);
+      const leads_condition = before.token !== undefined && before.token.type === "WORD" && CONDITION_KEYWORDS.has(before.token.value);
+      if ((operator_before || operator_after || leads_condition) && !my_ignored_lines.has(my_literal.range.start.line)) {
+        the_diagnostics.push({
+          range: import_node6.Range.create(my_literal.range.start, my_macro.range.end),
+          message: "Literal adjacent to macro reference in an " + "expression. Stata concatenates these during macro " + "expansion; add an operator, whitespace, or " + "parentheses if that was not intended.",
+          severity: my_severity,
+          source: "sight",
+          code: "LITERAL_MACRO_ADJACENCY" /* LITERAL_MACRO_ADJACENCY */,
+          ...diagnostic_code_description_fields("LITERAL_MACRO_ADJACENCY" /* LITERAL_MACRO_ADJACENCY */)
+        });
+      }
+    }
+    return the_diagnostics;
+  }
+}
+var import_node6, MACRO_REF_TYPES, CONDITION_KEYWORDS, GROUP_OPEN_TYPES, GROUP_CLOSE_TYPES, UNARY_PREFIX_OPERATORS;
+var init_literal_macro_adjacency_diagnostics = __esm(() => {
+  init_types();
+  init_diagnostic_code_description();
+  init_diagnostic_severity();
+  init_diagnostic_token_stream();
+  import_node6 = __toESM(require_main4(), 1);
+  MACRO_REF_TYPES = new Set([
+    "MACRO_REF_LOCAL",
+    "MACRO_REF_GLOBAL"
+  ]);
+  CONDITION_KEYWORDS = new Set(["if", "while"]);
+  GROUP_OPEN_TYPES = new Set(["LPAREN", "LBRACKET"]);
+  GROUP_CLOSE_TYPES = new Set(["RPAREN", "RBRACKET"]);
+  UNARY_PREFIX_OPERATORS = new Set(["-", "+", "!", "~"]);
+});
+
 // src/providers/diagnostics.ts
 import { createHash } from "crypto";
 function is_lexer_error_code(code) {
@@ -27120,6 +27490,8 @@ class DiagnosticsProvider {
   indentation_analyzer = new IndentationDiagnosticAnalyzer;
   operator_sequence_analyzer = new OperatorSequenceAnalyzer;
   mixed_logical_analyzer = new MixedLogicalOperatorAnalyzer;
+  chained_comparison_analyzer = new ChainedComparisonAnalyzer;
+  literal_macro_adjacency_analyzer = new LiteralMacroAdjacencyAnalyzer;
   dependency_graph;
   published_versions = new Map;
   filtered_cache = new Map;
@@ -27299,6 +27671,18 @@ class DiagnosticsProvider {
         the_diagnostics.push(my_mixed_diag);
       }
     }
+    const chained_comparison_diagnostics = this.chained_comparison_analyzer.analyze(document, config);
+    for (const my_chained_diag of chained_comparison_diagnostics) {
+      if (!this.is_in_embedded_context(my_chained_diag.range.start, the_context_ranges)) {
+        the_diagnostics.push(my_chained_diag);
+      }
+    }
+    const literal_macro_adjacency_diagnostics = this.literal_macro_adjacency_analyzer.analyze(document, config);
+    for (const my_adjacency_diag of literal_macro_adjacency_diagnostics) {
+      if (!this.is_in_embedded_context(my_adjacency_diag.range.start, the_context_ranges)) {
+        the_diagnostics.push(my_adjacency_diag);
+      }
+    }
     if (resolved_scope) {
       for (const my_directive_diag of resolved_scope.diagnostics) {
         const converted = this.convert_directive_diagnostic(my_directive_diag, config);
@@ -27833,6 +28217,8 @@ var init_diagnostics = __esm(() => {
   init_indentation_diagnostics();
   init_operator_sequence_diagnostics();
   init_mixed_logical_diagnostics();
+  init_chained_comparison_diagnostics();
+  init_literal_macro_adjacency_diagnostics();
   import_vscode_languageserver2 = __toESM(require_main4(), 1);
   LEXER_ERROR_CODES = new Set(Object.values(LexerErrorCode));
   PARSER_ERROR_CODES = new Set(Object.values(ParseErrorCode));
@@ -31011,7 +31397,7 @@ function create_initialize_handler(on_capabilities_detected, on_initialization_o
     }
     const result = {
       capabilities: {
-        textDocumentSync: import_node4.TextDocumentSyncKind.Incremental,
+        textDocumentSync: import_node7.TextDocumentSyncKind.Incremental,
         completionProvider: {
           triggerCharacters: [":", "`", '"', "$", "{", ",", " "],
           resolveProvider: false
@@ -31442,7 +31828,7 @@ function create_expand_includes_handler(deps, shared_ihlp) {
     return { content: my_result };
   };
 }
-var import_node4, DEFAULT_SETTINGS, MAX_IHLP_CACHE_SIZE = 500, MAX_RESOLVE_STHLP_NEGATIVE_CACHE_SIZE = 1000;
+var import_node7, DEFAULT_SETTINGS, MAX_IHLP_CACHE_SIZE = 500, MAX_RESOLVE_STHLP_NEGATIVE_CACHE_SIZE = 1000;
 var init_server_handlers = __esm(() => {
   init_completion();
   init_context_tracker();
@@ -31451,7 +31837,7 @@ var init_server_handlers = __esm(() => {
   init_marker_scanner();
   init_help_resolver();
   init_config_file();
-  import_node4 = __toESM(require_main4(), 1);
+  import_node7 = __toESM(require_main4(), 1);
   DEFAULT_SETTINGS = {
     diagnostics: {
       enabled: true,
@@ -31463,7 +31849,9 @@ var init_server_handlers = __esm(() => {
         spacedCompoundOperator: "information",
         invalidOperatorSequence: "error",
         cStyleLogicalInControlFlow: "information",
-        mixedLogicalOperators: "warning"
+        mixedLogicalOperators: "warning",
+        chainedComparison: "warning",
+        literalMacroAdjacency: "hint"
       },
       indentation: false
     },
@@ -31607,6 +31995,12 @@ function validate_comment_formatting_config(config, log_warning) {
       if (diagnostics.severity.mixedLogicalOperators && valid_severities.includes(diagnostics.severity.mixedLogicalOperators)) {
         validated_config.diagnostics.severity.mixedLogicalOperators = diagnostics.severity.mixedLogicalOperators;
       }
+      if (diagnostics.severity.chainedComparison && valid_severities.includes(diagnostics.severity.chainedComparison)) {
+        validated_config.diagnostics.severity.chainedComparison = diagnostics.severity.chainedComparison;
+      }
+      if (diagnostics.severity.literalMacroAdjacency && valid_severities.includes(diagnostics.severity.literalMacroAdjacency)) {
+        validated_config.diagnostics.severity.literalMacroAdjacency = diagnostics.severity.literalMacroAdjacency;
+      }
     }
     if (typeof diagnostics.indentation === "boolean") {
       validated_config.diagnostics.indentation = diagnostics.indentation;
@@ -69870,9 +70264,9 @@ __export(exports_server_factory, {
 import * as fs14 from "fs";
 function create_transport_connection(transport) {
   if (transport === "stdio") {
-    return import_node5.createConnection(process.stdin, process.stdout);
+    return import_node8.createConnection(process.stdin, process.stdout);
   } else {
-    return import_node5.createConnection(import_node5.ProposedFeatures.all);
+    return import_node8.createConnection(import_node8.ProposedFeatures.all);
   }
 }
 function map_public_settings(raw, log_warning) {
@@ -69913,7 +70307,7 @@ function indexing_affecting_signature(config) {
 async function create_server(options) {
   const { transport, quiet, log_channel } = options;
   const connection = create_transport_connection(transport);
-  const documents = new import_node5.TextDocuments(TextDocument);
+  const documents = new import_node8.TextDocuments(TextDocument);
   const document_store = new DocumentStore;
   const debounce_manager = new DocumentDebounceManager;
   let diagnostics_provider = null;
@@ -69990,7 +70384,7 @@ async function create_server(options) {
       for (const my_pattern of [PROJECT_CONFIG_FILE, STALE_JSON_CONFIG_FILE]) {
         watchers.push({
           globPattern: { baseUri, pattern: my_pattern },
-          kind: import_node5.WatchKind.Create | import_node5.WatchKind.Change | import_node5.WatchKind.Delete
+          kind: import_node8.WatchKind.Create | import_node8.WatchKind.Change | import_node8.WatchKind.Delete
         });
       }
     }
@@ -70005,7 +70399,7 @@ async function create_server(options) {
     if (watchers.length === 0) {
       project_config_watch_registration = undefined;
     } else {
-      project_config_watch_registration = await connection.client.register(import_node5.DidChangeWatchedFilesNotification.type, { watchers });
+      project_config_watch_registration = await connection.client.register(import_node8.DidChangeWatchedFilesNotification.type, { watchers });
     }
     previous_registration?.dispose();
   }
@@ -70561,7 +70955,7 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
       }
     });
     if (server_capabilities.has_configuration_capability) {
-      connection.client.register(import_node5.DidChangeConfigurationNotification.type, undefined);
+      connection.client.register(import_node8.DidChangeConfigurationNotification.type, undefined);
     }
     if (server_capabilities.has_workspace_folder_capability) {
       connection.workspace.onDidChangeWorkspaceFolders(async (_event) => {
@@ -70681,7 +71075,7 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
   documents.listen(connection);
   connection.listen();
 }
-var import_node5, embedded_cache;
+var import_node8, embedded_cache;
 var init_server_factory = __esm(() => {
   init_main();
   init_document_store();
@@ -70707,7 +71101,7 @@ var init_server_factory = __esm(() => {
   init_stata_install_paths();
   init_v18();
   init_server_handlers();
-  import_node5 = __toESM(require_main4(), 1);
+  import_node8 = __toESM(require_main4(), 1);
   embedded_cache = v18_default;
 });
 
@@ -70899,4 +71293,4 @@ export {
   is_cli_entry_point
 };
 
-//# debugId=A1927913CBC66B5464756E2164756E21
+//# debugId=6FDB62323EDE1B8464756E2164756E21

package/dist/sight-server.js.sha256

@@ -1 +1 @@
-ba04e86fe7a6ff3104e6dcc4fd46966bd59d1b2d47c0dcf2c505ecd6789bfae1  sight-server.js
+4bf15e7be7e980d82d2126fba5074822b8d22cc4aeb9b9c5a51db7409db926bc  sight-server.js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbearak/sight",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "type": "module",
   "workspaces": [
     "client"