rename

Author: SyMind

benches/bench_complex_replace_source.rs

@@ -9,7 +9,7 @@ pub use criterion::*;
 pub use codspeed_criterion_compat::*;
 
 use rspack_sources::{
-  stream_chunks::StreamChunks, BoxSource, CachedSource, MapOptions, ObjectPool,
+  stream_chunks::ToStream, BoxSource, CachedSource, MapOptions, ObjectPool,
   OriginalSource, ReplaceSource, Source, SourceExt,
 };
 
@@ -36737,7 +36737,7 @@ pub fn benchmark_complex_replace_source_map_cached_source_stream_chunks(
   cached_source.map(&ObjectPool::default(), &MapOptions::default());
 
   b.iter(|| {
-    black_box(cached_source.stream_chunks().stream(
+    black_box(cached_source.to_stream().chunks(
       &ObjectPool::default(),
       &MapOptions::default(),
       &mut |_chunk, _mapping| {},

src/cached_source.rs

@@ -9,7 +9,7 @@ use rustc_hash::FxHasher;
 use crate::{
   helpers::{
     stream_and_get_source_and_map, stream_chunks_of_raw_source,
-    stream_chunks_of_source_map, Chunks, GeneratedInfo, StreamChunks,
+    stream_chunks_of_source_map, Stream, GeneratedInfo, ToStream,
   },
   object_pool::ObjectPool,
   source::{IndexSourceMap, SourceValue},
@@ -182,26 +182,26 @@ impl Source for CachedSource {
   }
 }
 
-struct CachedSourceChunks<'source> {
-  chunks: Box<dyn Chunks + 'source>,
+struct CachedSourceStream<'source> {
+  stream: Box<dyn Stream + 'source>,
   cache: Arc<CachedData>,
   source: Cow<'source, str>,
 }
 
-impl<'a> CachedSourceChunks<'a> {
+impl<'a> CachedSourceStream<'a> {
   fn new(cache_source: &'a CachedSource) -> Self {
     let source = cache_source.source().into_string_lossy();
 
     Self {
-      chunks: cache_source.inner.stream_chunks(),
+      stream: cache_source.inner.to_stream(),
       cache: cache_source.cache.clone(),
       source,
     }
   }
 }
 
-impl Chunks for CachedSourceChunks<'_> {
-  fn stream<'a>(
+impl Stream for CachedSourceStream<'_> {
+  fn chunks<'a>(
     &'a self,
     object_pool: &'a ObjectPool,
     options: &MapOptions,
@@ -240,7 +240,7 @@ impl Chunks for CachedSourceChunks<'_> {
         let (generated_info, map) = stream_and_get_source_and_map(
           options,
           object_pool,
-          self.chunks.as_ref(),
+          self.stream.as_ref(),
           on_chunk,
           on_source,
           on_name,
@@ -252,9 +252,9 @@ impl Chunks for CachedSourceChunks<'_> {
   }
 }
 
-impl StreamChunks for CachedSource {
-  fn stream_chunks<'a>(&'a self) -> Box<dyn Chunks + 'a> {
-    Box::new(CachedSourceChunks::new(self))
+impl ToStream for CachedSource {
+  fn to_stream<'a>(&'a self) -> Box<dyn Stream + 'a> {
+    Box::new(CachedSourceStream::new(self))
   }
 }
 
@@ -409,8 +409,8 @@ mod tests {
     let mut on_name_count = 0;
     let generated_info = {
       let object_pool = ObjectPool::default();
-      let chunks = source.stream_chunks();
-      chunks.stream(
+      let stream = source.to_stream();
+      stream.chunks(
         &object_pool,
         &map_options,
         &mut |_chunk, _mapping| {
@@ -426,7 +426,7 @@ mod tests {
     };
 
     let cached_source = CachedSource::new(source);
-    cached_source.stream_chunks().stream(
+    cached_source.to_stream().chunks(
       &ObjectPool::default(),
       &map_options,
       &mut |_chunk, _mapping| {},
@@ -437,7 +437,7 @@ mod tests {
     let mut cached_on_chunk_count = 0;
     let mut cached_on_source_count = 0;
     let mut cached_on_name_count = 0;
-    let cached_generated_info = cached_source.stream_chunks().stream(
+    let cached_generated_info = cached_source.to_stream().chunks(
       &ObjectPool::default(),
       &map_options,
       &mut |_chunk, _mapping| {

src/concat_source.rs

@@ -8,7 +8,7 @@ use std::{
 use rustc_hash::FxHashMap as HashMap;
 
 use crate::{
-  helpers::{get_map, Chunks, GeneratedInfo, StreamChunks},
+  helpers::{get_map, Stream, GeneratedInfo, ToStream},
   linear_map::LinearMap,
   object_pool::ObjectPool,
   source::{IndexSourceMap, Mapping, OriginalLocation, Section, SectionOffset},
@@ -211,8 +211,8 @@ impl Source for ConcatSource {
     object_pool: &'a ObjectPool,
     options: &MapOptions,
   ) -> Option<SourceMap> {
-    let chunks = self.stream_chunks();
-    let result = get_map(object_pool, chunks.as_ref(), options);
+    let stream = self.to_stream();
+    let result = get_map(object_pool, stream.as_ref(), options);
     result
   }
 
@@ -334,23 +334,23 @@ impl PartialEq for ConcatSource {
 }
 impl Eq for ConcatSource {}
 
-struct ConcatSourceChunks<'source> {
-  children_chunks: Vec<Box<dyn Chunks + 'source>>,
+struct ConcatSourceStream<'source> {
+  children_chunks: Vec<Box<dyn Stream + 'source>>,
 }
 
-impl<'source> ConcatSourceChunks<'source> {
+impl<'source> ConcatSourceStream<'source> {
   fn new(concat_source: &'source ConcatSource) -> Self {
     let children = concat_source.optimized_children();
     let children_chunks = children
       .iter()
-      .map(|child| child.stream_chunks())
+      .map(|child| child.to_stream())
       .collect::<Vec<_>>();
     Self { children_chunks }
   }
 }
 
-impl Chunks for ConcatSourceChunks<'_> {
-  fn stream<'b>(
+impl Stream for ConcatSourceStream<'_> {
+  fn chunks<'b>(
     &'b self,
     object_pool: &'b ObjectPool,
     options: &MapOptions,
@@ -359,7 +359,7 @@ impl Chunks for ConcatSourceChunks<'_> {
     on_name: crate::helpers::OnName<'_, 'b>,
   ) -> GeneratedInfo {
     if self.children_chunks.len() == 1 {
-      return self.children_chunks[0].stream(
+      return self.children_chunks[0].chunks(
         object_pool,
         options,
         on_chunk,
@@ -385,7 +385,7 @@ impl Chunks for ConcatSourceChunks<'_> {
       let GeneratedInfo {
         generated_line,
         generated_column,
-      } = child_handle.stream(
+      } = child_handle.chunks(
         object_pool,
         options,
         &mut |chunk, mapping| {
@@ -525,9 +525,9 @@ impl Chunks for ConcatSourceChunks<'_> {
   }
 }
 
-impl StreamChunks for ConcatSource {
-  fn stream_chunks<'a>(&'a self) -> Box<dyn Chunks + 'a> {
-    Box::new(ConcatSourceChunks::new(self))
+impl ToStream for ConcatSource {
+  fn to_stream<'a>(&'a self) -> Box<dyn Stream + 'a> {
+    Box::new(ConcatSourceStream::new(self))
   }
 }
 

src/helpers.rs

@@ -20,15 +20,15 @@ use crate::{
 
 pub fn get_map<'a>(
   object_pool: &'a ObjectPool,
-  chunks: &'a dyn Chunks,
+  stream: &'a dyn Stream,
   options: &MapOptions,
 ) -> Option<SourceMap> {
   let mut mappings_encoder = create_encoder(options.columns);
   let mut sources: Vec<String> = Vec::new();
   let mut sources_content: Vec<Arc<str>> = Vec::new();
   let mut names: Vec<String> = Vec::new();
 
-  chunks.stream(
+  stream.chunks(
     object_pool,
     &MapOptions {
       columns: options.columns,
@@ -72,13 +72,13 @@ pub fn get_map<'a>(
 /// while building source map information. It's designed to handle the transformation
 /// of source code into mappings that connect generated code positions to original
 /// source positions.
-pub trait Chunks {
+pub trait Stream {
   /// Streams through source code chunks and generates source map information.
   ///
   /// This method processes the source code in chunks, calling the provided callbacks
   /// for each chunk, source reference, and name reference encountered. It's the core
   /// method for building source maps during code transformation.
-  fn stream<'a>(
+  fn chunks<'a>(
     &'a self,
     object_pool: &'a ObjectPool,
     options: &MapOptions,
@@ -88,10 +88,10 @@ pub trait Chunks {
   ) -> crate::helpers::GeneratedInfo;
 }
 
-/// [StreamChunks] abstraction, see [webpack-sources source.streamChunks](https://github.com/webpack/webpack-sources/blob/9f98066311d53a153fdc7c633422a1d086528027/lib/helpers/streamChunks.js#L13).
-pub trait StreamChunks {
-  /// [StreamChunks] abstraction
-  fn stream_chunks<'a>(&'a self) -> Box<dyn Chunks + 'a>;
+/// [ToStream] abstraction, see [webpack-sources source.streamChunks](https://github.com/webpack/webpack-sources/blob/9f98066311d53a153fdc7c633422a1d086528027/lib/helpers/streamChunks.js#L13).
+pub trait ToStream {
+  /// [ToStream] abstraction
+  fn to_stream<'a>(&'a self) -> Box<dyn Stream + 'a>;
 }
 
 /// [OnChunk] abstraction, see [webpack-sources onChunk](https://github.com/webpack/webpack-sources/blob/9f98066311d53a153fdc7c633422a1d086528027/lib/helpers/streamChunks.js#L13).
@@ -1229,7 +1229,7 @@ pub fn stream_chunks_of_combined_source_map<'a>(
 pub fn stream_and_get_source_and_map<'a>(
   options: &MapOptions,
   object_pool: &'a ObjectPool,
-  chunks: &'a dyn Chunks,
+  stream: &'a dyn Stream,
   on_chunk: OnChunk<'_, 'a>,
   on_source: OnSource<'_, 'a>,
   on_name: OnName<'_, 'a>,
@@ -1239,7 +1239,7 @@ pub fn stream_and_get_source_and_map<'a>(
   let mut sources_content: Vec<Arc<str>> = Vec::new();
   let mut names: Vec<String> = Vec::new();
 
-  let generated_info = chunks.stream(
+  let generated_info = stream.chunks(
     object_pool,
     options,
     &mut |chunk, mapping| {

src/lib.rs

@@ -30,11 +30,11 @@ pub use source_map_source::{
   SourceMapSource, SourceMapSourceOptions, WithoutOriginalOptions,
 };
 
-/// Reexport `StreamChunks` related types.
+/// Reexport `ToStream` related types.
 pub mod stream_chunks {
   pub use super::helpers::{
-    stream_chunks_default, Chunks, GeneratedInfo, OnChunk, OnName, OnSource,
-    StreamChunks,
+    stream_chunks_default, Stream, GeneratedInfo, OnChunk, OnName, OnSource,
+    ToStream,
   };
 }
 

src/original_source.rs

@@ -7,7 +7,7 @@ use std::{
 use crate::{
   helpers::{
     get_generated_source_info, get_map, split_into_lines,
-    split_into_potential_tokens, Chunks, GeneratedInfo, StreamChunks,
+    split_into_potential_tokens, Stream, GeneratedInfo, ToStream,
   },
   object_pool::ObjectPool,
   source::{Mapping, OriginalLocation},
@@ -73,8 +73,8 @@ impl Source for OriginalSource {
     object_pool: &ObjectPool,
     options: &MapOptions,
   ) -> Option<SourceMap> {
-    let chunks = self.stream_chunks();
-    get_map(object_pool, chunks.as_ref(), options)
+    let stream = self.to_stream();
+    get_map(object_pool, stream.as_ref(), options)
   }
 
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
@@ -111,16 +111,16 @@ impl std::fmt::Debug for OriginalSource {
   }
 }
 
-struct OriginalSourceChunks<'a>(&'a OriginalSource);
+struct OriginalSourceStream<'a>(&'a OriginalSource);
 
-impl<'source> OriginalSourceChunks<'source> {
+impl<'source> OriginalSourceStream<'source> {
   pub fn new(source: &'source OriginalSource) -> Self {
     Self(source)
   }
 }
 
-impl Chunks for OriginalSourceChunks<'_> {
-  fn stream<'b>(
+impl Stream for OriginalSourceStream<'_> {
+  fn chunks<'b>(
     &'b self,
     _object_pool: &'b ObjectPool,
     options: &MapOptions,
@@ -249,9 +249,9 @@ impl Chunks for OriginalSourceChunks<'_> {
   }
 }
 
-impl StreamChunks for OriginalSource {
-  fn stream_chunks<'a>(&'a self) -> Box<dyn Chunks + 'a> {
-    Box::new(OriginalSourceChunks::new(self))
+impl ToStream for OriginalSource {
+  fn to_stream<'a>(&'a self) -> Box<dyn Stream + 'a> {
+    Box::new(OriginalSourceStream::new(self))
   }
 }
 
@@ -365,8 +365,8 @@ mod tests {
     let source = OriginalSource::new(code, "test.js");
     let mut chunks = vec![];
     let object_pool = ObjectPool::default();
-    let handle = source.stream_chunks();
-    let generated_info = handle.stream(
+    let handle = source.to_stream();
+    let generated_info = handle.chunks(
       &object_pool,
       &MapOptions::default(),
       &mut |chunk, mapping| {