feat(experimental): show macro errors where they happen

[asterite]

Description

Problem*

Related to #6965
Resolves #6013

Summary

This PR makes macro errors show up in the code that produces the error. For example:

#[foo] // Error used to be notified here (and still is, kind of)
comptime fn foo(_: FunctionDefinition) -> Quoted {
    quote {
        fn bar() {
            1 + "a"; // Error is notified here
        }
    }
}

For that to work several changes were needed:

1. Value::Quoted in comptime code used to be a list of bare tokens, without spans. The first change was to change that to SpannedToken. With that, the snippet above gives the error in the "correct" location.
2. But what if the quoted value is in another file? Just spans aren't enough: every token needs to hold a Location, and that Location needs to be propagated to AST nodes. That's what the rest of the PR does.

For example in a program like this:

// main.nr
mod other;
use other::expr;

#[foo]
comptime fn foo(_: FunctionDefinition) -> Quoted {
    let expr = expr();
    quote {
        fn bar() {
            $expr;
        }
    }
}

// other.nr
pub comptime fn expr() -> Quote {
    quote { 1 + "a" }
}

The resulting program will have a function bar located at "main.nr", with an expression that's located in "other.nr". When the error is found, it's found in "other.nr".

Going back to the first snippet:

#[foo]
comptime fn foo(_: FunctionDefinition) -> Quoted {
    quote {
        fn bar() {
            1 + "a";
        }
    }
}

This is what the error looks like now:

That is:

• the error primarily shows up in the macro source code that triggered it (which hopefully is understandable)
• the error mentions that it happened while running a function attribute

This solves the concern about only showing the error where it happens but without that being clear that it was because of a macro call or similarly.

To implement this, the Elaborator keeps a stack of "elaborate reasons": before elaborating items produced by a macro we record that we are elaborating because of this macro (and track that location). Then, if an error happens, it's wrapped so that it also mentions that location.

Additional Context

This PR is massive, but most of the diff is:

1. Changing Span to Location in a lot of places
2. A new file, with_file.rs, whose task is to transform a ParsedModule into another one where all the FileIDs that exist in it are replaced with a different FileID (this is so that LSP parser cache can still be used, which is much faster than not caching)

There's another thing I noticed. In this snippet:

mod other;

fn main() {
    comptime {
        let expr = quote { 1 + "a" }.as_expr().unwrap();
        let resolved = expr.resolve(Option::none());
    }
}

We get this error:

error: Types in a binary operation should match, but found Field and str<1>
  ┌─ src/main.nr:6:24
  │
6 │         let resolved = expr.resolve(Option::none());
  │                        ----

Without going back to the code and checking what's expr it's hard to understand the error. I think the error should be (like the rest of this PR) first in 1 + "a" then a mention that it happened while doing expr.resolve. The issue is that comptime Values that wrap expressions and statements only hold an ExpressionKind or StatementKind, without a Location. To improve this we could change that to storing Expression and Statement, and using those locations in errors. But I'll leave that to a separate PR because this was is already huge.

Documentation

Check one:

• No documentation needed.
• Documentation included in this PR.
• [For Experimental Features] Documentation to be submitted in a separate PR.

PR Checklist

• I have tested the changes locally.
• I have formatted the changes with Prettier and/or cargo fmt on default settings.

[asterite]

I made a follow-up issue to test error locations: #7455

[jfecher]

LGTM. I only got through the first 50 files or so though

[jfecher]

LGTM

[Aristotelis2002]

This PR seems to lead to an unexpected behavior in nargo debug:

Note the step in the seemingly random file. Program is:

fn bar(y: Field) {
    assert(y != 0);
}
fn foo(x: Field) {
    bar(x)
}
fn main(x: Field, y: pub Field) {
    foo(x);
    foo(y);
    assert(x != y);
}