Adom Library

@@ -2483,7 +2483,8 @@ pub(crate) fn lint_lbr(content: &str) -> LintResult {         struct P { name: String, x: f64, y: f64, hx: f64, hy: f64, round: bool }         let num = |s: &str| s.parse::<f64>().unwrap_or(0.0);         let rot90 = |r: Option<&str>| matches!(r, Some("R90") | Some("R270"));-        let mut bad: Vec<String> = Vec::new();+        let mut overlaps: Vec<String> = Vec::new();+        let mut close: Vec<String> = Vec::new();         let pkg_re = regex_lite::Regex::new(r#"(?s)<package name="([^"]*)">(.*?)</package>"#).unwrap();         // Match the whole element, then read each attribute from it. An optional (?:rot=...)?         // group followed by a greedy [^>]* silently matches EMPTY and lets the tail eat the@@ -2536,21 +2537,37 @@ pub(crate) fn lint_lbr(content: &str) -> LintResult {                     } else {                         gx.max(gy)                     };-                    if gap < 0.2 {-                        bad.push(if gap < 0.0 {-                            format!("{} pads {} and {} OVERLAP by {:.3} mm", pkg, a.name, b.name, -gap)-                        } else {-                            format!("{} pads {} and {} are {:.3} mm apart", pkg, a.name, b.name, gap)-                        });+                    // True copper OVERLAP is a short and stays a hard error. A small+                    // POSITIVE gap is what fine-pitch land patterns look like by+                    // construction (a 0.5 mm-pitch SOT-563 has 0.150 mm between pads in+                    // KiCad's own library), so it warns instead of failing: a flat 0.2 mm+                    // ERROR rejected 559 of 1314 stock KiCad footprints (wiki #20), each+                    // one a part silently dropped from the factory worklist. The epsilon+                    // keeps a gap of exactly the threshold clean: 1.2 - 1.0 is+                    // 0.19999999999999996 in floats, and a message that says "closer than+                    // 0.2 mm" must not reject a pair that is "0.200 mm apart".+                    const EPS: f64 = 1e-4;+                    if gap < -EPS {+                        overlaps.push(format!("{} pads {} and {} OVERLAP by {:.3} mm", pkg, a.name, b.name, -gap));+                    } else if gap < 0.2 - EPS {+                        close.push(format!("{} pads {} and {} are {:.3} mm apart", pkg, a.name, b.name, gap));                     }                 }             }         }-        if !bad.is_empty() {+        if !overlaps.is_empty() {             errors.push(LintError {                 code: "pad-clearance".into(),-                message: format!("copper closer than 0.2 mm: {}. A pad mapping that grows into its neighbour is a short.",-                                 bad.join("; ")),+                message: format!("copper OVERLAPS: {}. A pad mapping that grows into its neighbour is a short.",+                                 overlaps.join("; ")),+            });+        }+        if !close.is_empty() {+            warnings.push(LintError {+                code: "pad-clearance".into(),+                message: format!("copper closer than 0.2 mm: {}. Fine-pitch land patterns sit here by construction; \+check the source footprint intends it rather than a mapping having grown a pad.",+                                 close.join("; ")),             });         }     }@@ -4051,6 +4068,38 @@ mod lint_tests {         assert!(!lint_lbr(&vias).errors.iter().any(|e| e.code == "pad-clearance"));     } +    #[test]+    fn fine_pitch_gaps_warn_instead_of_failing_and_the_exact_boundary_passes_clean() {+        // wiki #20: a flat 0.2 mm ERROR rejected 559 of 1314 stock KiCad footprints,+        // and 225 of them sat at exactly 0.200 mm because of float representation.+        use super::lint_lbr;+        let lib = |pads: &str| format!(r#"<eagle><drawing><layers></layers><library>+            <packages><package name="P">{pads}</package></packages>+            <symbols><symbol name="S"><pin name="A" x="0" y="0" length="short"/></symbol></symbols>+            <devicesets><deviceset name="D"><gates><gate name="G$1" symbol="S" x="0" y="0"/></gates>+            <devices><device name="" package="P"><connects><connect gate="G$1" pin="A" pad="1"/></connects>+            <technologies><technology name=""/></technologies></device></devices></deviceset></devicesets>+            </library></drawing></eagle>"#);+        // a 0.5 mm-pitch SOT-563 row: 0.150 mm apart by construction. WARNING, never error.+        let fine = lib(r#"<smd name="1" x="0" y="0" dx="0.675" dy="0.35"/>+                          <smd name="2" x="0" y="0.5" dx="0.675" dy="0.35"/>"#);+        let r = lint_lbr(&fine);+        assert!(r.errors.iter().all(|e| e.code != "pad-clearance"), "fine pitch must not FAIL: {:?}", r.errors);+        assert!(r.warnings.iter().any(|w| w.code == "pad-clearance"), "but it should still WARN: {:?}", r.warnings);+        // exactly 0.200 mm apart: 1.0 mm rect pads at x -0.6 and 0.6 compute a gap of+        // 0.19999999999999996 in floats. The epsilon keeps the rule's own wording true:+        // "closer than 0.2 mm" cannot reject "0.200 mm apart". Clean, not even a warning.+        let boundary = lib(r#"<smd name="1" x="-0.6" y="0" dx="1.0" dy="1.0"/>+                              <smd name="2" x="0.6" y="0" dx="1.0" dy="1.0"/>"#);+        let rb = lint_lbr(&boundary);+        assert!(rb.errors.iter().all(|e| e.code != "pad-clearance"), "{:?}", rb.errors);+        assert!(rb.warnings.iter().all(|w| w.code != "pad-clearance"), "{:?}", rb.warnings);+        // negative control: genuinely overlapping copper is still a hard error.+        let overlap = lib(r#"<smd name="1" x="0" y="0" dx="1.2" dy="1.2"/>+                             <smd name="2" x="1.0" y="0" dx="1.2" dy="1.2"/>"#);+        assert!(lint_lbr(&overlap).errors.iter().any(|e| e.code == "pad-clearance"));+    }+     #[test]     fn roundrect_pads_carry_their_corner_radius_into_eagle() {         use super::parse_mod_pads;