[FEAT] style warnings (#354)

* add style warnings to LSP

* accept test

* accept test help

* cargo insta review.

* simpler functions

* fix unnecessary advice

* uppercase search sanitization

* update nets

Author: hexdae

Cargo.lock

@@ -56,6 +56,7 @@ env_logger = "0.11"
 indicatif = "0.17.8"
 inquire = "0.7"
 itertools = "0.13.0"
+heck = "0.5.0"
 log = "0.4"
 lru = "0.12"
 minijinja = "2.5"

Cargo.toml

@@ -855,20 +855,34 @@ fn sanitize_mpn_for_path(mpn: &str) -> String {
     }
 }
 
-/// Sanitize a pin name to create a valid Starlark identifier
+/// Sanitize a pin name to create a valid Starlark identifier.
+/// Output follows UPPERCASE convention for io() parameters.
+///
+/// Special handling:
+/// - `~` or `!` at start: becomes `N_` prefix (e.g., `~CS` → `N_CS`)
+/// - `+` at end: becomes `_POS` suffix (e.g., `V+` → `V_POS`)
+/// - `-` at end: becomes `_NEG` suffix (e.g., `V-` → `V_NEG`)
+/// - `+` or `-` elsewhere: becomes `_` (e.g., `A+B` → `A_B`)
+/// - `#`: becomes `H` (e.g., `CS#` → `CSH`)
+/// - All alphanumeric chars: uppercased
 fn sanitize(name: &str) -> String {
-    let result = name
-        .chars()
-        .map(|c| match c {
-            '+' => 'P', // Plus becomes P (e.g., V+ → VP)
-            '-' => 'M', // Minus becomes M (e.g., V- → VM)
-            '~' => 'n', // Tilde (NOT) becomes n (e.g., ~CS → nCS)
-            '!' => 'n', // Bang (NOT) also becomes n
-            '#' => 'h', // Hash becomes h (e.g., CS# → CSh)
-            c if c.is_alphanumeric() => c,
-            _ => '_',
-        })
-        .collect::<String>();
+    let chars: Vec<char> = name.chars().collect();
+    let len = chars.len();
+    let mut result = String::with_capacity(len + 8);
+
+    for (i, &c) in chars.iter().enumerate() {
+        let is_last = i == len - 1;
+
+        match c {
+            '+' if is_last => result.push_str("_POS"),
+            '-' if is_last => result.push_str("_NEG"),
+            '+' | '-' => result.push('_'),
+            '~' | '!' => result.push_str("N_"), // NOT prefix
+            '#' => result.push('H'),
+            c if c.is_alphanumeric() => result.push(c.to_ascii_uppercase()),
+            _ => result.push('_'),
+        }
+    }
 
     // Remove consecutive underscores and trim underscores from start/end
     let sanitized = result
@@ -1835,4 +1849,71 @@ mod tests {
 
         insta::assert_snapshot!(result);
     }
+
+    #[test]
+    fn test_sanitize_pin_name_basic() {
+        // Basic alphanumeric names get uppercased
+        assert_eq!(sanitize("VCC"), "VCC");
+        assert_eq!(sanitize("gnd"), "GND");
+        assert_eq!(sanitize("GPIO1"), "GPIO1");
+        assert_eq!(sanitize("sda"), "SDA");
+    }
+
+    #[test]
+    fn test_sanitize_pin_name_plus_minus_at_end() {
+        // + and - at end become _POS and _NEG
+        assert_eq!(sanitize("V+"), "V_POS");
+        assert_eq!(sanitize("V-"), "V_NEG");
+        assert_eq!(sanitize("IN+"), "IN_POS");
+        assert_eq!(sanitize("OUT-"), "OUT_NEG");
+        assert_eq!(sanitize("VCC+"), "VCC_POS");
+    }
+
+    #[test]
+    fn test_sanitize_pin_name_plus_minus_in_middle() {
+        // + and - in middle become underscores
+        assert_eq!(sanitize("A+B"), "A_B");
+        assert_eq!(sanitize("IN-OUT"), "IN_OUT");
+        assert_eq!(sanitize("V+REF"), "V_REF");
+    }
+
+    #[test]
+    fn test_sanitize_pin_name_not_prefix() {
+        // ~ and ! at start become N_ prefix
+        assert_eq!(sanitize("~CS"), "N_CS");
+        assert_eq!(sanitize("!RESET"), "N_RESET");
+        assert_eq!(sanitize("~WR"), "N_WR");
+        assert_eq!(sanitize("!OE"), "N_OE");
+    }
+
+    #[test]
+    fn test_sanitize_pin_name_hash_suffix() {
+        // # becomes H
+        assert_eq!(sanitize("CS#"), "CSH");
+        assert_eq!(sanitize("WE#"), "WEH");
+    }
+
+    #[test]
+    fn test_sanitize_pin_name_special_chars() {
+        // Other special chars become underscores
+        assert_eq!(sanitize("PIN/A"), "PIN_A");
+        assert_eq!(sanitize("PIN.B"), "PIN_B");
+        assert_eq!(sanitize("PIN A"), "PIN_A");
+    }
+
+    #[test]
+    fn test_sanitize_pin_name_leading_digit() {
+        // Leading digit gets P prefix
+        assert_eq!(sanitize("1"), "P1");
+        assert_eq!(sanitize("1A"), "P1A");
+        assert_eq!(sanitize("123"), "P123");
+    }
+
+    #[test]
+    fn test_sanitize_pin_name_consecutive_underscores() {
+        // Consecutive underscores get collapsed
+        assert_eq!(sanitize("A__B"), "A_B");
+        assert_eq!(sanitize("A___B"), "A_B");
+        assert_eq!(sanitize("_A_"), "A");
+    }
 }

