chore(rust): change indentation to tabs

The 4 spaces indentation uses too much screen width in the deep indentation of transforming, and with tabs people can configure their own visible width.

Author: wmertens

packages/qwik/src/napi/build.rs

@@ -1,5 +1,5 @@
 extern crate napi_build;
 
 fn main() {
-    napi_build::setup();
+	napi_build::setup();
 }

packages/qwik/src/napi/src/lib.rs

@@ -15,27 +15,27 @@ static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
 #[allow(clippy::needless_pass_by_value)]
 #[js_function(1)]
 fn transform_fs(ctx: CallContext) -> Result<JsUnknown> {
-    let opts = ctx.get::<JsObject>(0)?;
-    let config: qwik_core::TransformFsOptions = ctx.env.from_js_value(opts)?;
+	let opts = ctx.get::<JsObject>(0)?;
+	let config: qwik_core::TransformFsOptions = ctx.env.from_js_value(opts)?;
 
-    let result = qwik_core::transform_fs(config).unwrap();
-    ctx.env.to_js_value(&result)
+	let result = qwik_core::transform_fs(config).unwrap();
+	ctx.env.to_js_value(&result)
 }
 
 #[allow(clippy::needless_pass_by_value)]
 #[js_function(1)]
 fn transform_modules(ctx: CallContext) -> Result<JsUnknown> {
-    let opts = ctx.get::<JsObject>(0)?;
-    let config: qwik_core::TransformModulesOptions = ctx.env.from_js_value(opts)?;
+	let opts = ctx.get::<JsObject>(0)?;
+	let config: qwik_core::TransformModulesOptions = ctx.env.from_js_value(opts)?;
 
-    let result = qwik_core::transform_modules(config).unwrap();
-    ctx.env.to_js_value(&result)
+	let result = qwik_core::transform_modules(config).unwrap();
+	ctx.env.to_js_value(&result)
 }
 
 #[module_exports]
 fn init(mut exports: JsObject) -> Result<()> {
-    exports.create_named_method("transform_fs", transform_fs)?;
-    exports.create_named_method("transform_modules", transform_modules)?;
+	exports.create_named_method("transform_fs", transform_fs)?;
+	exports.create_named_method("transform_modules", transform_modules)?;
 
-    Ok(())
+	Ok(())
 }

packages/qwik/src/optimizer/cli/src/main.rs

@@ -9,24 +9,24 @@ use path_absolutize::Absolutize;
 use qwik_core::{transform_fs, EmitMode, EntryStrategy, MinifyMode, TransformFsOptions};
 
 struct OptimizerInput {
-    glob: Option<String>,
-    manifest: Option<String>,
-    core_module: Option<String>,
-    scope: Option<String>,
-    src: PathBuf,
-    dest: PathBuf,
-    mode: EmitMode,
-    strategy: EntryStrategy,
-    transpile_ts: bool,
-    transpile_jsx: bool,
-    preserve_filenames: bool,
-    minify: MinifyMode,
-    sourcemaps: bool,
-    explicit_extensions: bool,
+	glob: Option<String>,
+	manifest: Option<String>,
+	core_module: Option<String>,
+	scope: Option<String>,
+	src: PathBuf,
+	dest: PathBuf,
+	mode: EmitMode,
+	strategy: EntryStrategy,
+	transpile_ts: bool,
+	transpile_jsx: bool,
+	preserve_filenames: bool,
+	minify: MinifyMode,
+	sourcemaps: bool,
+	explicit_extensions: bool,
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let matches = Command::new("qwik")
+	let matches = Command::new("qwik")
         .version("1.0")
         .arg_required_else_help(true)
         .subcommand_required(true)
@@ -85,85 +85,85 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         )
         .get_matches();
 
