swc-project/swc
1
1
Fork 0
mirror of https://github.com/swc-project/swc.git synced 2024-11-22 06:46:41 +03:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

fix(es/plugin): Revert #9696 (#9717)

Browse Source
This commit is contained in:
Donny/강동윤 2024-11-06 15:26:35 +09:00 committed by GitHub
parent 6194044b42
commit 772f023fd2
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 39 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.changeset/clever-jobs-hug.md Normal file
View File

@ -0,0 +1,5 @@
---
swc_common: major
---
fix(es/plugin): Revert #9696

115
crates/swc_common/src/cache.rs
View File

@ -1,115 +0,0 @@
use std::ops::Deref;
use once_cell::sync::OnceCell;
/// Wrapper for [OnceCell] with support for [rkyv].
#[derive(Clone, Debug)]
pub struct CacheCell<T>(OnceCell<T>);
impl<T> Deref for CacheCell<T> {
type Target = OnceCell<T>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<T> CacheCell<T> {
pub fn new() -> Self {
Self(OnceCell::new())
}
}
impl<T> From<T> for CacheCell<T> {
fn from(value: T) -> Self {
Self(OnceCell::from(value))
}
}
impl<T> Default for CacheCell<T> {
fn default() -> Self {
Self::new()
}
}
#[cfg(feature = "rkyv-impl")]
mod rkyv_impl {
use std::{hint::unreachable_unchecked, ptr};
use rkyv::{
option::ArchivedOption, out_field, Archive, Archived, Deserialize, Fallible, Resolver,
Serialize,
};
use super::*;
#[allow(dead_code)]
#[repr(u8)]
enum ArchivedOptionTag {
None,
Some,
}
#[repr(C)]
struct ArchivedOptionVariantNone(ArchivedOptionTag);
#[repr(C)]
struct ArchivedOptionVariantSome<T>(ArchivedOptionTag, T);
impl<T> Archive for CacheCell<T>
where
T: Archive,
{
type Archived = Archived<Option<T>>;
type Resolver = Resolver<Option<T>>;
unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
match resolver {
None => {
let out = out.cast::<ArchivedOptionVariantNone>();
ptr::addr_of_mut!((*out).0).write(ArchivedOptionTag::None);
}
Some(resolver) => {
let out = out.cast::<ArchivedOptionVariantSome<T::Archived>>();
ptr::addr_of_mut!((*out).0).write(ArchivedOptionTag::Some);
let v = self.0.get();
let value = if let Some(value) = v.as_ref() {
value
} else {
unreachable_unchecked();
};
let (fp, fo) = out_field!(out.1);
value.resolve(pos + fp, resolver, fo);
}
}
}
}
impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for CacheCell<T> {
#[inline]
fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
self.0
.get()
.map(|value| value.serialize(serializer))
.transpose()
}
}
impl<T: Archive, D: Fallible + ?Sized> Deserialize<CacheCell<T>, D> for ArchivedOption<T::Archived>
where
T::Archived: Deserialize<T, D>,
{
#[inline]
fn deserialize(&self, deserializer: &mut D) -> Result<CacheCell<T>, D::Error> {
match self {
ArchivedOption::Some(value) => {
let v = value.deserialize(deserializer)?;
Ok(CacheCell::from(v))
}
ArchivedOption::None => Ok(CacheCell::new()),
}
}
}
}

5
crates/swc_common/src/lib.rs
View File

@ -51,13 +51,14 @@ pub use self::{
source_map::{FileLines, FileLoader, FilePathMapping, SourceMap, SpanSnippetError},
syntax_pos::LineCol,
};
#[doc(hidden)]
pub mod private;
/// A trait for ast nodes.
pub trait AstNode: Debug + PartialEq + Clone + Spanned {
const TYPE: &'static str;
}
pub mod cache;
pub mod collections;
pub mod comments;
mod eq;
@ -67,8 +68,6 @@ pub mod iter;
pub mod pass;
pub mod plugin;
mod pos;
#[doc(hidden)]
pub mod private;
mod rustc_data_structures;
pub mod serializer;
pub mod source_map;

26
crates/swc_common/src/source_map.rs
View File

