Merge pull request #117 from ucb-substrate/compiler_debug_info

feat(compiler): add span to inconsistent constraints

Author: CONnor9029

README.md

@@ -58,7 +58,7 @@ vim.cmd([[autocmd BufRead,BufNewFile *.ar setfiletype argon]])
 To open an example Argon workspace, run the following from the root directory of your Argon clone:
 
 ```
-vim pdks/sky130/lib.ar
+nvim pdks/sky130/lib.ar
 ```
 
 Start the GUI by running `:Argon gui`.

core/compiler/src/compile.rs

@@ -1873,6 +1873,7 @@ struct ExecScope {
 struct FallbackConstraint {
     priority: i32,
     constraint: LinearExpr,
+    span: Span,
 }
 
 impl PartialEq for FallbackConstraint {
@@ -1908,6 +1909,7 @@ struct CellState {
     fallback_constraints: BinaryHeap<FallbackConstraint>,
     fallback_constraints_used: Vec<LinearExpr>,
     unsolved_vars: Option<IndexSet<Var>>,
+    constraint_span_map: IndexMap<ConstraintId, Span>,
 }
 
 struct ExecPass<'a> {
@@ -2138,6 +2140,7 @@ impl<'a> ExecPass<'a> {
                         root_scope: root_scope_id,
                         unsolved_vars: Default::default(),
                         objects: Default::default(),
+                        constraint_span_map: IndexMap::new(),
                     }
                 )
                 .is_none()
@@ -2218,16 +2221,18 @@ impl<'a> ExecPass<'a> {
                 }
                 let mut constraint_added = false;
                 let state = self.cell_state_mut(cell_id);
-                while let Some(FallbackConstraint { constraint, .. }) =
-                    state.fallback_constraints.pop()
+                while let Some(FallbackConstraint {
+                    constraint, span, ..
+                }) = state.fallback_constraints.pop()
                 {
                     if constraint
                         .coeffs
                         .iter()
                         .any(|(c, v)| c.abs() > 1e-6 && !state.solver.is_solved(*v))
                     {
                         state.fallback_constraints_used.push(constraint.clone());
-                        state.solver.constrain_eq0(constraint);
+                        let constraint_id = state.solver.constrain_eq0(constraint);
+                        state.constraint_span_map.insert(constraint_id, span);
                         constraint_added = true;
                         break;
                     }
@@ -2246,18 +2251,25 @@ impl<'a> ExecPass<'a> {
                 require_progress = true;
             }
         }
+
         let state = self.cell_state_mut(cell_id);
         if progress {
             state.solve_iters += 1;
             state.solver.solve();
         }
         for constraint in state.solver.inconsistent_constraints().clone() {
+            let span = self
+                .cell_state(cell_id)
+                .constraint_span_map
+                .get(&constraint)
+                .cloned();
             self.errors.push(ExecError {
-                span: None,
+                span,
                 cell: cell_id,
                 kind: ExecErrorKind::InconsistentConstraint(constraint),
             });
         }
+
         self.partial_cells
             .pop_back()
             .expect("failed to pop cell id");
@@ -2897,6 +2909,7 @@ impl<'a> ExecPass<'a> {
                                 }
                                 x => unreachable!("unsupported kwarg `{x}`"),
                             };
+                            let span = self.span(&vref.loc, kwarg.span);
                             let defer = self.value_id();
                             self.values.insert(
                                 defer,
@@ -2906,6 +2919,7 @@ impl<'a> ExecPass<'a> {
                                         rhs: *rhs,
                                         fallback: kwarg.name.name.ends_with('i'),
                                         priority,
+                                        span,
                                     }),
                                     loc: vref.loc,
                                 }),
@@ -3038,7 +3052,15 @@ impl<'a> ExecPass<'a> {
                     ) {
                         let expr = vl.as_ref().unwrap_linear().clone()
                             - vr.as_ref().unwrap_linear().clone();
-                        state.solver.constrain_eq0(expr);
+                        let constraint = state.solver.constrain_eq0(expr);
+
+                        state.constraint_span_map.insert(
+                            constraint,
+                            Span {
+                                path: state.scopes[&vref.loc.scope].span.path.clone(),
+                                span: c.expr.span,
+                            },
+                        );
                         self.values.insert(vid, Defer::Ready(Value::Nil));
                         true
                     } else {
@@ -3123,6 +3145,7 @@ impl<'a> ExecPass<'a> {
                             constraint,
                             span: Some(span.clone()),
                         };
+                        state.constraint_span_map.insert(constraint, span.clone());
                         state.object_emit.push(ObjectEmit {
                             scope: vref.loc.scope,
                             object: dim.id,
@@ -3253,6 +3276,7 @@ impl<'a> ExecPass<'a> {
                                 }
                                 _ => continue,
                             };
+                            let span = self.span(&vref.loc, kwarg.span);
                             let defer = self.value_id();
                             self.values.insert(
                                 defer,
@@ -3262,6 +3286,7 @@ impl<'a> ExecPass<'a> {
                                         rhs: *rhs,
                                         fallback: kwarg.name.name.ends_with('i'),
                                         priority,
+                                        span,
                                     }),
                                     loc: vref.loc,
                                 }),
@@ -3693,9 +3718,11 @@ impl<'a> ExecPass<'a> {
                         state.fallback_constraints.push(FallbackConstraint {
                             priority: c.priority,
                             constraint: expr,
+                            span: c.span.clone(),
                         });
                     } else {
-                        state.solver.constrain_eq0(expr);
+                        let constraint = state.solver.constrain_eq0(expr);
+                        state.constraint_span_map.insert(constraint, c.span.clone());
                     }
                     self.values.insert(vid, DeferValue::Ready(Value::Nil));
                     true
@@ -4268,6 +4295,7 @@ struct PartialConstraint {
     rhs: ValueId,
     fallback: bool,
     priority: i32,
+    span: Span,
 }
 
 #[derive(Debug, Clone)]

core/lang-server/src/lib.rs

@@ -134,7 +134,7 @@ impl StateMut {
                 .unwrap_or_else(|| {
                     PathBuf::from(concat!(
                         env!("CARGO_MANIFEST_DIR"),
-                        "/../../core/compiler/examples/lyp/basic.lyp"
+                        "/../../pdks/sky130/sky130.lyp"
                     ))
                 });
             let parse_output = parse::parse_workspace_with_std(root_dir.join("lib.ar"));