Vendor things

third-party/vendor/swc_ecma_parser/examples/lexer.rs

@@ -0,0 +1,44 @@
+use swc_common::{
+    self,
+    errors::{ColorConfig, Handler},
+    sync::Lrc,
+    FileName, SourceMap,
+};
+use swc_ecma_parser::{lexer::Lexer, Capturing, Parser, StringInput, Syntax};
+
+fn main() {
+    let cm: Lrc<SourceMap> = Default::default();
+    let handler = Handler::with_tty_emitter(ColorConfig::Auto, true, false, Some(cm.clone()));
+
+    // Real usage
+    // let fm = cm
+    //     .load_file(Path::new("test.js"))
+    //     .expect("failed to load test.js");
+
+    let fm = cm.new_source_file(
+        FileName::Custom("test.js".into()),
+        "function foo() {}".into(),
+    );
+
+    let lexer = Lexer::new(
+        Syntax::Es(Default::default()),
+        Default::default(),
+        StringInput::from(&*fm),
+        None,
+    );
+
+    let capturing = Capturing::new(lexer);
+
+    let mut parser = Parser::new_from(capturing);
+
+    for e in parser.take_errors() {
+        e.into_diagnostic(&handler).emit();
+    }
+
+    let _module = parser
+        .parse_module()
+        .map_err(|e| e.into_diagnostic(&handler).emit())
+        .expect("Failed to parse module.");
+
+    println!("Tokens: {:?}", parser.input().take());
+}

third-party/vendor/swc_ecma_parser/examples/parse-all.rs

@@ -0,0 +1,75 @@
+#![deny(warnings)]
+
+extern crate swc_node_base;
+
+use std::{env, path::PathBuf, time::Instant};
+
+use criterion::black_box;
+use swc_common::{errors::HANDLER, GLOBALS};
+use swc_ecma_parser::parse_file_as_module;
+use walkdir::WalkDir;
+
+fn main() {
+    let dirs = env::args().skip(1).collect::<Vec<_>>();
+    let files = expand_dirs(dirs);
+    eprintln!("Using {} files", files.len());
+
+    let start = Instant::now();
+    testing::run_test2(false, |cm, handler| {
+        GLOBALS.with(|globals| {
+            HANDLER.set(&handler, || {
+                let _ = files
+                    .into_iter()
+                    .map(|path| -> Result<(), ()> {
+                        GLOBALS.set(globals, || {
+                            let fm = cm.load_file(&path).expect("failed to load file");
+
+                            let program = parse_file_as_module(
+                                &fm,
+                                Default::default(),
+                                Default::default(),
+                                None,
+                                &mut vec![],
+                            )
+                            .map_err(|err| {
+                                err.into_diagnostic(&handler).emit();
+                            })
+                            .unwrap();
+
+                            black_box(program);
+
+                            Ok(())
+                        })
+                    })
+                    .collect::<Vec<_>>();
+
+                Ok(())
+            })
+        })
+    })
+    .unwrap();
+
+    eprintln!("Took {:?}", start.elapsed());
+}
+
+/// Return the whole input files as abolute path.
+fn expand_dirs(dirs: Vec<String>) -> Vec<PathBuf> {
+    dirs.into_iter()
+        .map(PathBuf::from)
+        .map(|dir| dir.canonicalize().unwrap())
+        .flat_map(|dir| {
+            WalkDir::new(dir)
+                .into_iter()
+                .filter_map(Result::ok)
+                .filter_map(|entry| {
+                    if entry.metadata().map(|v| v.is_file()).unwrap_or(false) {
+                        Some(entry.into_path())
+                    } else {
+                        None
+                    }
+                })
+                .filter(|path| path.extension().map(|ext| ext == "js").unwrap_or(false))
+                .collect::<Vec<_>>()
+        })
+        .collect()
+}

third-party/vendor/swc_ecma_parser/examples/perf.rs

@@ -0,0 +1,51 @@
+extern crate swc_node_base;
+
+use std::{collections::hash_map::DefaultHasher, hash::Hash};
+
+use criterion::black_box;
+use swc_common::{self, sync::Lrc, SourceMap};
+use swc_ecma_parser::{lexer::Lexer, Parser, StringInput, Syntax, TsConfig};
+
+fn main() {
+    let mut cnt = 0;
+    let mut hasher = DefaultHasher::new();
+
+    for entry in walkdir::WalkDir::new("tests/typescript") {
+        let entry = entry.unwrap();
+        if !entry.path().to_string_lossy().ends_with(".ts")
+            && !entry.path().to_string_lossy().ends_with(".tsx")
+        {
+            continue;
+        }
+
+        let cm: Lrc<SourceMap> = Default::default();
+
+        let fm = cm.load_file(entry.path()).unwrap();
+
+        let lexer = Lexer::new(
+            Syntax::Typescript(TsConfig {
+                no_early_errors: true,
+                tsx: entry.path().to_string_lossy().ends_with(".tsx"),
+                ..Default::default()
+            }),
+            Default::default(),
+            StringInput::from(&*fm),
+            None,
+        );
+
+        let mut parser = Parser::new_from(lexer);
+
+        let module = parser.parse_typescript_module();
+
+        if let Ok(module) = &module {
+            module.hash(&mut hasher);
+        }
+
+        let _ = black_box(module);
+
+        cnt += 1;
+    }
+
+    eprintln!("Parsed {} files", cnt);
+    eprintln!("Hash: {:?}", hasher);
+}

third-party/vendor/swc_ecma_parser/examples/typescript.rs

@@ -0,0 +1,44 @@
+use swc_common::{
+    self,
+    errors::{ColorConfig, Handler},
+    sync::Lrc,
+    FileName, SourceMap,
+};
+use swc_ecma_parser::{lexer::Lexer, Capturing, Parser, StringInput, Syntax};
+
+fn main() {
+    let cm: Lrc<SourceMap> = Default::default();
+    let handler = Handler::with_tty_emitter(ColorConfig::Auto, true, false, Some(cm.clone()));
+
+    // Real usage
+    // let fm = cm
+    //     .load_file(Path::new("test.ts"))
+    //     .expect("failed to load test.ts");
+
+    let fm = cm.new_source_file(
+        FileName::Custom("test.ts".into()),
+        "interface Foo {}".into(),
+    );
+
+    let lexer = Lexer::new(
+        Syntax::Typescript(Default::default()),
+        Default::default(),
+        StringInput::from(&*fm),
+        None,
+    );
+
+    let capturing = Capturing::new(lexer);
+
+    let mut parser = Parser::new_from(capturing);
+
+    for e in parser.take_errors() {
+        e.into_diagnostic(&handler).emit();
+    }
+
+    let _module = parser
+        .parse_typescript_module()
+        .map_err(|e| e.into_diagnostic(&handler).emit())
+        .expect("Failed to parse module.");
+
+    println!("Tokens: {:?}", parser.input().take());
+}