diff --git a/cli/tests/snapshot/snapshots/snapshot__eval_stderr_destructuring_closed_fail.ncl.snap b/cli/tests/snapshot/snapshots/snapshot__eval_stderr_destructuring_closed_fail.ncl.snap
index 0b7eda263a..eb3c6adbf7 100644
--- a/cli/tests/snapshot/snapshots/snapshot__eval_stderr_destructuring_closed_fail.ncl.snap
+++ b/cli/tests/snapshot/snapshots/snapshot__eval_stderr_destructuring_closed_fail.ncl.snap
@@ -2,17 +2,11 @@
 source: cli/tests/snapshot/main.rs
 expression: err
 ---
-error: contract broken by a value
-       extra field `b`
-  ┌─ [INPUTS_PATH]/errors/destructuring_closed_fail.ncl:3:11
+error: unmatched pattern
+  ┌─ [INPUTS_PATH]/errors/destructuring_closed_fail.ncl:3:5
   │
 3 │ let {a} = {a=1, b=2}
-  │     ---   ^^^^^^^^^^ applied to this expression
-  │     │      
-  │     expected type
-  │
-  = Have you misspelled a field?
-  = The record contract might also be too strict. By default, record contracts exclude any field which is not listed.
-    Append `, ..` at the end of the record contract, as in `{some_field | SomeContract, ..}`, to make it accept extra fields.
-
-
+  │     ^^^^^^^^^^^^^^^^
+  │     │     │
+  │     │     this value doesn't match any branch
+  │     in this match expression
diff --git a/core/src/parser/grammar.lalrpop b/core/src/parser/grammar.lalrpop
index 5155a1b409..9368a8931f 100644
--- a/core/src/parser/grammar.lalrpop
+++ b/core/src/parser/grammar.lalrpop
@@ -404,10 +404,11 @@ RecordField: FieldDef = {
     <l: @L> <path: FieldPath> <ann: FieldAnnot<Type>?> <r: @R> <t: ("=" <Term>)?> => {
         let annot_span = mk_span(src_id, l, r);
         let span = if let Some(ref value) = t {
-                // value.pos.unwrap(): the position of `t` is necessarily set by the <Term> rule
+                // value.pos.unwrap(): the position of `t` is necessarily set by
+                // the <Term> rule
                 // result unwrap(): the term and the annotation have spans
-                //   coming from the same file (the current one)
-                RawSpan::fuse(annot_span, value.pos.unwrap()).unwrap()
+                // coming from the same file (the current one)
+                annot_span.fuse(value.pos.unwrap()).unwrap()
         } else {
             annot_span
         };
diff --git a/core/src/parser/uniterm.rs b/core/src/parser/uniterm.rs
index 715a051971..afa4d0c0ac 100644
--- a/core/src/parser/uniterm.rs
+++ b/core/src/parser/uniterm.rs
@@ -374,12 +374,9 @@ impl UniRecord {
                     tail: Box::new(tail),
                 })),
                 _ => {
-                    // Position of identifiers must always be set at this stage
-                    // (parsing)
-                    let span_id = id.pos.unwrap();
-                    let term_pos = field_def.pos.into_opt().unwrap_or(span_id);
                     Err(InvalidRecordTypeError::InvalidField(
-                        RawSpan::fuse(span_id, term_pos).unwrap(),
+                        // Position of identifiers must always be set at this stage (parsing)
+                        id.pos.fuse(field_def.pos).unwrap(),
                     ))
                 }
             }
@@ -418,7 +415,7 @@ impl UniRecord {
                                 FieldPathElem::Ident(id) => id.pos.unwrap(),
                                 FieldPathElem::Expr(rt) => rt.pos.unwrap(),
                             })
-                            .reduce(|acc, span| RawSpan::fuse(acc, span).unwrap_or(acc))
+                            .reduce(|acc, span| acc.fuse(span).unwrap_or(acc))
                             // We already checked that the path is non-empty.
                             .unwrap();
 
