Delete more dead code, add coverage markers

src/source.rs

@@ -25,11 +25,13 @@ pub type Inputs<'a> = [Doc<'a>];
 #[derive(Copy, Clone, Eq, Ord, PartialEq, PartialOrd)]
 pub struct DocId(pub u32);
 
+// coverage:off -- Only used in assertion failures, which should be uncovered.
 impl fmt::Debug for DocId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
     }
 }
+// coverage:on
 
 /// Marks a location in a source file by byte offset.
 ///
@@ -67,7 +69,9 @@ impl Span {
         // with a panic.
         assert!(
             end <= 0xffff_ffff_ffff,
-            "Document should not be larger than 262 TiB."
+            // coverage:off -- Error is not tested, I don't have such large disk.
+            "Document should not be larger than 262 TiB.",
+            // coverage:on
         );
         debug_assert!(end >= start);
         Span {
@@ -110,11 +114,6 @@ impl Span {
         Span::new(self.doc(), self.start() + n_trim, self.end())
     }
 
-    /// Keep at most the first `n` bytes of the span.
-    pub fn take(&self, n: usize) -> Span {
-        Span::new(self.doc(), self.start(), self.end().min(self.start() + n))
-    }
-
     /// Return a span that runs from self up to but not including `other`.
     pub fn until(&self, other: Span) -> Span {
         debug_assert_eq!(self.doc(), other.doc());

src/typecheck.rs

@@ -503,9 +503,11 @@ impl<'a> TypeChecker<'a> {
                     .check(expr_span)?
             }
 
-            Expr::CheckType { .. } | Expr::TypedFunction { .. } | Expr::SetLit { .. } | Expr::DictLit { .. } => panic!(
+            // coverage:off -- Arm should be unreachable.
+            Expr::CheckType { .. } | Expr::TypedFunction { .. } | Expr::SetLit { .. } | Expr::DictLit { .. } => unreachable!(
                 "Node {expr:?} is inserted by the typechecker, it should not be present before checking."
             ),
+            // coverage:on
         };
         match expr_type {
             // If the type check passed, great, we now know the inferred type.