@ -316,11 +316,10 @@ impl SourceMap {
let line_info = self.lookup_line_with(fm, pos);
match line_info {
Ok(SourceFileAndLine { sf: f, line: a }) => {
let analysis = f.analyze();
let chpos = self.bytepos_to_file_charpos_with(&f, pos);
let line = a + 1; // Line numbers start at 1
let linebpos = f.analyze().lines[a];
let linebpos = f.lines[a];
assert!(
pos >= linebpos,
"{}: bpos = {:?}; linebpos = {:?};",
@ -333,17 +332,16 @@ impl SourceMap {
let col = chpos - linechpos;
let col_display = {
let start_width_idx = analysis
let start_width_idx = f
.non_narrow_chars
.binary_search_by_key(&linebpos, |x| x.pos())
.unwrap_or_else(|x| x);
let end_width_idx = analysis
let end_width_idx = f
.non_narrow_chars
.binary_search_by_key(&pos, |x| x.pos())
.unwrap_or_else(|x| x);
let special_chars = end_width_idx - start_width_idx;
let non_narrow: usize = analysis.non_narrow_chars
[start_width_idx..end_width_idx]
let non_narrow: usize = f.non_narrow_chars[start_width_idx..end_width_idx]
.iter()
.map(|x| x.width())
.sum();
@ -369,15 +367,14 @@ impl SourceMap {
})
}
Err(f) => {
let analysis = f.analyze();
let chpos = self.bytepos_to_file_charpos(pos)?;
let col_display = {
let end_width_idx = analysis
let end_width_idx = f
.non_narrow_chars
.binary_search_by_key(&pos, |x| x.pos())
.unwrap_or_else(|x| x);
let non_narrow: usize = analysis.non_narrow_chars[0..end_width_idx]
let non_narrow: usize = f.non_narrow_chars[0..end_width_idx]
.iter()
.map(|x| x.width())
.sum();
@ -1031,11 +1028,11 @@ impl SourceMap {
) -> u32 {
let mut total_extra_bytes = state.total_extra_bytes;
let mut index = state.mbc_index;
let analysis = file.analyze();
if bpos >= state.pos {
let range = index..analysis.multibyte_chars.len();
let range = index..file.multibyte_chars.len();
for i in range {
let mbc = &analysis.multibyte_chars[i];
let mbc = &file.multibyte_chars[i];
debug!("{}-byte char at {:?}", mbc.bytes, mbc.pos);
if mbc.pos >= bpos {
break;
@ -1055,7 +1052,7 @@ impl SourceMap {
} else {
let range = 0..index;
for i in range.rev() {
let mbc = &analysis.multibyte_chars[i];
let mbc = &file.multibyte_chars[i];
debug!("{}-byte char at {:?}", mbc.bytes, mbc.pos);
if mbc.pos < bpos {
break;
@ -1325,8 +1322,7 @@ impl SourceMap {
None => continue,
};
let analysis = f.analyze();
let linebpos = analysis.lines[line as usize];
let linebpos = f.lines[line as usize];
debug_assert!(
pos >= linebpos,
"{}: bpos = {:?}; linebpos = {:?};",

63
crates/swc_common/src/syntax_pos.rs
View File

@ -16,7 +16,7 @@ use url::Url;
use self::hygiene::MarkData;
pub use self::hygiene::{Mark, SyntaxContext};
use crate::{cache::CacheCell, rustc_data_structures::stable_hasher::StableHasher, sync::Lrc};
use crate::{rustc_data_structures::stable_hasher::StableHasher, sync::Lrc};
mod analyze_source_file;
pub mod hygiene;
@ -827,26 +827,14 @@ pub struct SourceFile {
pub start_pos: BytePos,
/// The end position of this source in the `SourceMap`
pub end_pos: BytePos,
/// A hash of the filename, used for speeding up the incr. comp. hashing.
pub name_hash: u128,
lazy: CacheCell<SourceFileAnalysis>,
}
#[cfg_attr(
any(feature = "rkyv-impl"),
derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
)]
#[cfg_attr(feature = "rkyv-impl", archive(check_bytes))]
#[cfg_attr(feature = "rkyv-impl", archive_attr(repr(C)))]
#[derive(Clone)]
pub struct SourceFileAnalysis {
/// Locations of lines beginnings in the source code
pub lines: Vec<BytePos>,
/// Locations of multi-byte characters in the source code
pub multibyte_chars: Vec<MultiByteChar>,
/// Width of characters that are not narrow in the source code
pub non_narrow_chars: Vec<NonNarrowChar>,
/// A hash of the filename, used for speeding up the incr. comp. hashing.
pub name_hash: u128,
}
impl fmt::Debug for SourceFile {
@ -900,6 +888,9 @@ impl SourceFile {
};
let end_pos = start_pos.to_usize() + src.len();
let (lines, multibyte_chars, non_narrow_chars) =
analyze_source_file::analyze_source_file(&src[..], start_pos);
SourceFile {
name,
name_was_remapped,
@ -909,16 +900,17 @@ impl SourceFile {
src_hash,
start_pos,
end_pos: SmallPos::from_usize(end_pos),
lines,
multibyte_chars,
non_narrow_chars,
name_hash,
lazy: CacheCell::new(),
}
}
/// Return the BytePos of the beginning of the current line.
pub fn line_begin_pos(&self, pos: BytePos) -> BytePos {
let line_index = self.lookup_line(pos).unwrap();
let analysis = self.analyze();
analysis.lines[line_index]
self.lines[line_index]
}
/// Get a line from the list of pre-computed line-beginnings.
@ -936,8 +928,7 @@ impl SourceFile {
}
let begin = {
let analysis = self.analyze();
let line = analysis.lines.get(line_number)?;
let line = self.lines.get(line_number)?;
let begin: BytePos = *line - self.start_pos;
begin.to_usize()
};
@ -954,8 +945,7 @@ impl SourceFile {
}
pub fn count_lines(&self) -> usize {
let analysis = self.analyze();
analysis.lines.len()
self.lines.len()
}
/// Find the line containing the given position. The return value is the
@ -963,13 +953,12 @@ impl SourceFile {
/// number. If the `source_file` is empty or the position is located before
/// the first line, `None` is returned.
pub fn lookup_line(&self, pos: BytePos) -> Option<usize> {
let analysis = self.analyze();
if analysis.lines.is_empty() {
if self.lines.is_empty() {
return None;
}
let line_index = lookup_line(&analysis.lines, pos);
assert!(line_index < analysis.lines.len() as isize);
let line_index = lookup_line(&self.lines[..], pos);
assert!(line_index < self.lines.len() as isize);
if line_index >= 0 {
Some(line_index as usize)
} else {
@ -982,13 +971,11 @@ impl SourceFile {
return (self.start_pos, self.end_pos);
}
let analysis = self.analyze();
assert!(line_index < analysis.lines.len());
if line_index == (analysis.lines.len() - 1) {
(analysis.lines[line_index], self.end_pos)
assert!(line_index < self.lines.len());
if line_index == (self.lines.len() - 1) {
(self.lines[line_index], self.end_pos)
} else {
(analysis.lines[line_index], analysis.lines[line_index + 1])
(self.lines[line_index], self.lines[line_index + 1])
}
}
@ -996,18 +983,6 @@ impl SourceFile {
pub fn contains(&self, byte_pos: BytePos) -> bool {
byte_pos >= self.start_pos && byte_pos <= self.end_pos
}
pub fn analyze(&self) -> &SourceFileAnalysis {
self.lazy.get_or_init(|| {
let (lines, multibyte_chars, non_narrow_chars) =
analyze_source_file::analyze_source_file(&self.src[..], self.start_pos);
SourceFileAnalysis {
lines,
multibyte_chars,
non_narrow_chars,
}
})
}
}
/// Remove utf-8 BOM if any.

2
crates/swc_error_reporters/src/lib.rs
View File

@ -131,7 +131,7 @@ impl SourceCode for MietteSourceCode<'_> {
}
let loc = self.0.lookup_char_pos(span.lo());
let line_count = loc.file.analyze().lines.len();
let line_count = loc.file.lines.len();
let name = if self.1.skip_filename {
None

2
crates/swc_estree_compat/src/swcify/ctx.rs
View File

@ -12,7 +12,7 @@ pub struct Context {
impl Context {
fn locate_line_col(&self, loc: LineCol) -> BytePos {
if let Some(&line_start) = self.fm.analyze().lines.get(loc.line) {
if let Some(&line_start) = self.fm.lines.get(loc.line) {
line_start + BytePos(loc.column as _)
} else {
BytePos(0)