-    // You can check for the existence of subcommands, and if found use their
-    // matches just as you would the top level app
-    if let Some(matches) = matches.subcommand_matches("optimize") {
-        // "$ myapp test" was run
-        let strategy = match matches.value_of("strategy") {
-            Some("inline") => EntryStrategy::Inline,
-            Some("hook") => EntryStrategy::Hook,
-            Some("single") => EntryStrategy::Single,
-            Some("component") => EntryStrategy::Component,
-            Some("smart") | None => EntryStrategy::Smart,
-            _ => panic!("Invalid strategy option"),
-        };
+	// You can check for the existence of subcommands, and if found use their
+	// matches just as you would the top level app
+	if let Some(matches) = matches.subcommand_matches("optimize") {
+		// "$ myapp test" was run
+		let strategy = match matches.value_of("strategy") {
+			Some("inline") => EntryStrategy::Inline,
+			Some("hook") => EntryStrategy::Hook,
+			Some("single") => EntryStrategy::Single,
+			Some("component") => EntryStrategy::Component,
+			Some("smart") | None => EntryStrategy::Smart,
+			_ => panic!("Invalid strategy option"),
+		};
 
-        let minify = match matches.value_of("minify") {
-            Some("none") => MinifyMode::None,
-            Some("simplify") | None => MinifyMode::Simplify,
-            _ => panic!("Invalid minify option"),
-        };
+		let minify = match matches.value_of("minify") {
+			Some("none") => MinifyMode::None,
+			Some("simplify") | None => MinifyMode::Simplify,
+			_ => panic!("Invalid minify option"),
+		};
 
-        let mode = match matches.value_of("mode") {
-            Some("dev") => EmitMode::Dev,
-            Some("prod") => EmitMode::Prod,
-            Some("lib") | None => EmitMode::Lib,
-            _ => panic!("Invalid mode option"),
-        };
-        optimize(OptimizerInput {
-            src: matches.value_of_t_or_exit("src"),
-            dest: matches.value_of_t_or_exit("dest"),
-            manifest: matches.value_of("manifest").map(|s| s.into()),
-            core_module: matches.value_of("core_module").map(|s| s.into()),
-            scope: matches.value_of("scope").map(|s| s.into()),
-            mode,
-            glob: None,
-            strategy,
-            minify,
-            explicit_extensions: matches.is_present("extensions"),
-            transpile_jsx: !matches.is_present("no-jsx"),
-            transpile_ts: !matches.is_present("no-ts"),
-            preserve_filenames: matches.is_present("preserve-filenames"),
-            sourcemaps: matches.is_present("sourcemaps"),
-        })?;
-    }
-    Ok(())
+		let mode = match matches.value_of("mode") {
+			Some("dev") => EmitMode::Dev,
+			Some("prod") => EmitMode::Prod,
+			Some("lib") | None => EmitMode::Lib,
+			_ => panic!("Invalid mode option"),
+		};
+		optimize(OptimizerInput {
+			src: matches.value_of_t_or_exit("src"),
+			dest: matches.value_of_t_or_exit("dest"),
+			manifest: matches.value_of("manifest").map(|s| s.into()),
+			core_module: matches.value_of("core_module").map(|s| s.into()),
+			scope: matches.value_of("scope").map(|s| s.into()),
+			mode,
+			glob: None,
+			strategy,
+			minify,
+			explicit_extensions: matches.is_present("extensions"),
+			transpile_jsx: !matches.is_present("no-jsx"),
+			transpile_ts: !matches.is_present("no-ts"),
+			preserve_filenames: matches.is_present("preserve-filenames"),
+			sourcemaps: matches.is_present("sourcemaps"),
+		})?;
+	}
+	Ok(())
 }
 
 fn optimize(
-    optimizer_input: OptimizerInput,
+	optimizer_input: OptimizerInput,
 ) -> Result<qwik_core::TransformOutput, Box<dyn std::error::Error>> {
-    let current_dir = std::env::current_dir()?;
-    let src_dir = current_dir.join(optimizer_input.src).canonicalize()?;
+	let current_dir = std::env::current_dir()?;
+	let src_dir = current_dir.join(optimizer_input.src).canonicalize()?;
 
-    let result = transform_fs(TransformFsOptions {
-        src_dir: src_dir.to_string_lossy().to_string(),
-        vendor_roots: vec![],
-        glob: optimizer_input.glob,
-        source_maps: optimizer_input.sourcemaps,
-        minify: optimizer_input.minify,
-        transpile_jsx: optimizer_input.transpile_jsx,
-        transpile_ts: optimizer_input.transpile_ts,
-        preserve_filenames: optimizer_input.preserve_filenames,
-        entry_strategy: optimizer_input.strategy,
-        explicit_extensions: optimizer_input.explicit_extensions,
-        core_module: optimizer_input.core_module,
-        root_dir: None,
+	let result = transform_fs(TransformFsOptions {
+		src_dir: src_dir.to_string_lossy().to_string(),
+		vendor_roots: vec![],
+		glob: optimizer_input.glob,
+		source_maps: optimizer_input.sourcemaps,
+		minify: optimizer_input.minify,
+		transpile_jsx: optimizer_input.transpile_jsx,
+		transpile_ts: optimizer_input.transpile_ts,
+		preserve_filenames: optimizer_input.preserve_filenames,
+		entry_strategy: optimizer_input.strategy,
+		explicit_extensions: optimizer_input.explicit_extensions,
+		core_module: optimizer_input.core_module,
+		root_dir: None,
 
-        mode: optimizer_input.mode,
-        scope: optimizer_input.scope,
+		mode: optimizer_input.mode,
+		scope: optimizer_input.scope,
 
-        manual_chunks: None,
-        strip_exports: None,
-        strip_ctx_name: None,
-        strip_event_handlers: false,
-        reg_ctx_name: None,
-        is_server: None,
-    })?;
+		manual_chunks: None,
+		strip_exports: None,
+		strip_ctx_name: None,
+		strip_event_handlers: false,
+		reg_ctx_name: None,
+		is_server: None,
+	})?;
 
-    result.write_to_fs(
-        &current_dir.join(optimizer_input.dest).absolutize()?,
-        optimizer_input.manifest,
-    )?;
-    Ok(result)
+	result.write_to_fs(
+		&current_dir.join(optimizer_input.dest).absolutize()?,
+		optimizer_input.manifest,
+	)?;
+	Ok(result)
 }

