feat(lsp): add conditional directive awareness for ifdef/ifndef

Gray out inactive ifdef/ifndef branches based on defined document
attributes, similar to how C/C++ editors gray out #ifdef inactive code.

- Extract conditional blocks from raw text (following extract_includes pattern)
- Add "disabled" semantic token modifier for inactive content
- Emit DiagnosticTag::Unnecessary hints for universal editor graying
- Highlight directive lines (ifdef/ifndef/endif) as keywords
- Support both block form and single-line form
- Handle OR (,) and AND (+) multi-attribute operations

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: nlopes

acdc-lsp/CHANGELOG.md

@@ -9,6 +9,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Conditional directive awareness** — `ifdef`/`ifndef` blocks are now detected
+  and inactive branches are grayed out based on defined document attributes.
+  Uses semantic tokens with a custom "disabled" modifier and `DiagnosticTag::Unnecessary`
+  for universal editor support. Conditional directive lines are highlighted as keywords.
 - **Include path completion** — filesystem traversal completion for `include::`
   directives. Suggests files and directories as the user types the path, with
   AsciiDoc files prioritized. Selecting a directory re-triggers completion for

acdc-lsp/src/backend.rs

@@ -417,7 +417,11 @@ impl LanguageServer for Backend {
 
         let response = if let Some(doc) = self.workspace.get_document(&uri) {
             doc.ast.as_ref().map(|ast| {
-                SemanticTokensResult::Tokens(semantic_tokens::compute_semantic_tokens(ast))
+                SemanticTokensResult::Tokens(semantic_tokens::compute_semantic_tokens(
+                    ast,
+                    &doc.conditionals,
+                    &doc.text,
+                ))
             })
         } else {
             None

acdc-lsp/src/capabilities/diagnostics.rs

@@ -10,7 +10,9 @@ use std::hash::BuildHasher;
 use std::path::Path;
 
 use acdc_parser::{Error, Location, Positioning, Source};
-use tower_lsp::lsp_types::{Diagnostic, DiagnosticSeverity, Range};
+use tower_lsp::lsp_types::{Diagnostic, DiagnosticSeverity, DiagnosticTag, Range};
+
+use crate::state::{ConditionalBlock, ConditionalDirectiveKind, ConditionalOperation};
 
 use crate::convert::{location_to_range, parser_position_to_lsp};
 use crate::state::XrefTarget;
@@ -180,6 +182,59 @@ pub fn compute_link_diagnostics(
     diagnostics
 }
 
+/// Compute diagnostics for inactive conditional blocks.
+///
+/// Emits HINT-level diagnostics with `DiagnosticTag::UNNECESSARY` for content
+/// inside inactive ifdef/ifndef blocks. This causes editors to render the
+/// content with reduced opacity (grayed out).
+#[must_use]
+pub fn compute_conditional_diagnostics(conditionals: &[ConditionalBlock]) -> Vec<Diagnostic> {
+    let mut diagnostics = Vec::new();
+
+    for cond in conditionals {
+        if cond.is_active {
+            continue;
+        }
+
+        let Some(end_line) = cond.end_line else {
+            continue;
+        };
+
+        let directive = match cond.kind {
+            ConditionalDirectiveKind::Ifdef => "ifdef",
+            ConditionalDirectiveKind::Ifndef => "ifndef",
+        };
+        let separator = match cond.operation {
+            Some(ConditionalOperation::Or) => ",",
+            _ => "+",
+        };
+        let attrs = cond.attributes.join(separator);
+
+        let start_line: u32 = cond.start_line.try_into().unwrap_or(u32::MAX);
+        let end_line_u32: u32 = end_line.try_into().unwrap_or(u32::MAX);
+
+        diagnostics.push(Diagnostic {
+            range: Range {
+                start: tower_lsp::lsp_types::Position {
+                    line: start_line,
+                    character: 0,
+                },
+                end: tower_lsp::lsp_types::Position {
+                    line: end_line_u32,
+                    character: u32::MAX,
+                },
+            },
+            severity: Some(DiagnosticSeverity::HINT),
+            source: Some("acdc".to_string()),
+            message: format!("Inactive conditional block ({directive}::{attrs})"),
+            tags: Some(vec![DiagnosticTag::UNNECESSARY]),
+            ..Default::default()
+        });
+    }
+
+    diagnostics
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -393,4 +448,41 @@ mod tests {
         let diags = compute_link_diagnostics(&[], &includes, &tmp, None);
         assert!(diags.is_empty());
     }
+
+    #[test]
+    fn test_conditional_inactive_diagnostic() -> Result<(), Box<dyn std::error::Error>> {
+        let conditionals = vec![ConditionalBlock {
+            kind: ConditionalDirectiveKind::Ifdef,
+            attributes: vec!["missing-attr".to_string()],
+            operation: None,
+            is_active: false,
+            start_line: 2,
+            end_line: Some(4),
+        }];
+
+        let diags = compute_conditional_diagnostics(&conditionals);
+        assert_eq!(diags.len(), 1);
+        let d = diags.first().ok_or("expected one diagnostic")?;
+        assert_eq!(d.severity, Some(DiagnosticSeverity::HINT));
+        assert!(d.message.contains("ifdef::missing-attr"));
+        assert_eq!(d.tags, Some(vec![DiagnosticTag::UNNECESSARY]));
+        assert_eq!(d.range.start.line, 2);
+        assert_eq!(d.range.end.line, 4);
+        Ok(())
+    }
+
+    #[test]
+    fn test_conditional_active_no_diagnostic() {
+        let conditionals = vec![ConditionalBlock {
+            kind: ConditionalDirectiveKind::Ifdef,
+            attributes: vec!["present".to_string()],
+            operation: None,
+            is_active: true,
+            start_line: 0,
+            end_line: Some(2),
+        }];
+
+        let diags = compute_conditional_diagnostics(&conditionals);
+        assert!(diags.is_empty());
+    }
 }

acdc-lsp/src/capabilities/formatting.rs

@@ -766,6 +766,7 @@ mod tests {
             attribute_refs: vec![],
             attribute_defs: vec![],
             media_sources: vec![],
+            conditionals: vec![],
         };
 
         let options = make_options();

acdc-lsp/src/capabilities/semantic_tokens.rs

@@ -17,6 +17,8 @@ use tower_lsp::lsp_types::{
     WorkDoneProgressOptions,
 };
 
+use crate::state::ConditionalBlock;
+
 /// Convert usize to u32 for LSP types, saturating at `u32::MAX`.
 fn to_lsp_u32(val: usize) -> u32 {
     val.try_into().unwrap_or(u32::MAX)
@@ -37,8 +39,9 @@ pub const TOKEN_TYPES: &[SemanticTokenType] = &[
 
 /// Semantic token modifiers
 pub const TOKEN_MODIFIERS: &[SemanticTokenModifier] = &[
-    SemanticTokenModifier::DECLARATION, // anchor definitions
-    SemanticTokenModifier::DEFINITION,  // section with ID
+    SemanticTokenModifier::DECLARATION,     // 0 - anchor definitions
+    SemanticTokenModifier::DEFINITION,      // 1 - section with ID
+    SemanticTokenModifier::new("disabled"), // 2 - inactive conditional content
 ];
 
 /// Create the semantic tokens legend for capability registration
@@ -70,12 +73,17 @@ struct RawToken {
     token_modifiers: u32,
 }
 
-/// Compute semantic tokens for a document
+/// Compute semantic tokens for a document, including conditional directive awareness.
 #[must_use]
-pub fn compute_semantic_tokens(doc: &Document) -> SemanticTokens {
+pub fn compute_semantic_tokens(
+    doc: &Document,
+    conditionals: &[ConditionalBlock],
+    text: &str,
+) -> SemanticTokens {
     let mut tokens: Vec<RawToken> = Vec::new();
 
     collect_tokens_from_blocks(&doc.blocks, &mut tokens);
+    collect_conditional_tokens(conditionals, text, &mut tokens);
 
     // Sort by position for delta encoding
     tokens.sort_by(|a, b| a.line.cmp(&b.line).then(a.start_char.cmp(&b.start_char)));
@@ -89,6 +97,63 @@ pub fn compute_semantic_tokens(doc: &Document) -> SemanticTokens {
     }
 }
 
+/// Emit semantic tokens for conditional directives and inactive content.
+fn collect_conditional_tokens(
+    conditionals: &[ConditionalBlock],
+    text: &str,
+    tokens: &mut Vec<RawToken>,
+) {
+    let lines: Vec<&str> = text.lines().collect();
+
+    for cond in conditionals {
+        // Directive line as KEYWORD
+        if let Some(line_text) = lines.get(cond.start_line)
+            && !line_text.is_empty()
+        {
+            tokens.push(RawToken {
+                line: to_lsp_u32(cond.start_line),
+                start_char: 0,
+                length: to_lsp_u32(line_text.len()),
+                token_type: 6, // KEYWORD
+                token_modifiers: 0,
+            });
+        }
+
+        // Endif line as KEYWORD
+        if let Some(endif_line) = cond.end_line
+            && let Some(line_text) = lines.get(endif_line)
+            && !line_text.is_empty()
+        {
+            tokens.push(RawToken {
+                line: to_lsp_u32(endif_line),
+                start_char: 0,
+                length: to_lsp_u32(line_text.len()),
+                token_type: 6, // KEYWORD
+                token_modifiers: 0,
+            });
+        }
+
+        // For inactive blocks, emit COMMENT + disabled modifier for content lines
+        if !cond.is_active
+            && let Some(end_line) = cond.end_line
+        {
+            for line_idx in (cond.start_line + 1)..end_line {
+                if let Some(line_text) = lines.get(line_idx)
+                    && !line_text.is_empty()
+                {
+                    tokens.push(RawToken {
+                        line: to_lsp_u32(line_idx),
+                        start_char: 0,
+                        length: to_lsp_u32(line_text.len()),
+                        token_type: 5,      // COMMENT
+                        token_modifiers: 4, // bit 2 = disabled
+                    });
+                }
+            }
+        }
+    }
+}
+
 fn collect_tokens_from_blocks(blocks: &[Block], tokens: &mut Vec<RawToken>) {
     for block in blocks {
         collect_tokens_from_block(block, tokens);
@@ -370,7 +435,7 @@ Some content.
         let options = Options::default();
         let doc = acdc_parser::parse(content, &options)?;
 
-        let tokens = compute_semantic_tokens(&doc);
+        let tokens = compute_semantic_tokens(&doc, &[], content);
         // Should have at least tokens for section titles
         assert!(!tokens.data.is_empty());
         Ok(())
@@ -388,7 +453,7 @@ See <<target>> for more.
         let options = Options::default();
         let doc = acdc_parser::parse(content, &options)?;
 
-        let tokens = compute_semantic_tokens(&doc);
+        let tokens = compute_semantic_tokens(&doc, &[], content);
         // Should have tokens for section, anchor, and xref
         assert!(tokens.data.len() >= 2);
         Ok(())
@@ -400,5 +465,121 @@ See <<target>> for more.
         assert!(legend.token_types.contains(&SemanticTokenType::NAMESPACE));
         assert!(legend.token_types.contains(&SemanticTokenType::FUNCTION));
         assert!(legend.token_types.contains(&SemanticTokenType::COMMENT));
+        assert_eq!(legend.token_modifiers.len(), 3);
+        assert_eq!(
+            legend.token_modifiers.get(2),
+            Some(&SemanticTokenModifier::new("disabled"))
+        );
+    }
+
+    #[test]
+    fn test_conditional_inactive_tokens() -> Result<(), acdc_parser::Error> {
+        use crate::state::{ConditionalBlock, ConditionalDirectiveKind};
+
+        let content = "ifdef::missing[]\ninactive content\nendif::[]";
+        let options = Options::default();
+        let doc = acdc_parser::parse(content, &options)?;
+
+        let conditionals = vec![ConditionalBlock {
+            kind: ConditionalDirectiveKind::Ifdef,
+            attributes: vec!["missing".to_string()],
+            operation: None,
+            is_active: false,
+            start_line: 0,
+            end_line: Some(2),
+        }];
+
+        let tokens = compute_semantic_tokens(&doc, &conditionals, content);
+        // Should have tokens: ifdef line (KEYWORD), inactive content (COMMENT+disabled), endif (KEYWORD)
+        assert!(tokens.data.len() >= 3);
+
+        // Reconstruct absolute positions from delta encoding
+        let mut abs_tokens = Vec::new();
+        let mut prev_line = 0u32;
+        let mut prev_start = 0u32;
+        for t in &tokens.data {
+            let line = prev_line + t.delta_line;
+            let start = if t.delta_line == 0 {
+                prev_start + t.delta_start
+            } else {
+                t.delta_start
+            };
+            abs_tokens.push((
+                line,
+                start,
+                t.length,
+                t.token_type,
+                t.token_modifiers_bitset,
+            ));
+            prev_line = line;
+            prev_start = start;
+        }
+
+        // Line 0: ifdef directive → KEYWORD (type 6)
+        assert!(
+            abs_tokens.iter().any(|t| t.0 == 0 && t.3 == 6),
+            "expected KEYWORD token on line 0"
+        );
+        // Line 1: inactive content → COMMENT (type 5) + disabled (bit 2 = 4)
+        assert!(
+            abs_tokens.iter().any(|t| t.0 == 1 && t.3 == 5 && t.4 == 4),
+            "expected COMMENT+disabled token on line 1"
+        );
+        // Line 2: endif → KEYWORD (type 6)
+        assert!(
+            abs_tokens.iter().any(|t| t.0 == 2 && t.3 == 6),
+            "expected KEYWORD token on line 2"
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_conditional_active_no_disabled_tokens() -> Result<(), acdc_parser::Error> {
+        use crate::state::{ConditionalBlock, ConditionalDirectiveKind};
+
+        let content = "ifdef::present[]\nactive content\nendif::[]";
+        let options = Options::default();
+        let doc = acdc_parser::parse(content, &options)?;
+
+        let conditionals = vec![ConditionalBlock {
+            kind: ConditionalDirectiveKind::Ifdef,
+            attributes: vec!["present".to_string()],
+            operation: None,
+            is_active: true,
+            start_line: 0,
+            end_line: Some(2),
+        }];
+
+        let tokens = compute_semantic_tokens(&doc, &conditionals, content);
+        // Active block: should have KEYWORD tokens for directives but NO disabled tokens
+        let mut abs_tokens = Vec::new();
+        let mut prev_line = 0u32;
+        let mut prev_start = 0u32;
+        for t in &tokens.data {
+            let line = prev_line + t.delta_line;
+            let start = if t.delta_line == 0 {
+                prev_start + t.delta_start
+            } else {
+                t.delta_start
+            };
+            abs_tokens.push((
+                line,
+                start,
+                t.length,
+                t.token_type,
+                t.token_modifiers_bitset,
+            ));
+            prev_line = line;
+            prev_start = start;
+        }
+
+        // No tokens should have the disabled modifier (bit 2 = 4)
+        assert!(
+            !abs_tokens.iter().any(|t| t.4 & 4 != 0),
+            "active block should have no disabled tokens"
+        );
+
+        Ok(())
     }
 }