mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rustc_span: Minor improvements

Browse Source 
Introduce `{IndexNewtype,SyntaxContext}::from_u16` for convenience because small indices are sometimes encoded as `u16`.
Use `SpanData::span` instead of `Span::new` where appropriate.
Add a clarifying comment about decoding span parents.
This commit is contained in:
Vadim Petrochenkov 2024-06-16 00:53:00 +03:00
parent 12b33d36f3
commit 14da80c372
6 changed files with 33 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
compiler/rustc_index_macros/src/newtype.rs
View File

@ -205,6 +205,21 @@ impl #name {
}
}
/// Creates a new index from a given `u16`.
///
/// # Panics
///
/// Will panic if `value` exceeds `MAX`.
#[inline]
#vis const fn from_u16(value: u16) -> Self {
let value = value as u32;
assert!(value <= #max);
// SAFETY: We just checked that `value <= max`.
unsafe {
Self::from_u32_unchecked(value)
}
}
/// Creates a new index from a given `u32`.
///
/// # Safety

4
compiler/rustc_infer/src/infer/mod.rs
View File

@ -881,13 +881,13 @@ pub fn unresolved_variables(&self) -> Vec<Ty<'tcx>> {
.collect();
vars.extend(
(0..inner.int_unification_table().len())
.map(|i| ty::IntVid::from_u32(i as u32))
.map(|i| ty::IntVid::from_usize(i))
.filter(|&vid| inner.int_unification_table().probe_value(vid).is_unknown())
.map(|v| Ty::new_int_var(self.tcx, v)),
);
vars.extend(
(0..inner.float_unification_table().len())
.map(|i| ty::FloatVid::from_u32(i as u32))
.map(|i| ty::FloatVid::from_usize(i))
.filter(|&vid| inner.float_unification_table().probe_value(vid).is_unknown())
.map(|v| Ty::new_float_var(self.tcx, v)),
);

4
compiler/rustc_metadata/src/rmeta/decoder.rs
View File

@ -539,7 +539,7 @@ fn decode_span(&mut self) -> Span {
} else {
SpanData::decode(self)
};
Span::new(data.lo, data.hi, data.ctxt, data.parent)
data.span()
}
fn decode_symbol(&mut self) -> Symbol {
@ -669,7 +669,7 @@ fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> SpanData {
let lo = lo + source_file.translated_source_file.start_pos;
let hi = hi + source_file.translated_source_file.start_pos;
// Do not try to decode parent for foreign spans.
// Do not try to decode parent for foreign spans (it wasn't encoded in the first place).
SpanData { lo, hi, ctxt, parent: None }
}
}

5
compiler/rustc_span/src/hygiene.rs
View File

@ -691,6 +691,11 @@ pub(crate) const fn from_u32(raw: u32) -> SyntaxContext {
SyntaxContext(raw)
}
#[inline]
pub(crate) const fn from_u16(raw: u16) -> SyntaxContext {
SyntaxContext(raw as u32)
}
/// Extend a syntax context with a given expansion and transparency.
pub fn apply_mark(self, expn_id: ExpnId, transparency: Transparency) -> SyntaxContext {
HygieneData::with(|data| data.apply_mark(self, expn_id, transparency))

4
compiler/rustc_span/src/lib.rs
View File

@ -967,7 +967,7 @@ fn prepare_to_combine(
/// This span, but in a larger context, may switch to the metavariable span if suitable.
pub fn with_neighbor(self, neighbor: Span) -> Span {
match Span::prepare_to_combine(self, neighbor) {
Ok((this, ..)) => Span::new(this.lo, this.hi, this.ctxt, this.parent),
Ok((this, ..)) => this.span(),
Err(_) => self,
}
}
@ -1352,7 +1352,7 @@ fn fallback(span: Span, f: &mut fmt::Formatter<'_>) -> fmt::Result {
impl fmt::Debug for SpanData {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&Span::new(self.lo, self.hi, self.ctxt, self.parent), f)
fmt::Debug::fmt(&self.span(), f)
}
}

15
compiler/rustc_span/src/span_encoding.rs
View File

@ -121,7 +121,7 @@ fn data(self) -> SpanData {
SpanData {
lo: BytePos(self.lo),
hi: BytePos(self.lo.debug_strict_add(len)),
ctxt: SyntaxContext::from_u32(self.ctxt as u32),
ctxt: SyntaxContext::from_u16(self.ctxt),
parent: None,
}
}
@ -146,7 +146,7 @@ fn data(self) -> SpanData {
lo: BytePos(self.lo),
hi: BytePos(self.lo.debug_strict_add(len)),
ctxt: SyntaxContext::root(),
parent: Some(LocalDefId { local_def_index: DefIndex::from_u32(self.parent as u32) }),
parent: Some(LocalDefId { local_def_index: DefIndex::from_u16(self.parent) }),
}
}
#[inline]
@ -167,7 +167,7 @@ impl PartiallyInterned {
#[inline]
fn data(self) -> SpanData {
SpanData {
ctxt: SyntaxContext::from_u32(self.ctxt as u32),
ctxt: SyntaxContext::from_u16(self.ctxt),
..with_span_interner(|interner| interner.spans[self.index as usize])
}
}
@ -331,8 +331,7 @@ pub fn map_ctxt(self, update: impl FnOnce(SyntaxContext) -> SyntaxContext) -> Sp
match_span_kind! {
self,
InlineCtxt(span) => {
updated_ctxt32 =
update(SyntaxContext::from_u32(span.ctxt as u32)).as_u32();
updated_ctxt32 = update(SyntaxContext::from_u16(span.ctxt)).as_u32();
// Any small new context including zero will preserve the format.
if updated_ctxt32 <= MAX_CTXT {
return InlineCtxt::span(span.lo, span.len, updated_ctxt32 as u16);
@ -349,7 +348,7 @@ pub fn map_ctxt(self, update: impl FnOnce(SyntaxContext) -> SyntaxContext) -> Sp
data = span.data();
},
PartiallyInterned(span) => {
updated_ctxt32 = update(SyntaxContext::from_u32(span.ctxt as u32)).as_u32();
updated_ctxt32 = update(SyntaxContext::from_u16(span.ctxt)).as_u32();
// Any small new context excluding zero will preserve the format.
// Zero may change the format to `InlineParent` if parent and len are small enough.
if updated_ctxt32 <= MAX_CTXT && updated_ctxt32 != 0 {
@ -373,9 +372,9 @@ pub fn map_ctxt(self, update: impl FnOnce(SyntaxContext) -> SyntaxContext) -> Sp
fn inline_ctxt(self) -> Result<SyntaxContext, usize> {
match_span_kind! {
self,
InlineCtxt(span) => Ok(SyntaxContext::from_u32(span.ctxt as u32)),
InlineCtxt(span) => Ok(SyntaxContext::from_u16(span.ctxt)),
InlineParent(_span) => Ok(SyntaxContext::root()),
PartiallyInterned(span) => Ok(SyntaxContext::from_u32(span.ctxt as u32)),
PartiallyInterned(span) => Ok(SyntaxContext::from_u16(span.ctxt)),
Interned(span) => Err(span.index as usize),
}
}