packages/qwik/src/optimizer/core/benches/transform.rs

@@ -7,7 +7,7 @@ use test::Bencher;
 
 #[bench]
 fn transform_todo_app(b: &mut Bencher) {
-    b.iter(|| {
+	b.iter(|| {
       let code = r#"
       import {
           Fragment,

packages/qwik/src/optimizer/core/src/add_side_effect.rs

@@ -10,56 +10,56 @@ use swc_ecmascript::ast;
 use swc_ecmascript::visit::{VisitMut, VisitMutWith};
 
 pub struct SideEffectVisitor<'a> {
-    global_collector: &'a GlobalCollect,
-    imports: HashSet<JsWord>,
-    path_data: &'a PathData,
-    src_dir: &'a Path,
+	global_collector: &'a GlobalCollect,
+	imports: HashSet<JsWord>,
+	path_data: &'a PathData,
+	src_dir: &'a Path,
 }
 
 impl<'a> SideEffectVisitor<'a> {
-    pub fn new(
-        global_collector: &'a GlobalCollect,
-        path_data: &'a PathData,
-        src_dir: &'a Path,
-    ) -> Self {
-        Self {
-            global_collector,
-            path_data,
-            src_dir,
-            imports: HashSet::new(),
-        }
-    }
+	pub fn new(
+		global_collector: &'a GlobalCollect,
+		path_data: &'a PathData,
+		src_dir: &'a Path,
+	) -> Self {
+		Self {
+			global_collector,
+			path_data,
+			src_dir,
+			imports: HashSet::new(),
+		}
+	}
 }
 
 impl<'a> VisitMut for SideEffectVisitor<'a> {
-    fn visit_mut_import_decl(&mut self, node: &mut ast::ImportDecl) {
-        if node.src.value.starts_with('.') {
-            self.imports.insert(node.src.value.clone());
-        }
-    }
-    fn visit_mut_module(&mut self, node: &mut ast::Module) {
-        node.visit_mut_children_with(self);
-        let mut imports: Vec<_> = self.global_collector.imports.values().collect();
-        imports.sort_by_key(|i| i.source.clone());
+	fn visit_mut_import_decl(&mut self, node: &mut ast::ImportDecl) {
+		if node.src.value.starts_with('.') {
+			self.imports.insert(node.src.value.clone());
+		}
+	}
+	fn visit_mut_module(&mut self, node: &mut ast::Module) {
+		node.visit_mut_children_with(self);
+		let mut imports: Vec<_> = self.global_collector.imports.values().collect();
+		imports.sort_by_key(|i| i.source.clone());
 
-        for import in imports {
-            if import.source.starts_with('.') && !self.imports.contains(&import.source) {
-                let abs_dir = self.path_data.abs_dir.to_slash_lossy();
-                let relative = relative_path::RelativePath::new(&abs_dir);
-                let final_path = relative.join(import.source.as_ref()).normalize();
-                if final_path.starts_with(self.src_dir.to_str().unwrap()) {
-                    node.body.insert(
-                        0,
-                        ast::ModuleItem::ModuleDecl(ast::ModuleDecl::Import(ast::ImportDecl {
-                            asserts: None,
-                            span: DUMMY_SP,
-                            specifiers: vec![],
-                            type_only: false,
-                            src: Box::new(ast::Str::from(import.source.clone())),
-                        })),
-                    );
-                }
-            }
-        }
-    }
+		for import in imports {
+			if import.source.starts_with('.') && !self.imports.contains(&import.source) {
+				let abs_dir = self.path_data.abs_dir.to_slash_lossy();
+				let relative = relative_path::RelativePath::new(&abs_dir);
+				let final_path = relative.join(import.source.as_ref()).normalize();
+				if final_path.starts_with(self.src_dir.to_str().unwrap()) {
+					node.body.insert(
+						0,
+						ast::ModuleItem::ModuleDecl(ast::ModuleDecl::Import(ast::ImportDecl {
+							asserts: None,
+							span: DUMMY_SP,
+							specifiers: vec![],
+							type_only: false,
+							src: Box::new(ast::Str::from(import.source.clone())),
+						})),
+					);
+				}
+			}
+		}
+	}
 }