Unverified Commit 4bd51aff authored by vercel-fleet-prod[bot]'s avatar vercel-fleet-prod[bot] Committed by GitHub

turbopack: keep chunk compositions stable across item edits

Co-authored-by: 's avatarLuke Sandberg <210140+lukesandberg@users.noreply.github.com>
parent 2a3a12cc
......@@ -50,7 +50,7 @@ use turbo_rcstr::RcStr;
use turbo_tasks::{NonLocalValue, ResolvedVc, ValueToString, Vc, turbobail, turbofmt};
pub use crate::{
cell_rope::{CellRope, CellRopeBuilder},
cell_rope::{CellRope, CellRopeBuilder, CellRopePart},
content::{
File, FileContent, FileJsonContent, FileLine, FileLinesContent, FileMeta, LinkContent,
LinkTarget, Permissions, PersistedFileContent, WriteLinkContent, WriteLinkTargetType,
......
......@@ -8,7 +8,7 @@ use turbo_tasks_fs::FileContent;
use turbopack_core::{
asset::AssetContent,
chunk::{ChunkingContext, ModuleId},
code_builder::{Code, ComposedCode, ComposedCodeBuilder},
code_builder::{Code, CodeComposition, CodeCompositionBuilder, ComposedCode},
output::OutputAsset,
source_map::{GenerateSourceMap, SourceMapAsset},
version::{MergeableVersionedContent, Version, VersionedContent, VersionedContentMerger},
......@@ -62,9 +62,27 @@ impl EcmascriptBrowserChunkContent {
Ok(self.composed_code().await?.code())
}
/// The chunk's code, composed from its chunk items' cells (see [`ComposedCode`]).
/// The chunk's code, built from its [`composition`](Self::composition).
#[turbo_tasks::function]
async fn composed_code(self: Vc<Self>) -> Result<Vc<ComposedCode>> {
let this = self.await?;
let source_maps = *this
.chunking_context
.reference_chunk_source_maps(*ResolvedVc::upcast(this.chunk))
.await?;
let minification =
ChunkMinification::for_chunking_context(Vc::upcast(*this.chunking_context)).await?;
Ok(minification
.finish_composition(self.composition().to_resolved().await?, source_maps)
.await?
.cell())
}
/// The chunk's structure: its scaffolding, and references to its chunk items' cells (see
/// [`CodeComposition`]). Doesn't read the chunk items' bytes, so it isn't recomputed (and its
/// persisted body isn't rewritten) when only those change.
#[turbo_tasks::function]
async fn composition(self: Vc<Self>) -> Result<Vc<CodeComposition>> {
let this = self.await?;
let source_maps = *this
.chunking_context
......@@ -88,7 +106,7 @@ impl EcmascriptBrowserChunkContent {
Either::Right(CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR)
}
};
let mut code = ComposedCodeBuilder::new(
let mut code = CodeCompositionBuilder::new(
source_maps,
*this.chunking_context.debug_ids_enabled().await?,
);
......@@ -144,10 +162,7 @@ impl EcmascriptBrowserChunkContent {
code += suffix;
}
let (code, parts) = code.build();
Ok(minification
.finish_composed_chunk(code, parts, source_maps)?
.cell())
Ok(code.build().cell())
}
#[turbo_tasks::function]
......
#![feature(arbitrary_self_types)]
#![feature(arbitrary_self_types_pointers)]
#![allow(clippy::needless_return)] // tokio macro-generated code doesn't respect this
//! A composed output (see `CodeComposition`) across persisted sessions with the GC enabled: the
//! written files reference other tasks' cells, so those must stay alive, restore correctly, and
//! keep producing the current bytes after edits and collections.
use std::{fs::read_to_string, path::Path, sync::Arc};
use anyhow::Result;
use turbo_rcstr::{RcStr, rcstr};
use turbo_tasks::{
Effects, GcRoot, OperationVc, ResolvedVc, State, TurboTasks, Vc,
read_strongly_consistent_and_apply_effects, take_effects,
};
use turbo_tasks_backend::{
BackendOptions, BackingStorageOptions, EvictionMode, GitVersionInfo, StorageMode,
TurboTasksBackend,
};
use turbo_tasks_fs::{DiskFileSystem, FileContent, FileSystem, rope::Rope};
use turbopack_core::{
code_builder::{CodeBuilder, CodeCells, CodeComposition, CodeCompositionBuilder, ComposedCode},
source_map::SourceMapAsset,
};
fn open_tt(path: &Path) -> Arc<TurboTasks<TurboTasksBackend>> {
TurboTasks::new(TurboTasksBackend::new(
BackendOptions {
num_workers: Some(2),
small_preallocation: true,
storage_mode: Some(StorageMode::ReadWriteOnShutdown),
eviction_mode: EvictionMode::Full,
gc: Some(true),
..Default::default()
},
turbo_tasks_backend::turbo_backing_storage(
path,
&GitVersionInfo {
describe: "test-unversioned",
dirty: false,
},
BackingStorageOptions {
is_short_session: true,
skip_compaction: true,
..Default::default()
},
)
.unwrap()
.0,
))
}
/// The edited text, and which of two identical pieces fills the second slot.
#[turbo_tasks::value]
struct Input {
text: State<RcStr>,
use_twin: State<bool>,
}
#[turbo_tasks::function(operation, root)]
fn input_operation() -> Vc<Input> {
Input {
text: State::new(rcstr!("one")),
use_twin: State::new(false),
}
.cell()
}
#[turbo_tasks::function(operation, root)]
fn disk_fs_operation(root: RcStr) -> Vc<DiskFileSystem> {
DiskFileSystem::new(rcstr!("out"), Vc::cell(root))
}
/// A module factory. Slot 0 is the edited one; slots 1 and 2 are distinct tasks with identical
/// bytes.
#[turbo_tasks::function]
async fn piece(input: ResolvedVc<Input>, slot: u32) -> Result<Vc<CodeCells>> {
let text = match slot {
0 => input.await?.text.get().clone(),
_ => rcstr!("fixed"),
};
let mut code = CodeBuilder::new(false, false);
code += "(()=>{";
code.push_source(&Rope::from(text.to_string()), None::<Rope>);
code += "})";
Ok(*code.build().resolved_code_cells())
}
/// What a chunk item's entry exposes to the composition: references only.
#[turbo_tasks::value(shared)]
struct PieceRef {
cells: ResolvedVc<CodeCells>,
code: ResolvedVc<Rope>,
}
#[turbo_tasks::function]
async fn piece_ref(input: ResolvedVc<Input>, slot: u32) -> Result<Vc<PieceRef>> {
let cells = piece(*input, slot).to_resolved().await?;
Ok(PieceRef {
cells,
code: cells.await?.code(),
}
.cell())
}
/// The structure-only task, like a chunk content's `composition`.
#[turbo_tasks::function]
async fn composition(input: ResolvedVc<Input>, debug_id: bool) -> Result<Vc<CodeComposition>> {
let second = if *input.await?.use_twin.get() { 2 } else { 1 };
let mut builder = CodeCompositionBuilder::new(false, debug_id);
builder += "[";
for slot in [0, second] {
if slot != 0 {
builder += ",";
}
let piece = piece_ref(*input, slot).await?;
builder.push_code_cells(piece.cells, piece.code);
}
builder += "]";
Ok(builder.build().cell())
}
#[turbo_tasks::function]
async fn composed(input: ResolvedVc<Input>, debug_id: bool) -> Result<Vc<ComposedCode>> {
let composition = composition(*input, debug_id).to_resolved().await?;
let code = composition.await?.build_code().await?;
Ok(ComposedCode::new(code, Some(composition)).cell())
}
/// Like a chunk content's `content`. Without a debug id the file is the composition's body
/// itself; with one it's a rope nesting the body between the debug id comments.
#[turbo_tasks::function]
async fn content(input: ResolvedVc<Input>, debug_id: bool) -> Result<Vc<FileContent>> {
let file = composed(*input, debug_id)
.await?
.to_file_with_magic_comments(|| -> Vc<SourceMapAsset> {
unreachable!("the pieces have no source maps")
})
.await?;
Ok(FileContent::Content(file).cell())
}
#[turbo_tasks::function(operation, root)]
async fn write_operation(fs: ResolvedVc<DiskFileSystem>, input: ResolvedVc<Input>) -> Result<()> {
let root = fs.root().owned().await?;
for (name, debug_id) in [("direct.js", false), ("nested.js", true)] {
root.join(name)?.write(content(*input, debug_id)).await?;
}
Ok(())
}
#[turbo_tasks::function(operation, root)]
async fn extract_effects_operation(op: OperationVc<()>) -> Result<Vc<Effects>> {
let _ = op.resolve().strongly_consistent().await?;
Ok(take_effects(op).await?.cell())
}
/// Writes both files, and returns the operation so a session can pin it as its GC root.
async fn write(
fs: ResolvedVc<DiskFileSystem>,
input: ResolvedVc<Input>,
) -> Result<OperationVc<Effects>> {
let op = extract_effects_operation(write_operation(fs, input));
read_strongly_consistent_and_apply_effects(op, |e| e).await?;
Ok(op)
}
fn assert_files(out: &Path, text: &str) {
let body = format!("[(()=>{{{text}}}),(()=>{{fixed}})]");
assert_eq!(read_to_string(out.join("direct.js")).unwrap(), body);
let nested = read_to_string(out.join("nested.js")).unwrap();
assert!(
nested.contains(&format!("\n{body}\n\n//# debugId=")),
"unexpected nested.js: {nested}"
);
}
/// Runs session `n` (see [`composed_files_survive_restores_edits_and_gc`]), then GC with the
/// session's write operation pinned as its root, and persists the session. Returns the number of
/// tasks the GC collected.
async fn session(cache: &Path, out: &Path, n: u32) -> usize {
let tt = open_tt(cache);
let root: RcStr = out.to_str().unwrap().into();
let check = out.to_path_buf();
let pinned = turbo_tasks::run_once(tt.clone(), async move {
let fs = disk_fs_operation(root)
.resolve()
.strongly_consistent()
.await?;
let input_op = input_operation();
let input = input_op.resolve().strongly_consistent().await?;
let input_value = input_op.read_strongly_consistent().await?;
let op = match n {
// Cold.
1 => {
let op = write(fs, input).await?;
assert_files(&check, "one");
op
}
// Restored, then a content edit, then a structural change with equal bytes (the
// second slot moves to another task, the old one becomes collectible).
2 => {
let _ = write(fs, input).await?;
assert_files(&check, "one");
input_value.text.set(rcstr!("a longer text"));
let _ = write(fs, input).await?;
assert_files(&check, "a longer text");
input_value.use_twin.set(true);
let op = write(fs, input).await?;
assert_files(&check, "a longer text");
op
}
// Restored after the collection, with the files deleted: writing them again reads
// every referenced cell. Then edits keep working on restored state.
3 => {
input_value.text.set(rcstr!("a longer text"));
input_value.use_twin.set(true);
let op = write(fs, input).await?;
assert_files(&check, "a longer text");
input_value.text.set(rcstr!("two"));
let op2 = write(fs, input).await?;
assert_files(&check, "two");
assert_eq!(op, op2);
op
}
_ => unreachable!(),
};
anyhow::Ok(op)
})
.await
.unwrap();
let pin = GcRoot::pin(tt.clone(), pinned);
let mut collected = 0;
for _ in 0..3 {
collected += tt.backend().gc_for_testing(&tt);
}
tt.backend().snapshot_and_evict_for_testing(&tt);
drop(pin);
tt.stop_and_wait().await;
collected
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn composed_files_survive_restores_edits_and_gc() {
let cache = tempfile::tempdir().unwrap();
let out = tempfile::tempdir().unwrap();
session(cache.path(), out.path(), 1).await;
// The second slot's previous piece and its entry (slot 1) are no longer used.
assert!(session(cache.path(), out.path(), 2).await >= 2);
std::fs::remove_file(out.path().join("direct.js")).unwrap();
std::fs::remove_file(out.path().join("nested.js")).unwrap();
session(cache.path(), out.path(), 3).await;
}
......@@ -5,9 +5,10 @@ use turbo_rcstr::RcStr;
use turbo_tasks::{
NonLocalValue, ReadRef, ResolvedVc, TryJoinIterExt, ValueToString, Vc, debug::ValueDebugFormat,
};
use turbo_tasks_fs::rope::Rope;
use turbopack_core::{
chunk::{ChunkItem, ChunkItemExt, MangleType, MinifyType, ModuleId},
code_builder::{Code, CodeCells},
code_builder::CodeCells,
};
use crate::{
......@@ -51,8 +52,8 @@ async fn code_module_id_and_path(
};
Ok(CodeModuleIdAndPath {
id: item.chunk_item.id().await?,
code: cells.to_code().await?,
cells: Some(cells.await?),
code: cells.await?.code(),
cells,
path: item.chunk_item.asset_ident().to_string().owned().await?,
strict: factory.strict,
})
......@@ -75,13 +76,16 @@ async fn minified_module_factory(
Ok(*minified.resolved_code_cells())
}
/// A chunk item's module factory, as referenced by a chunk. Holds only references to the
/// factory's cells, not its bytes, so it stays equal when only the factory's bytes change (and a
/// chunk's composition, which depends on it, isn't recomputed).
#[derive(Clone, PartialEq, Eq, ValueDebugFormat, NonLocalValue)]
pub struct CodeModuleIdAndPath {
pub id: ModuleId,
pub code: ReadRef<Code>,
/// The persisted cells `code` was read from, so that chunks can reference them. Always set
/// outside of tests.
pub cells: Option<ReadRef<CodeCells>>,
/// The factory's persisted cells.
pub cells: ResolvedVc<CodeCells>,
/// The cell holding the factory's bytes ([`CodeCells::code`]).
pub code: ResolvedVc<Rope>,
pub path: RcStr,
pub strict: bool,
}
......
......@@ -5,7 +5,7 @@ use either::Either;
use turbo_tasks::{ResolvedVc, TryJoinIterExt, Vc};
use turbopack_core::{
chunk::{ChunkItem, ChunkItems, ChunkingContext, MangleType, MinifyType, batch_info},
code_builder::{Code, ComposedCode, ComposedCodeParts},
code_builder::{CodeComposition, ComposedCode},
};
use crate::{
......@@ -57,22 +57,21 @@ impl ChunkMinification {
}
}
/// Applies the whole-chunk minification, if any, to a chunk assembled with a
/// [`ComposedCodeBuilder`](turbopack_core::code_builder::ComposedCodeBuilder). The result
/// references the chunk items' cells, unless the chunk is minified as a whole (which
/// produces new, flat code).
pub fn finish_composed_chunk(
/// Builds a chunk's code from its [`CodeComposition`] and applies the whole-chunk
/// minification, if any. The result references the chunk items' cells through the
/// composition, unless the chunk is minified as a whole (which produces new, flat code).
pub async fn finish_composition(
self,
code: Code,
parts: ComposedCodeParts,
composition: ResolvedVc<CodeComposition>,
source_maps: bool,
) -> Result<ComposedCode> {
let code = composition.await?.build_code().await?;
Ok(match self {
ChunkMinification::WholeChunk { mangle } => {
ComposedCode::new(minify(code, source_maps, mangle)?, None)
}
ChunkMinification::None | ChunkMinification::PerItem { .. } => {
ComposedCode::new(code, Some(parts))
ComposedCode::new(code, Some(composition))
}
})
}
......
use std::{io::Write, ops::AddAssign};
use anyhow::Result;
use turbopack_core::code_builder::{CodeBuilder, ComposedCodeBuilder};
use turbopack_core::{chunk::ModuleId, code_builder::CodeCompositionBuilder};
use crate::{chunk::CodeModuleIdAndPath, utils::StringifyJs};
/// Where [`write_module_factories`] writes to.
pub trait ModuleFactorySink: Write + AddAssign<&'static str> {
/// Appends a factory. With `without_strict_directive`, its recorded `"use strict"` directive
/// is left out (see [`CodeBuilder::push_code_without_strict_directive`]).
fn push_factory(&mut self, item: &CodeModuleIdAndPath, without_strict_directive: bool);
/// A module factory placed in a chunk by [`write_module_factories`].
pub trait ModuleFactory {
fn id(&self) -> &ModuleId;
fn strict(&self) -> bool;
}
impl ModuleFactorySink for CodeBuilder {
fn push_factory(&mut self, item: &CodeModuleIdAndPath, without_strict_directive: bool) {
if without_strict_directive {
self.push_code_without_strict_directive(&item.code);
} else {
self.push_code(&item.code);
}
impl ModuleFactory for CodeModuleIdAndPath {
fn id(&self) -> &ModuleId {
&self.id
}
fn strict(&self) -> bool {
self.strict
}
}
/// Where [`write_module_factories`] writes to.
pub trait ModuleFactorySink<F>: Write + AddAssign<&'static str> {
/// Appends a factory. With `without_strict_directive`, a strict factory's recorded
/// `"use strict"` directive may be left out, because the layout already places it in a
/// strict context.
fn push_factory(&mut self, factory: &F, without_strict_directive: bool);
}
/// References each factory's cells, so that the chunk's persisted representation doesn't copy
/// them.
impl ModuleFactorySink for ComposedCodeBuilder {
fn push_factory(&mut self, item: &CodeModuleIdAndPath, without_strict_directive: bool) {
if without_strict_directive && item.code.strict_directive().is_some() {
// The cells hold the directive, so the bytes without it are inlined.
self.push_code_without_strict_directive(&item.code);
return;
}
match &item.cells {
Some(cells) => self.push_code_cells(cells, &item.code),
None => self.push_code(&item.code),
}
/// them, and doesn't depend on their bytes.
impl ModuleFactorySink<CodeModuleIdAndPath> for CodeCompositionBuilder {
fn push_factory(&mut self, factory: &CodeModuleIdAndPath, _without_strict_directive: bool) {
self.push_code_cells(factory.cells, factory.code);
}
}
......@@ -71,10 +70,10 @@ pub enum StrictFactoryMode {
/// The chunk items must be sorted with all strict items first, see
/// [`EcmascriptChunkContent::chunk_item_code_module_ids_and_paths`](crate::chunk::EcmascriptChunkContent::chunk_item_code_module_ids_and_paths).
pub fn strict_factory_mode(
chunk_items: &[CodeModuleIdAndPath],
chunk_items: &[impl ModuleFactory],
supports_arrow_functions: bool,
) -> StrictFactoryMode {
let strict = chunk_items.iter().filter(|item| item.strict).count();
let strict = chunk_items.iter().filter(|item| item.strict()).count();
let non_strict = chunk_items.len() - strict;
if strict == 0 {
return StrictFactoryMode::Flat;
......@@ -127,34 +126,34 @@ const fn mixed_prefix(supports_arrow_functions: bool) -> &'static str {
///
/// Every strict factory carries its own `"use strict"` directive. Where the layout places it in
/// a strict context anyway (inside the mixed IIFE, or in an all-strict chunk), the directive is
/// left out (see [`CodeBuilder::push_code_without_strict_directive`]).
/// left out (see `ModuleFactorySink::push_factory`).
///
/// The chunk items must be sorted with all strict items first.
pub fn write_module_factories(
code: &mut impl ModuleFactorySink,
chunk_items: &[CodeModuleIdAndPath],
pub fn write_module_factories<F: ModuleFactory>(
code: &mut impl ModuleFactorySink<F>,
chunk_items: &[F],
mode: StrictFactoryMode,
supports_arrow_functions: bool,
) -> Result<()> {
debug_assert!(
chunk_items.is_sorted_by_key(|item| !item.strict),
chunk_items.is_sorted_by_key(|item| !item.strict()),
"strict chunk items must come first"
);
let mut in_strict_group = false;
for (i, item) in chunk_items.iter().enumerate() {
if mode == StrictFactoryMode::Mixed && item.strict != in_strict_group {
if mode == StrictFactoryMode::Mixed && item.strict() != in_strict_group {
if in_strict_group {
*code += MIXED_SUFFIX;
*code += ",";
} else {
*code += mixed_prefix(supports_arrow_functions);
}
in_strict_group = item.strict;
in_strict_group = item.strict();
} else if i > 0 {
*code += ",";
}
write!(code, "{},", StringifyJs(&item.id))?;
code.push_factory(item, item.strict && mode != StrictFactoryMode::Flat);
write!(code, "{},", StringifyJs(item.id()))?;
code.push_factory(item, item.strict() && mode != StrictFactoryMode::Flat);
}
if in_strict_group {
*code += MIXED_SUFFIX;
......@@ -164,8 +163,7 @@ pub fn write_module_factories(
#[cfg(test)]
mod tests {
use turbo_tasks::ReadRef;
use turbopack_core::{chunk::ModuleId, code_builder::STRICT_DIRECTIVE};
use turbopack_core::code_builder::{CodeBuilder, STRICT_DIRECTIVE};
use super::*;
......@@ -196,26 +194,45 @@ mod tests {
);
}
/// A strict factory `s` carries a recorded directive, a non-strict one `n` does not.
fn item(id: u64, strict: bool) -> CodeModuleIdAndPath {
let mut code = CodeBuilder::new(false, false);
if strict {
code += "(()=>{";
code.push_strict_directive();
code += "s})";
} else {
code += "(()=>{n})";
struct TestFactory {
id: ModuleId,
strict: bool,
}
impl ModuleFactory for TestFactory {
fn id(&self) -> &ModuleId {
&self.id
}
fn strict(&self) -> bool {
self.strict
}
CodeModuleIdAndPath {
}
/// Writes a strict factory as `(()=>{"use strict";s})`, leaving out the directive when asked
/// to, and a non-strict one as `(()=>{n})`.
impl ModuleFactorySink<TestFactory> for CodeBuilder {
fn push_factory(&mut self, factory: &TestFactory, without_strict_directive: bool) {
*self += "(()=>{";
if factory.strict {
if !without_strict_directive {
*self += STRICT_DIRECTIVE;
}
*self += "s})";
} else {
*self += "n})";
}
}
}
fn item(id: u64, strict: bool) -> TestFactory {
TestFactory {
id: ModuleId::Number(id),
code: ReadRef::new_owned(code.build()),
cells: None,
path: Default::default(),
strict,
}
}
fn write(items: &[CodeModuleIdAndPath]) -> String {
fn write(items: &[TestFactory]) -> String {
let mode = strict_factory_mode(items, true);
let wrapper = strict_chunk_wrapper(mode, true);
let mut code = CodeBuilder::new(false, false);
......
......@@ -4,7 +4,7 @@ use turbo_tasks_fs::FileContent;
use turbopack_core::{
asset::AssetContent,
chunk::ChunkingContext,
code_builder::{Code, ComposedCode, ComposedCodeBuilder},
code_builder::{Code, CodeComposition, CodeCompositionBuilder, ComposedCode},
output::OutputAsset,
source_map::{GenerateSourceMap, SourceMapAsset},
version::{MergeableVersionedContent, Version, VersionedContent, VersionedContentMerger},
......@@ -57,16 +57,34 @@ impl EcmascriptNodeChunkContent {
Ok(self.composed_code().await?.code())
}
/// The chunk's code, composed from its chunk items' cells (see [`ComposedCode`]).
/// The chunk's code, built from its [`composition`](Self::composition).
#[turbo_tasks::function]
async fn composed_code(&self) -> Result<Vc<ComposedCode>> {
async fn composed_code(self: Vc<Self>) -> Result<Vc<ComposedCode>> {
let this = self.await?;
let source_maps = *this
.chunking_context
.reference_chunk_source_maps(*ResolvedVc::upcast(this.chunk))
.await?;
let minification =
ChunkMinification::for_chunking_context(Vc::upcast(*this.chunking_context)).await?;
Ok(minification
.finish_composition(self.composition().to_resolved().await?, source_maps)
.await?
.cell())
}
/// The chunk's structure: its scaffolding, and references to its chunk items' cells (see
/// [`CodeComposition`]). Doesn't read the chunk items' bytes, so it isn't recomputed (and its
/// persisted body isn't rewritten) when only those change.
#[turbo_tasks::function]
async fn composition(&self) -> Result<Vc<CodeComposition>> {
let source_maps = *self
.chunking_context
.reference_chunk_source_maps(*ResolvedVc::upcast(self.chunk))
.await?;
let mut code =
ComposedCodeBuilder::new(true, *self.chunking_context.debug_ids_enabled().await?);
CodeCompositionBuilder::new(true, *self.chunking_context.debug_ids_enabled().await?);
let supports_arrow_functions = *self
.chunking_context
.environment()
......@@ -99,10 +117,7 @@ impl EcmascriptNodeChunkContent {
code += suffix;
}
let (code, parts) = code.build();
Ok(minification
.finish_composed_chunk(code, parts, source_maps)?
.cell())
Ok(code.build().cell())
}
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment