dbml_language_server/analysis/

semantic.rs

// src/analysis/semantic.rs
use crate::ast::*;
use lsp_types::{Diagnostic, DiagnosticSeverity, Position, Range};
use std::collections::HashMap;

#[derive(Debug, Clone)]
#[allow(dead_code)]
pub struct SymbolInfo {
    pub name: String,
    pub kind: SymbolKind,
    pub span: Span,
}

#[derive(Debug, Clone, PartialEq)]
#[allow(dead_code)]
pub enum SymbolKind {
    Table,
    Column,
    Enum,
    EnumMember,
}

#[derive(Debug, Clone)]
pub struct SemanticError {
    pub message: String,
    pub span: Span,
}

#[derive(Debug)]
pub struct SemanticModel {
    pub tables: HashMap<String, SymbolInfo>,
    pub columns: HashMap<String, Vec<SymbolInfo>>, // table_name -> columns
    pub enums: HashMap<String, SymbolInfo>,
    pub errors: Vec<SemanticError>,
}

impl SemanticModel {
    pub fn new() -> Self {
        Self {
            tables: HashMap::new(),
            columns: HashMap::new(),
            enums: HashMap::new(),
            errors: Vec::new(),
        }
    }

    pub fn analyze(document: &Document) -> Self {
        let mut model = Self::new();

        // Pass 1: Collect all definitions
        for item in &document.items {
            match item {
                DocumentItem::Table(table) => {
                    model.analyze_table(table);
                }
                DocumentItem::Enum(enum_def) => {
                    model.analyze_enum(enum_def);
                }
                DocumentItem::Ref(ref_def) => {
                    model.validate_ref(ref_def);
                }
                DocumentItem::Project(_) => {}
            }
        }

        model
    }

    fn analyze_table(&mut self, table: &Table) {
        let table_name = table.name.name.clone();

        // Check for duplicate table
        if self.tables.contains_key(&table_name) {
            self.errors.push(SemanticError {
                message: format!("Duplicate table definition: '{}'", table_name),
                span: table.name.span.clone(),
            });
        } else {
            self.tables.insert(
                table_name.clone(),
                SymbolInfo {
                    name: table_name.clone(),
                    kind: SymbolKind::Table,
                    span: table.name.span.clone(),
                },
            );
        }

        // Analyze columns
        let mut column_names = Vec::new();
        for item in &table.items {
            if let TableItem::Column(col) = item {
                let col_name = col.name.name.clone();

                // Check for duplicate column
                if column_names.iter().any(|c: &SymbolInfo| c.name == col_name) {
                    self.errors.push(SemanticError {
                        message: format!(
                            "Duplicate column '{}' in table '{}'",
                            col_name, table_name
                        ),
                        span: col.name.span.clone(),
                    });
                } else {
                    column_names.push(SymbolInfo {
                        name: col_name.clone(),
                        kind: SymbolKind::Column,
                        span: col.name.span.clone(),
                    });
                }

                // Validate column settings
                for setting in &col.settings {
                    if let ColumnSetting::Ref(inline_ref) = setting {
                        self.validate_inline_ref(inline_ref, &table_name);
                    }
                }
            }
        }

        self.columns.insert(table_name, column_names);
    }

    fn analyze_enum(&mut self, enum_def: &Enum) {
        let enum_name = enum_def.name.name.clone();

        if self.enums.contains_key(&enum_name) {
            self.errors.push(SemanticError {
                message: format!("Duplicate enum definition: '{}'", enum_name),
                span: enum_def.name.span.clone(),
            });
        } else {
            self.enums.insert(
                enum_name.clone(),
                SymbolInfo {
                    name: enum_name,
                    kind: SymbolKind::Enum,
                    span: enum_def.name.span.clone(),
                },
            );
        }
    }

    fn validate_ref(&mut self, ref_def: &Ref) {
        let from_table = &ref_def.from_table.name;
        let to_table = &ref_def.to_table.name;

        // Check if tables exist
        if !self.tables.contains_key(from_table) {
            self.errors.push(SemanticError {
                message: format!("Table '{}' not found", from_table),
                span: ref_def.from_table.span.clone(),
            });
        }

        if !self.tables.contains_key(to_table) {
            self.errors.push(SemanticError {
                message: format!("Table '{}' not found", to_table),
                span: ref_def.to_table.span.clone(),
            });
        }

        // Validate columns exist in their respective tables
        for col in &ref_def.from_columns {
            if let Some(columns) = self.columns.get(from_table) {
                if !columns.iter().any(|c| c.name == col.name) {
                    self.errors.push(SemanticError {
                        message: format!(
                            "Column '{}' not found in table '{}'",
                            col.name, from_table
                        ),
                        span: col.span.clone(),
                    });
                }
            }
        }

        for col in &ref_def.to_columns {
            if let Some(columns) = self.columns.get(to_table) {
                if !columns.iter().any(|c| c.name == col.name) {
                    self.errors.push(SemanticError {
                        message: format!("Column '{}' not found in table '{}'", col.name, to_table),
                        span: col.span.clone(),
                    });
                }
            }
        }
    }

    fn validate_inline_ref(&mut self, inline_ref: &InlineRef, _current_table: &str) {
        let target_table = &inline_ref.target_table.name;

        if !self.tables.contains_key(target_table) {
            self.errors.push(SemanticError {
                message: format!("Referenced table '{}' not found", target_table),
                span: inline_ref.target_table.span.clone(),
            });
        }
    }

    pub fn find_symbol_at_position(&self, pos: usize) -> Option<&SymbolInfo> {
        // Search in tables
        for symbol in self.tables.values() {
            if symbol.span.contains(&pos) {
                return Some(symbol);
            }
        }

        // Search in columns
        for columns in self.columns.values() {
            for symbol in columns {
                if symbol.span.contains(&pos) {
                    return Some(symbol);
                }
            }
        }

        // Search in enums
        for symbol in self.enums.values() {
            if symbol.span.contains(&pos) {
                return Some(symbol);
            }
        }

        None
    }

    pub fn to_diagnostics(&self, content: &str) -> Vec<Diagnostic> {
        self.errors
            .iter()
            .map(|err| {
                let range = span_to_range(&err.span, content);
                Diagnostic {
                    range,
                    severity: Some(DiagnosticSeverity::ERROR),
                    code: None,
                    code_description: None,
                    source: Some("dbml-lsp".to_string()),
                    message: err.message.clone(),
                    related_information: None,
                    tags: None,
                    data: None,
                }
            })
            .collect()
    }
}

fn span_to_range(span: &Span, content: &str) -> Range {
    let start_pos = offset_to_position(span.start, content);
    let end_pos = offset_to_position(span.end, content);
    Range::new(start_pos, end_pos)
}

fn offset_to_position(offset: usize, content: &str) -> Position {
    let mut line = 0;
    let mut col = 0;

    for (i, ch) in content.chars().enumerate() {
        if i >= offset {
            break;
        }
        if ch == '\n' {
            line += 1;
            col = 0;
        } else {
            col += 1;
        }
    }

    Position::new(line, col)
}