feat(router/draw): Try to add canes before trying to squeeze them through

src/drawing/drawing.rs

@@ -258,9 +258,12 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
                 LooseIndex::Bend(bend) => {
                     bends.push(bend);
 
+                    let bend_primitive = self.primitive(bend);
+                    let inner = bend_primitive.inner();
+
                     for outer in self.primitive(bend).outers().collect::<Vec<_>>() {
                         outers.push(outer);
-                        self.reattach_bend(recorder, outer, self.primitive(bend).inner());
+                        self.reattach_bend(recorder, outer, inner);
                     }
                 }
             }

src/layout/layout.rs

@@ -73,7 +73,27 @@ impl<R> Layout<R> {
 }
 
 impl<R: AccessRules> Layout<R> {
-    /// Insert [`Cane`] object into the [`Layout`]
+    pub fn add_cane(
+        &mut self,
+        recorder: &mut LayoutEdit,
+        from: DotIndex,
+        around: GearIndex,
+        dot_weight: LooseDotWeight,
+        seg_weight: SeqLooseSegWeight,
+        bend_weight: LooseBendWeight,
+        sense: RotationSense,
+    ) -> Result<Cane, DrawingException> {
+        self.drawing.add_cane(
+            recorder,
+            from,
+            around,
+            dot_weight,
+            seg_weight,
+            bend_weight,
+            sense,
+        )
+    }
+
     pub fn insert_cane(
         &mut self,
         recorder: &mut LayoutEdit,

src/router/draw.rs

@@ -288,31 +288,53 @@ impl<R: AccessRules> DrawPrivate for Layout<R> {
     ) -> Result<CaneHead, DrawingException> {
         let layer = head.face().primitive(self.drawing()).layer();
         let maybe_net = head.face().primitive(self.drawing()).maybe_net();
-        let cane = self.insert_cane(
+
+        let dot_weight = LooseDotWeight(GeneralDotWeight {
+            circle: Circle {
+                pos: to,
+                r: width / 2.0,
+            },
+            layer,
+            maybe_net,
+        });
+        let seg_weight = SeqLooseSegWeight(GeneralSegWeight {
+            width,
+            layer,
+            maybe_net,
+        });
+        let bend_weight = LooseBendWeight(GeneralBendWeight {
+            width,
+            offset,
+            layer,
+            maybe_net,
+        });
+
+        // We first try to add cane. If this fails, we try to insert it instead.
+        // These two operations differ simply: cane insertion squeezes through
+        // under bends, cane addition does not.
+
+        let cane = if let Ok(cane) = self.add_cane(
             recorder,
             head.face(),
             around,
-            LooseDotWeight(GeneralDotWeight {
+            dot_weight,
-                circle: Circle {
+            seg_weight,
-                    pos: to,
+            bend_weight,
-                    r: width / 2.0,
-                },
-                layer,
-                maybe_net,
-            }),
-            SeqLooseSegWeight(GeneralSegWeight {
-                width,
-                layer,
-                maybe_net,
-            }),
-            LooseBendWeight(GeneralBendWeight {
-                width,
-                offset,
-                layer,
-                maybe_net,
-            }),
             sense,
-        )?;
+        ) {
+            cane
+        } else {
+            self.insert_cane(
+                recorder,
+                head.face(),
+                around,
+                dot_weight,
+                seg_weight,
+                bend_weight,
+                sense,
+            )?
+        };
+
         Ok(CaneHead {
             face: self.drawing().primitive(cane.bend).other_joint(cane.dot),
             cane,