crates/pcb-diode-api/src/component.rs

@@ -29,6 +29,7 @@ debugserver-types = { workspace = true }
 either = { workspace = true }
 globset = { workspace = true }
 itertools = { workspace = true }
+heck = { workspace = true }
 lru = { workspace = true }
 lsp-types = { workspace = true }
 serde = { workspace = true }

crates/pcb-zen-core/Cargo.toml

@@ -23,5 +23,8 @@ pub(crate) mod file;
 // Add public error module and Result alias
 pub mod error;
 
+// Naming convention checks
+pub mod naming;
+
 // Validation utilities
 pub(crate) mod validation;

crates/pcb-zen-core/src/lang/mod.rs

@@ -31,6 +31,7 @@ use crate::lang::evaluator_ext::EvaluatorExt;
 use crate::lang::interface::{
     FrozenInterfaceFactory, FrozenInterfaceValue, InterfaceFactory, InterfaceValue,
 };
+use crate::lang::naming;
 use crate::lang::validation::validate_identifier_name;
 use regex::Regex;
 use starlark::codemap::{CodeMap, Pos, Span};
@@ -1700,6 +1701,15 @@ pub fn module_globals(builder: &mut GlobalsBuilder) {
             );
         }
 
+        // Check naming convention (io parameters should be UPPERCASE)
+        let (path, span) = eval
+            .call_stack_top_location()
+            .map(|loc| (loc.file.filename().to_string(), Some(loc.resolve_span())))
+            .unwrap_or_else(|| (eval.source_path().unwrap_or_default(), None));
+        if let Some(diag) = naming::check_io_naming(&name, span, Path::new(&path)) {
+            eval.add_diagnostic(diag);
+        }
+
         Ok(result_value)
     }
 
@@ -1764,6 +1774,15 @@ pub fn module_globals(builder: &mut GlobalsBuilder) {
             );
         }
 
+        // Check naming convention (config parameters should be snake_case)
+        let (path, span) = eval
+            .call_stack_top_location()
+            .map(|loc| (loc.file.filename().to_string(), Some(loc.resolve_span())))
+            .unwrap_or_else(|| (eval.source_path().unwrap_or_default(), None));
+        if let Some(diag) = naming::check_config_naming(&name, span, Path::new(&path)) {
+            eval.add_diagnostic(diag);
+        }
+
         Ok(result_value)
     }