diff --git a/core/src/parser/utils.rs b/core/src/parser/utils.rs
index e5152f6a7b..7f4e5b4759 100644
--- a/core/src/parser/utils.rs
+++ b/core/src/parser/utils.rs
@@ -150,7 +150,7 @@ impl FieldDef {
 
                 // `RawSpan::fuse` only returns `None` when the two spans are in different files.
                 // A record field and its value *must* be in the same file, so this is safe.
-                let pos = TermPos::Original(RawSpan::fuse(id_span, acc_span).unwrap());
+                let pos = TermPos::Original(id_span.fuse(acc_span).unwrap());
 
                 match path_elem {
                     FieldPathElem::Ident(id) => {
diff --git a/core/src/position.rs b/core/src/position.rs
index f84a9543f8..843cc1298a 100644
--- a/core/src/position.rs
+++ b/core/src/position.rs
@@ -31,13 +31,13 @@ pub struct RawSpan {
 
 impl RawSpan {
     /// Fuse two spans if they are from the same source file. The resulting span is the smallest
-    /// span that contain both `span1` and `span2`.
-    pub fn fuse(span1: RawSpan, span2: RawSpan) -> Option<RawSpan> {
-        if span1.src_id == span2.src_id {
+    /// span that contain both `self` and `other`.
+    pub fn fuse(self, other: RawSpan) -> Option<RawSpan> {
+        if self.src_id == other.src_id {
             Some(RawSpan {
-                src_id: span1.src_id,
-                start: min(span1.start, span2.start),
-                end: max(span1.end, span2.end),
+                src_id: self.src_id,
+                start: min(self.start, other.start),
+                end: max(self.end, other.end),
             })
         } else {
             None
@@ -140,6 +140,34 @@ impl TermPos {
     pub fn contains(&self, pos: RawPos) -> bool {
         self.as_opt_ref().map_or(false, |sp| sp.contains(pos))
     }
+
+    /// Fuse two positions if they are from the same source file.
+    ///
+    /// - If both positions are defined and from the same file, the resulting position is the
+    /// smallest span that contain both.
+    /// - If both positions are defined but aren't from the same file, this returns `TermPos::None`
+    /// - If at most one position is defined, the other is returned (whether defined or not).
+    pub fn fuse(self, other: Self) -> Self {
+        match (self, other) {
+            (TermPos::Original(sp1), TermPos::Original(sp2)) => {
+                if let Some(span) = sp1.fuse(sp2) {
+                    TermPos::Original(span)
+                } else {
+                    TermPos::None
+                }
+            }
+            (TermPos::Inherited(sp1), TermPos::Inherited(sp2))
+            | (TermPos::Original(sp1), TermPos::Inherited(sp2))
+            | (TermPos::Inherited(sp1), TermPos::Original(sp2)) => {
+                if let Some(span) = sp1.fuse(sp2) {
+                    TermPos::Inherited(span)
+                } else {
+                    TermPos::None
+                }
+            }
+            (TermPos::None, maybe_def) | (maybe_def, TermPos::None) => maybe_def,
+        }
+    }
 }
 
 /// A natural ordering for positions: `p1` is smaller than `p2` if they are located in the same
diff --git a/core/src/term/pattern/compile.rs b/core/src/term/pattern/compile.rs
index 10ee567821..16d1fe4df2 100644
--- a/core/src/term/pattern/compile.rs
+++ b/core/src/term/pattern/compile.rs
@@ -17,9 +17,9 @@
 //! to handle before that). We might revisit this in the future if pattern matching turns out to be
 //! a bottleneck.
 //!
-//! Most build blocks are generated programmatically rather than written out as e.g. members of the
-//! [internals] stdlib module. While clunkier, this lets more easily change the compilation
-//! strategy in the future and is already a more efficient in the current setting (combining
+//! Most building blocks are generated programmatically rather than written out as e.g. members of
+//! the [crate::stdlib::internals] module. While clunkier, this makes it easier to change
+//! the compilation strategy in the future and is more efficient in the current setting (combining
 //! building blocks from the standard library would require much more function applications, while
 //! we can generate inlined versions on-the-fly here).
 use super::*;
@@ -184,7 +184,7 @@ fn update_with_merge(record_id: LocIdent, id: LocIdent, field: Field) -> RichTer
         // We fuse all the definite spans together.
         // unwrap(): all span should come from the same file
         // unwrap(): we hope that at least one position is defined
-        .reduce(|span1, span2| crate::position::RawSpan::fuse(span1, span2).unwrap())
+        .reduce(|span1, span2| span1.fuse(span2).unwrap())
         .unwrap();
 
     let merge_label = MergeLabel {
diff --git a/core/src/term/pattern/mod.rs b/core/src/term/pattern/mod.rs
index fa3854599c..03da8c4dd5 100644
--- a/core/src/term/pattern/mod.rs
+++ b/core/src/term/pattern/mod.rs
@@ -2,18 +2,13 @@
 use std::collections::{hash_map::Entry, HashMap};
 
 use super::{
-    record::{Field, RecordAttrs, RecordData},
-    LabeledType, NickelString, Number, RichTerm, Term, TypeAnnotation,
+    record::{Field, RecordData},
+    NickelString, Number, RichTerm, TypeAnnotation,
 };
 
 use crate::{
-    error::EvalError,
-    identifier::LocIdent,
-    impl_display_from_pretty, mk_app,
-    parser::error::ParseError,
+    error::EvalError, identifier::LocIdent, impl_display_from_pretty, parser::error::ParseError,
     position::TermPos,
-    stdlib::internals,
-    typ::{Type, TypeF},
 };
 
 pub mod compile;
@@ -188,125 +183,6 @@ impl RecordPattern {
     }
 }
 
-impl FieldPattern {
-    /// Convert this field pattern to a record field binding with metadata. Used to generate the
-    /// record contract associated to a record pattern.
-    pub fn as_record_binding(&self) -> (LocIdent, Field) {
-        let mut annotation = self.annotation.clone();
-        // If the inner pattern gives rise to a contract, add it the to the field decoration.
-        annotation
-            .contracts
-            .extend(self.pattern.elaborate_contract());
-
-        (self.matched_id, Field::from(annotation))
-    }
-}
-
-// We don't implement elaborate_contract for `FieldPattern`, which is of a slightly different
-// nature (it's a part of a record pattern). Instead, we call to `FieldPattern::as_record_binding`,
-// which takes care of elaborating a field pattern to an appropriate record field.
-pub trait ElaborateContract {
-    /// Elaborate a contract from this pattern. The contract will check both the structure of the
-    /// matched value (e.g. the presence of fields in a record) and incoporate user-provided
-    /// contracts and annotations, as well as default values.
-    ///
-    /// Some patterns don't give rise to any contract (e.g. `Any`), in which case this function
-    /// returns `None`.
-    fn elaborate_contract(&self) -> Option<LabeledType>;
-}
-
-impl ElaborateContract for PatternData {
-    fn elaborate_contract(&self) -> Option<LabeledType> {
-        match self {
-            PatternData::Wildcard | PatternData::Any(_) => None,
-            PatternData::Record(pat) => pat.elaborate_contract(),
-            PatternData::Enum(pat) => pat.elaborate_contract(),
-            PatternData::Constant(pat) => pat.elaborate_contract(),
-        }
-    }
-}
-
-impl ElaborateContract for Pattern {
-    fn elaborate_contract(&self) -> Option<LabeledType> {
-        self.data.elaborate_contract()
-    }
-}
-
-// Generate the contract `std.contract.Equal <value>` as a labeled type.
-fn contract_eq(value: Term, span: crate::position::RawSpan) -> LabeledType {
-    let contract = mk_app!(internals::stdlib_contract_equal(), value);
-
-    let typ = Type {
-        typ: TypeF::Flat(contract),
-        pos: span.into(),
-    };
-
-    LabeledType::new(typ, span)
-}
-
-impl ElaborateContract for ConstantPattern {
-    fn elaborate_contract(&self) -> Option<LabeledType> {
-        // See [^unwrap-span].
-        let span = self.pos.unwrap();
-
-        Some(match &self.data {
-            ConstantPatternData::Bool(b) => contract_eq(Term::Bool(*b), span),
-            ConstantPatternData::String(s) => contract_eq(Term::Str(s.clone()), span),
-            ConstantPatternData::Number(n) => contract_eq(Term::Num(n.clone()), span),
-            ConstantPatternData::Null => contract_eq(Term::Null, span),
-        })
-    }
-}
-
-impl ElaborateContract for EnumPattern {
-    fn elaborate_contract(&self) -> Option<LabeledType> {
-        // TODO[adts]: it would be better to simply build a type like `[| 'tag arg |]` or `[| 'tag
-        // |]` and to rely on its derived contract. However, for the time being, the contract
-        // derived from enum variants isn't implemented yet.
-        let contract = if self.pattern.is_some() {
-            mk_app!(internals::enum_variant(), Term::Enum(self.tag))
-        } else {
-            mk_app!(internals::stdlib_contract_equal(), Term::Enum(self.tag))
-        };
-
-        let typ = Type {
-            typ: TypeF::Flat(contract),
-            pos: self.pos,
-        };
-
-        // [^unwrap-span]: We need the position to be defined here. Hopefully,
-        // contract-generating pattern are pattern used in destructuring, and destructuring
-        // patterns aren't currently generated by the Nickel interpreter. So we should only
-        // encounter user-written patterns here, which should have a position.
-        Some(LabeledType::new(typ, self.pos.unwrap()))
-    }
-}
-
-impl ElaborateContract for RecordPattern {
-    fn elaborate_contract(&self) -> Option<LabeledType> {
-        let typ = Type {
-            typ: TypeF::Flat(
-                Term::Record(RecordData::new(
-                    self.patterns
-                        .iter()
-                        .map(FieldPattern::as_record_binding)
-                        .collect(),
-                    RecordAttrs {
-                        open: self.is_open(),
-                        ..Default::default()
-                    },
-                    None,
-                ))
-                .into(),
-            ),
-            pos: self.pos,
-        };
-
-        // unwrap(): see [^unwrap-span]
-        Some(LabeledType::new(typ, self.pos.unwrap()))
-    }
-}
-
 impl_display_from_pretty!(PatternData);
 impl_display_from_pretty!(Pattern);
 impl_display_from_pretty!(ConstantPatternData);
diff --git a/core/src/transform/desugar_destructuring.rs b/core/src/transform/desugar_destructuring.rs
index d571142374..77059e6ef8 100644
--- a/core/src/transform/desugar_destructuring.rs
+++ b/core/src/transform/desugar_destructuring.rs
@@ -1,50 +1,16 @@
 //! Destructuring desugaring
 //!
-//! Replace a let-binding with destructuring by a sequence of normal let-binding.
+//! Replace a let-binding with destructuring by simpler constructs.
 //!
-//! # Example
+//! A destructuring `let pat> = <destr> in <body>` is rewritten to the pattern matching
+//! `<destr> |> match { <pat> => <body> }`.
 //!
-//! ## Let-binding
-//!
-//! The following destructuring let-binding:
-//!
-//! ```text
-//! let x @ {a, b=d, ..} = {a=1,b=2,c="ignored"} in ...
-//! ```
-//!
-//! will be transformed to:
-//!
-//! ```text
-//! let x = {a=1,b=2,c="ignored"} in
-//! let a = x.a in
-//! let d = x.b in
-//! ...
-//! ```
-//!
-//! ## Function
-//!
-//! The following destructuring function:
-//!
-//! ```text
-//! let f = fun x@{a, b=c} {d ? 2, ..w} => <do_something> in ...
-//! ```
-//!
-//! will be transformed to:
-//!
-//! ```text
-//! let f = fun x %unnamed% => (
-//!     let {a, b=c} = x in
-//!     let {d ? 2, ..w} = %unnamed% in
-//!     <do_something>
-//! ) in ...
-//! ```
-use crate::identifier::LocIdent;
-use crate::match_sharedterm;
-use crate::mk_app;
-use crate::term::pattern::*;
-use crate::term::{
-    make as mk_term, BinaryOp::DynRemove, LetAttrs, RecordOpKind, RichTerm, Term, TypeAnnotation,
-    UnaryOp,
+//! A destructuring function `fun <pat> => <body>` is rewritten to
+//! `fun x => let <pat> = x in <body>`, and then the inner let is recursively desugared.
+use crate::{
+    identifier::LocIdent,
+    match_sharedterm,
+    term::{pattern::*, MatchData, RichTerm, Term},
 };
 
 /// Entry point of the destructuring desugaring transformation.
@@ -79,165 +45,22 @@ pub fn desugar_fun(mut pat: Pattern, body: RichTerm) -> Term {
     )
 }
 
-/// Elaborate a contract from the pattern if it is a record pattern and apply it to the value before
-/// actually destructuring it. Then convert the let pattern to a sequence of normal let-bindings.
+/// Desugar a destructuring let-binding.
+///
+/// A let-binding `let <pat> = bound in body` is desugared to `<bound> |> match { <pat> => body }`.
 pub fn desugar_let(pat: Pattern, bound: RichTerm, body: RichTerm) -> Term {
-    let contract = pat.elaborate_contract();
+    // the position of the match expression is used during error reporting, so we try to provide a
+    // sensible one.
+    let match_expr_pos = pat.pos.fuse(bound.pos);
 
-    let annotated = {
-        let t_pos = bound.pos;
+    // `(match { <pat> => <body> }) <bound>`
+    Term::App(
         RichTerm::new(
-            Term::Annotated(
-                TypeAnnotation {
-                    contracts: contract.into_iter().collect(),
-                    ..Default::default()
-                },
-                bound,
-            ),
-            t_pos,
-        )
-    };
-
-    pat.desugar(annotated, body)
-}
-
-trait Desugar {
-    /// Elaborate a destructuring let-binding matching a pattern `self` against a value `destr` to
-    /// a sequence of normal let-bindings and primitive operations.
-    ///
-    /// This function ignores the user-supplied contracts of the pattern and doesn't generate a
-    /// safety contract to check that the value has the expected shape: this guarding contract must
-    /// be introduced separately and prior to calling to [Desugar::desugar]. In practice, this
-    /// contract is introduced by [desugar_let]. [Desugar::desugar] is only concerned with
-    /// destructuring the value and binding its parts to appropriate variables.
-    fn desugar(self, destr: RichTerm, body: RichTerm) -> Term;
-}
-
-impl Desugar for Pattern {
-    fn desugar(self, destr: RichTerm, body: RichTerm) -> Term {
-        // If the pattern is aliased, `x @ <pat>` matching `destr`, we introduce a heading
-        // let-binding `let x = destruct in <elaborated>`, where `<elaborated>` is the desugaring
-        // of `<pat>` matching `x` followed by the original `body`.
-        if let Some(alias) = self.alias {
-            let pos = body.pos;
-            let inner = RichTerm::new(
-                self.data
-                    .desugar(RichTerm::new(Term::Var(alias), alias.pos), body),
-                pos,
-            );
-
-            Term::Let(alias, destr, inner, LetAttrs::default())
-        } else {
-            self.data.desugar(destr, body)
-        }
-    }
-}
-
-impl Desugar for PatternData {
-    fn desugar(self, destr: RichTerm, body: RichTerm) -> Term {
-        match self {
-            PatternData::Wildcard => body.into(),
-            // If the pattern is an unconstrained identifier, we just bind it to the value.
-            PatternData::Any(id) => Term::Let(id, destr, body, LetAttrs::default()),
-            PatternData::Record(pat) => pat.desugar(destr, body),
-            PatternData::Enum(pat) => pat.desugar(destr, body),
-            PatternData::Constant(pat) => pat.desugar(destr, body),
-        }
-    }
-}
-
-impl Desugar for ConstantPattern {
-    fn desugar(self, destr: RichTerm, body: RichTerm) -> Term {
-        // See [^seq-patterns]
-        mk_app!(mk_term::op1(UnaryOp::Seq(), destr), body).into()
-    }
-}
-
-impl Desugar for FieldPattern {
-    // For a field pattern, we assume that the `destr` argument is the whole record being
-    // destructured. We extract the field from `destr`, or use the default value is the field isn't
-    // present, and desugar the rest of the pattern against `destr.matched_id`.
-    fn desugar(self, destr: RichTerm, body: RichTerm) -> Term {
-        let destr = if let Some(default) = self.default {
-            // We put `destr` inside a let-binding, because with_default_value uses it several
-            // time.
-            let record_id = LocIdent::fresh();
-            let with_default = compile::with_default_value(record_id, self.matched_id, default);
-            mk_term::let_in(record_id, destr, with_default)
-        } else {
-            destr
-        };
-
-        let extracted = mk_term::op1(UnaryOp::StaticAccess(self.matched_id), destr);
-        self.pattern.desugar(extracted, body)
-    }
-}
-
-impl Desugar for RecordPattern {
-    fn desugar(self, destr: RichTerm, body: RichTerm) -> Term {
-        let pos = body.pos;
-        // The body is the rest of the term being transformed, which contains the code that uses
-        // the bindings introduced by the pattern. After having extracted all fields from the
-        // value, we potentially need to capture the rest in a variable for patterns with a
-        // capturing tail. For example, `let {foo, bar, ..rest} = destr in body` should be
-        // desugared as `let foo = destr.foo in let bar = destr.bar in let rest = <rest> in body`
-        // (where `<rest>` is some expression removing `foo` and `bar` from `destr`).
-        //
-        // Because body is the continuation, we need to first append the rest capture to the
-        // original body before passing it to the [Desugar::desugar] of each individual field.
-        let body_with_rest = bind_rest(&self, destr.clone(), body);
-
-        self.patterns
-            .into_iter()
-            .fold(body_with_rest, |acc, field_pat| {
-                RichTerm::new(field_pat.desugar(destr.clone(), acc), pos)
-            })
-            .term
-            .into_owned()
-    }
-}
-
-impl Desugar for EnumPattern {
-    fn desugar(self, destr: RichTerm, body: RichTerm) -> Term {
-        if let Some(arg_pat) = self.pattern {
-            let extracted = mk_term::op1(UnaryOp::EnumUnwrapVariant(), destr.clone());
-            arg_pat.desugar(extracted, body)
-        }
-        // [^seq-patterns]: If the pattern doesn't bind any argument, it's transparent, and we just
-        // proceed with the body. However, because of lazyness, the associated contract will never
-        // be checked, because body doesn't depend on `destr`.
-        //
-        // For patterns that bind variables, it's reasonable to keep them lazy: that is, in `let
-        // 'Foo x = destr in body`, `destr` is checked to be an enum only when `x` is evaluated.
-        // However, for patterns that don't bind anything, the pattern is useless. Arguably, users
-        // would expect that writing `let 'Foo = x in body` would check that `x` is indeed equal to
-        // `'Foo`. We thus introduce an artificial dependency: it's exactly the role of `seq`
-        else {
-            mk_app!(mk_term::op1(UnaryOp::Seq(), destr), body).into()
-        }
-    }
-}
-
-fn bind_rest(pat: &RecordPattern, destr: RichTerm, body: RichTerm) -> RichTerm {
-    let capture_var = match pat {
-        RecordPattern {
-            tail: RecordPatternTail::Capture(x),
-            ..
-        } => *x,
-        _ => return body,
-    };
-
-    Term::Let(
-        capture_var,
-        pat.patterns.iter().fold(destr, |acc, field_pat| {
-            mk_term::op2(
-                DynRemove(RecordOpKind::default()),
-                Term::Str(field_pat.matched_id.ident().into()),
-                acc,
-            )
-        }),
-        body,
-        Default::default(),
+            Term::Match(MatchData {
+                branches: vec![(pat, body)],
+            }),
+            match_expr_pos,
+        ),
+        bound,
     )
-    .into()
 }
diff --git a/core/tests/integration/inputs/destructuring/adt_enum_tag_tag_mismatch.ncl b/core/tests/integration/inputs/destructuring/adt_enum_tag_tag_mismatch.ncl
index de58d11e1f..09ab21593b 100644
--- a/core/tests/integration/inputs/destructuring/adt_enum_tag_tag_mismatch.ncl
+++ b/core/tests/integration/inputs/destructuring/adt_enum_tag_tag_mismatch.ncl
@@ -1,6 +1,6 @@
 # test.type = 'error'
 #
 # [test.metadata]
-# error = 'EvalError::BlameError'
+# error = 'EvalError::NonExhaustiveEnumMatch'
 let 'Foo = 'Bar in
 true
diff --git a/core/tests/integration/inputs/destructuring/adt_extra_arg_contract_fail.ncl b/core/tests/integration/inputs/destructuring/adt_extra_arg.ncl
similarity index 61%
rename from core/tests/integration/inputs/destructuring/adt_extra_arg_contract_fail.ncl
rename to core/tests/integration/inputs/destructuring/adt_extra_arg.ncl
index 6ab8dc4886..facfe98c0e 100644
--- a/core/tests/integration/inputs/destructuring/adt_extra_arg_contract_fail.ncl
+++ b/core/tests/integration/inputs/destructuring/adt_extra_arg.ncl
@@ -1,6 +1,6 @@
 # test.type = 'error'
 #
 # [test.metadata]
-# error = 'EvalError::BlameError'
+# error = 'EvalError::NAryPrimopTypeError'
 let 'Foo = 'Foo 5 in
 true
diff --git a/core/tests/integration/inputs/destructuring/adt_missing_arg_contract_fail.ncl b/core/tests/integration/inputs/destructuring/adt_missing_arg.ncl
similarity index 60%
rename from core/tests/integration/inputs/destructuring/adt_missing_arg_contract_fail.ncl
rename to core/tests/integration/inputs/destructuring/adt_missing_arg.ncl
index 2202b6b671..8e844917fd 100644
--- a/core/tests/integration/inputs/destructuring/adt_missing_arg_contract_fail.ncl
+++ b/core/tests/integration/inputs/destructuring/adt_missing_arg.ncl
@@ -1,6 +1,6 @@
 # test.type = 'error'
 #
 # [test.metadata]
-# error = 'EvalError::BlameError'
+# error = 'EvalError::NonExhaustiveMatch'
 let 'Foo x = 'Foo in
 x
diff --git a/core/tests/integration/inputs/destructuring/adt_wrong_tag_contract_fail.ncl b/core/tests/integration/inputs/destructuring/adt_wrong_tag.ncl
similarity index 61%
rename from core/tests/integration/inputs/destructuring/adt_wrong_tag_contract_fail.ncl
rename to core/tests/integration/inputs/destructuring/adt_wrong_tag.ncl
index 10d194d5ad..b7e49ae75e 100644
--- a/core/tests/integration/inputs/destructuring/adt_wrong_tag_contract_fail.ncl
+++ b/core/tests/integration/inputs/destructuring/adt_wrong_tag.ncl
@@ -1,6 +1,6 @@
 # test.type = 'error'
 #
 # [test.metadata]
-# error = 'EvalError::BlameError'
+# error = 'EvalError::NonExhaustiveMatch'
 let 'Foo x = 'Bar 5  in
 x
diff --git a/core/tests/integration/inputs/destructuring/adt_wrong_type_contract_fail.ncl b/core/tests/integration/inputs/destructuring/adt_wrong_type.ncl
similarity index 62%
rename from core/tests/integration/inputs/destructuring/adt_wrong_type_contract_fail.ncl
rename to core/tests/integration/inputs/destructuring/adt_wrong_type.ncl
index fc7ad158f0..8518877740 100644
--- a/core/tests/integration/inputs/destructuring/adt_wrong_type_contract_fail.ncl
+++ b/core/tests/integration/inputs/destructuring/adt_wrong_type.ncl
@@ -1,6 +1,6 @@
 # test.type = 'error'
 #
 # [test.metadata]
-# error = 'EvalError::BlameError'
+# error = 'EvalError::NonExhaustiveMatch'
 let 'Foo x = {bar = 1}  in
 x
diff --git a/core/tests/integration/inputs/destructuring/closed_fail.ncl b/core/tests/integration/inputs/destructuring/closed_fail.ncl
index a934a5bca5..b04e2a387e 100644
--- a/core/tests/integration/inputs/destructuring/closed_fail.ncl
+++ b/core/tests/integration/inputs/destructuring/closed_fail.ncl
@@ -1,6 +1,6 @@
 # test.type = 'error'
 #
 # [test.metadata]
-# error = 'EvalError::BlameError'
+# error = 'EvalError::NonExhaustiveMatch'
 let {a} = {a=1, b=2}
 in a == 1
diff --git a/core/tests/integration/inputs/destructuring/constant_bool_fail.ncl b/core/tests/integration/inputs/destructuring/constant_bool_fail.ncl
index 80b39dc642..78d64cd2f5 100644
--- a/core/tests/integration/inputs/destructuring/constant_bool_fail.ncl
+++ b/core/tests/integration/inputs/destructuring/constant_bool_fail.ncl
@@ -1,5 +1,5 @@
 # test.type = 'error'
 #
 # [test.metadata]
-# error = 'EvalError::BlameError'
+# error = 'EvalError::NonExhaustiveMatch'
 let true = false in true
diff --git a/core/tests/integration/inputs/destructuring/constant_null_fail.ncl b/core/tests/integration/inputs/destructuring/constant_null_fail.ncl
index 3e38d6ac8b..1cb75351d9 100644
--- a/core/tests/integration/inputs/destructuring/constant_null_fail.ncl
+++ b/core/tests/integration/inputs/destructuring/constant_null_fail.ncl
@@ -1,5 +1,5 @@
 # test.type = 'error'
 #
 # [test.metadata]
-# error = 'EvalError::BlameError'
+# error = 'EvalError::NonExhaustiveMatch'
 let null = 0 in true
diff --git a/core/tests/integration/inputs/destructuring/constant_number_fail.ncl b/core/tests/integration/inputs/destructuring/constant_number_fail.ncl
index f78dae2617..bdf99a428a 100644
--- a/core/tests/integration/inputs/destructuring/constant_number_fail.ncl
+++ b/core/tests/integration/inputs/destructuring/constant_number_fail.ncl
@@ -1,5 +1,5 @@
 # test.type = 'error'
 #
 # [test.metadata]
-# error = 'EvalError::BlameError'
+# error = 'EvalError::NonExhaustiveMatch'
 let 1 = 1 + 1 in true
diff --git a/core/tests/integration/inputs/destructuring/constant_string_fail.ncl b/core/tests/integration/inputs/destructuring/constant_string_fail.ncl
index 6708214d8f..7a6760ea66 100644
--- a/core/tests/integration/inputs/destructuring/constant_string_fail.ncl
+++ b/core/tests/integration/inputs/destructuring/constant_string_fail.ncl
@@ -1,5 +1,5 @@
 # test.type = 'error'
 #
 # [test.metadata]
-# error = 'EvalError::BlameError'
+# error = 'EvalError::NonExhaustiveMatch'
 let "ab" = "a" ++ "b" ++ "c" in true
diff --git a/core/tests/integration/inputs/destructuring/nested_duplicated_ident.ncl b/core/tests/integration/inputs/destructuring/nested_duplicated_ident.ncl
deleted file mode 100644
index 34816f77f3..0000000000
--- a/core/tests/integration/inputs/destructuring/nested_duplicated_ident.ncl
+++ /dev/null
@@ -1,4 +0,0 @@
-# test.type = 'pass'
-let f = fun { x = { y }, z = { y } } => y in
-let result = f { x = { y = 1 }, z = { y = 2 } } in
-result == 1
\ No newline at end of file
diff --git a/core/tests/integration/main.rs b/core/tests/integration/main.rs
index bebcb71dd7..1f399eda53 100644
--- a/core/tests/integration/main.rs
+++ b/core/tests/integration/main.rs
@@ -167,6 +167,8 @@ enum ErrorExpectation {
     EvalMergeIncompatibleArgs,
     #[serde(rename = "EvalError::NonExhaustiveMatch")]
     EvalNonExhaustiveMatch,
+    #[serde(rename = "EvalError::NonExhaustiveEnumMatch")]
+    EvalNonExhaustiveEnumMatch,
     #[serde(rename = "TypecheckError::UnboundIdentifier")]
     TypecheckUnboundIdentifier { identifier: String },
     #[serde(rename = "TypecheckError::UnboundTypeVariable")]
@@ -233,6 +235,10 @@ impl PartialEq<Error> for ErrorExpectation {
             )
             | (EvalOther, Error::EvalError(EvalError::Other(..)))
             | (EvalNonExhaustiveMatch, Error::EvalError(EvalError::NonExhaustiveMatch { .. }))
+            | (
+                EvalNonExhaustiveEnumMatch,
+                Error::EvalError(EvalError::NonExhaustiveEnumMatch { .. }),
+            )
             | (
                 TypecheckRecordRowMismatch,
                 Error::TypecheckError(TypecheckError::RecordRowMismatch { .. }),
@@ -390,6 +396,7 @@ impl std::fmt::Display for ErrorExpectation {
                 format!("EvalError::MissingFieldDef({field})")
             }
             EvalNonExhaustiveMatch => "EvalError::NonExhaustiveMatch".to_owned(),
+            EvalNonExhaustiveEnumMatch => "EvalError::NonExhaustiveEnumMatch".to_owned(),
             TypecheckUnboundIdentifier { identifier } => {
                 format!("TypecheckError::UnboundIdentifier({identifier})")
             }
diff --git a/doc/manual/syntax.md b/doc/manual/syntax.md
index 43c64bfb70..1c1b5d301f 100644
--- a/doc/manual/syntax.md
+++ b/doc/manual/syntax.md
@@ -775,7 +775,7 @@ Examples:
 'Hello
 
 > let 'Invalid x = {} in x
-error: contract broken by a value
+error: unmatched pattern
 [...]
 ```
 
diff --git a/lsp/nls/src/requests/symbols.rs b/lsp/nls/src/requests/symbols.rs
index 145912b972..38eb3823da 100644
--- a/lsp/nls/src/requests/symbols.rs
+++ b/lsp/nls/src/requests/symbols.rs
@@ -1,6 +1,5 @@
 use lsp_server::{RequestId, Response, ResponseError};
 use lsp_types::{DocumentSymbol, DocumentSymbolParams, SymbolKind};
-use nickel_lang_core::position::RawSpan;
 use nickel_lang_core::term::RichTerm;
 use nickel_lang_core::typ::Type;
 
@@ -53,7 +52,7 @@ fn symbols(
                     .iter()
                     .filter_map(|ty| ty.typ.pos.into_opt())
                     .chain(field.value.as_ref().and_then(|val| val.pos.into_opt()))
-                    .fold(id_pos, |a, b| RawSpan::fuse(a, b).unwrap_or(a));
+                    .fold(id_pos, |a, b| a.fuse(b).unwrap_or(a));
 
                 let selection_range = crate::codespan_lsp::byte_span_to_range(
                     world.cache.files(),