c92d06271d
LightSpan::Delayed was introduced in commit
bf286a54bc which claimed that "This
reduces the eval time for `builtins.length (builtins.attrNames
(import <nixpkgs> {}))` by *one third*!"
I am unable to reproduce this result. In fact, dropping the
LightSpan::Delayed variant of the enum makes eval of the same
expression slightly faster! I also tried a large evaluation
(pkgsCross...hello) and got similar results: slightly faster,
slightly less memory. See git footers.
I suspect that there was some unrelated horrific inefficiency that
has since been fixed. The avoided computation in `get_span()` is
nothing more than a binary search! If this were in fact a major
performance issue we could simply precompute the mapping from
CodeIdx to Span when the Chunk becomes immutable (i.e. at the end of
the compilation process, when compiler backtracking is no longer a
concern). Since a Span is just 64 bits this is not a space issue,
and since binary search is much simpler than compiling Nix
expressions it isn't a performance issue either.
Technically there is no longer any reason to have LightSpan since it
is now a single-variant enum. However there is no rush to remove
it, since Rust will optimize its representation into the same thing
you'd get if you replaced LightSpan by Span.
Prev-Benchmark: {"nixpkgs-attrnames":{"kbytes":"233824","system":"0.32","user":"2.02"}}
This-Benchmark: {"nixpkgs-attrnames":{"kbytes":"230192","system":"0.29","user":"2.00"}}
Prev-Benchmark: {"pkgsCross.aarch64-multiplatform.hello.outPath":{"kbytes":"458936","system":"0.73","user":"5.36"}}
This-Benchmark: {"pkgsCross.aarch64-multiplatform.hello.outPath":{"kbytes":"451808","system":"0.53","user":"5.10"}}
Change-Id: Ib9e04806850aa1fc4e66e2a042703986440a7b4e
Reviewed-on: https://cl.tvl.fyi/c/depot/+/10254
Reviewed-by: tazjin <tazjin@tvl.su>
Autosubmit: Adam Joseph <adam@westernsemico.com>
Tested-by: BuildkiteCI
109 lines
2.8 KiB
Rust
109 lines
2.8 KiB
Rust
//! Utilities for dealing with span tracking in the compiler and in
|
|
//! error reporting.
|
|
|
|
use codemap::{File, Span};
|
|
use rnix::ast;
|
|
use rowan::ast::AstNode;
|
|
|
|
/// Helper struct to carry information required for making a span, but
|
|
/// without actually performing the (expensive) span lookup.
|
|
///
|
|
/// This is used for tracking spans across thunk boundaries, as they
|
|
/// are frequently instantiated but spans are only used in error or
|
|
/// warning cases.
|
|
#[derive(Clone, Debug)]
|
|
pub enum LightSpan {
|
|
/// The span has already been computed and can just be used right
|
|
/// away.
|
|
Actual { span: Span },
|
|
}
|
|
|
|
impl LightSpan {
|
|
pub fn new_actual(span: Span) -> Self {
|
|
Self::Actual { span }
|
|
}
|
|
|
|
pub fn span(&self) -> Span {
|
|
match self {
|
|
LightSpan::Actual { span } => *span,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Span> for LightSpan {
|
|
fn from(span: Span) -> Self {
|
|
LightSpan::Actual { span }
|
|
}
|
|
}
|
|
|
|
/// Trait implemented by all types from which we can retrieve a span.
|
|
pub trait ToSpan {
|
|
fn span_for(&self, file: &File) -> Span;
|
|
}
|
|
|
|
impl ToSpan for Span {
|
|
fn span_for(&self, _: &File) -> Span {
|
|
*self
|
|
}
|
|
}
|
|
|
|
impl ToSpan for rnix::TextRange {
|
|
fn span_for(&self, file: &File) -> Span {
|
|
file.span
|
|
.subspan(u32::from(self.start()) as u64, u32::from(self.end()) as u64)
|
|
}
|
|
}
|
|
|
|
impl ToSpan for rnix::SyntaxToken {
|
|
fn span_for(&self, file: &File) -> Span {
|
|
self.text_range().span_for(file)
|
|
}
|
|
}
|
|
|
|
impl ToSpan for rnix::SyntaxNode {
|
|
fn span_for(&self, file: &File) -> Span {
|
|
self.text_range().span_for(file)
|
|
}
|
|
}
|
|
|
|
/// Generates a `ToSpan` implementation for a type implementing
|
|
/// `rowan::AstNode`. This is impossible to do as a blanket
|
|
/// implementation because `rustc` forbids these implementations for
|
|
/// traits from third-party crates due to a belief that semantic
|
|
/// versioning truly could work (it doesn't).
|
|
macro_rules! expr_to_span {
|
|
( $type:path ) => {
|
|
impl ToSpan for $type {
|
|
fn span_for(&self, file: &File) -> Span {
|
|
self.syntax().span_for(file)
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
expr_to_span!(ast::Expr);
|
|
expr_to_span!(ast::Apply);
|
|
expr_to_span!(ast::Assert);
|
|
expr_to_span!(ast::Attr);
|
|
expr_to_span!(ast::AttrSet);
|
|
expr_to_span!(ast::Attrpath);
|
|
expr_to_span!(ast::AttrpathValue);
|
|
expr_to_span!(ast::BinOp);
|
|
expr_to_span!(ast::HasAttr);
|
|
expr_to_span!(ast::Ident);
|
|
expr_to_span!(ast::IdentParam);
|
|
expr_to_span!(ast::IfElse);
|
|
expr_to_span!(ast::Inherit);
|
|
expr_to_span!(ast::Interpol);
|
|
expr_to_span!(ast::Lambda);
|
|
expr_to_span!(ast::LegacyLet);
|
|
expr_to_span!(ast::LetIn);
|
|
expr_to_span!(ast::List);
|
|
expr_to_span!(ast::Literal);
|
|
expr_to_span!(ast::PatBind);
|
|
expr_to_span!(ast::Path);
|
|
expr_to_span!(ast::Pattern);
|
|
expr_to_span!(ast::Select);
|
|
expr_to_span!(ast::Str);
|
|
expr_to_span!(ast::UnaryOp);
|
|
expr_to_span!(ast::With);
|