get typescript trace generation working

Author: nathanwhit

cli/tsc/00_typescript.js

@@ -13,6 +13,25 @@ See the Apache Version 2.0 License for specific language governing permissions
 and limitations under the License.
 ***************************************************************************** */
 
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as perf_hooks from "node:perf_hooks";
+var __filename = "sys.js";
+var __dirname = "/tmp";
+var require = (m) => {
+  if (m === "fs") {
+    return fs;
+  } else if (m === "path") {
+    return path;
+  } else if (m === "os") {
+    return os;
+  } else if (m === "perf_hooks") {
+    return perf_hooks;
+  }
+  throw new Error("not handled " + m);
+};
+
 var ts = {}; ((module) => {
 "use strict";
 var __defProp = Object.defineProperty;
@@ -393,6 +412,8 @@ __export(typescript_exports, {
   createExpressionForObjectLiteralElementLike: () => createExpressionForObjectLiteralElementLike,
   createExpressionForPropertyName: () => createExpressionForPropertyName,
   createExpressionFromEntityName: () => createExpressionFromEntityName,
+  enableStatisticsAndTracing: () => enableStatisticsAndTracing,
+  reportStatistics: () => reportStatistics,
   createExternalHelpersImportDeclarationIfNeeded: () => createExternalHelpersImportDeclarationIfNeeded,
   createFileDiagnostic: () => createFileDiagnostic,
   createFileDiagnosticFromMessageChain: () => createFileDiagnosticFromMessageChain,
@@ -137651,7 +137672,9 @@ function canReportDiagnostics(system, compilerOptions) {
   return system === sys && (compilerOptions.diagnostics || compilerOptions.extendedDiagnostics);
 }
 function canTrace(system, compilerOptions) {
-  return system === sys && compilerOptions.generateTrace;
+  const ret = system === sys && compilerOptions.generateTrace;
+  console.log("canTrace", ret);
+  return ret;
 }
 function enableStatisticsAndTracing(system, compilerOptions, isBuildMode) {
   if (canReportDiagnostics(system, compilerOptions)) {
@@ -185814,3 +185837,7 @@ if (typeof console !== "undefined") {
 });
 })({ get exports() { return ts; }, set exports(v) { ts = v; if (typeof module !== "undefined" && module.exports) { module.exports = v; } } })
 //# sourceMappingURL=typescript.js.map
+export {
+  ts
+};
+globalThis.ts = ts;

cli/tsc/97_ts_host.js

@@ -7,6 +7,7 @@
 /** @type {DenoCore} */
 const core = globalThis.Deno.core;
 const ops = core.ops;
+import { ts } from "ext:deno_cli_tsc/00_typescript.js";
 
 let logDebug = false;
 let logSource = "JS";

cli/tsc/99_main_compiler.js

@@ -100,17 +100,28 @@ function exec({ config, debug: debugFlag, rootNames, localOnly }) {
   performanceStart();
 
   config = normalizeConfig(config);
+  
+  const tracePath = Deno.cwd();
+  
+  Object.assign(config, { generateTrace: tracePath });
+  if (config.compilerOptions) {
+    Object.assign(config.compilerOptions, { generateTrace: tracePath });
+  } else {
+    // config.compilerOptions = { generateTrace: tracePath };
+  }
+  
 
-  debug(">>> exec start", { rootNames });
-  debug(config);
-
+  console.log(">>> exec start", { rootNames });
+  console.log(config);
+  
   const { options, errors: configFileParsingDiagnostics } = ts
-    .convertCompilerOptionsFromJson(config, "");
+  .convertCompilerOptionsFromJson(config, "");
   // The `allowNonTsExtensions` is a "hidden" compiler option used in VSCode
   // which is not allowed to be passed in JSON, we need it to allow special
   // URLs which Deno supports. So we need to either ignore the diagnostic, or
   // inject it ourselves.
-  Object.assign(options, { allowNonTsExtensions: true });
+  Object.assign(options, { allowNonTsExtensions: true, generateTrace: tracePath });
+  ts.enableStatisticsAndTracing(ts.sys, options, false);
   const program = ts.createIncrementalProgram({
     rootNames,
     options,
@@ -180,6 +191,8 @@ function exec({ config, debug: debugFlag, rootNames, localOnly }) {
     ambientModules: checker.getAmbientModules().map((symbol) => symbol.name),
     stats: performanceEnd(),
   });
+  
+  ts.reportStatistics(ts.sys, program, null);
   debug("<<< exec stop");
 }
 

cli/tsc/js.rs

@@ -23,12 +23,19 @@ use deno_graph::ModuleGraph;
 use deno_lib::util::hash::FastInsecureHasher;
 use deno_lib::worker::create_isolate_create_params;
 use deno_path_util::resolve_url_or_path;
+use deno_resolver::npm::DenoInNpmPackageChecker;
+use deno_runtime::deno_permissions::PermissionsContainer;
+use deno_runtime::permissions::RuntimePermissionDescriptorParser;
+use deno_runtime::worker::WorkerOptions;
+use deno_runtime::worker::WorkerServiceOptions;
 use node_resolver::ResolutionMode;
 
 use super::LAZILY_LOADED_STATIC_ASSETS;
 use super::ResolveArgs;
 use super::ResolveError;
 use crate::args::TypeCheckMode;
+use crate::npm::CliNpmResolver;
+use crate::sys::CliSys;
 use crate::tsc::Diagnostics;
 use crate::tsc::ExecError;
 use crate::tsc::LoadError;
@@ -175,7 +182,7 @@ deno_core::extension!(deno_cli_tsc,
     ext.esm_files.to_mut().push(ExtensionFileSource::new_computed("ext:deno_cli_tsc/99_main_compiler.js", crate::tsc::MAIN_COMPILER_SOURCE.as_str().into()));
     ext.esm_files.to_mut().push(ExtensionFileSource::new_computed("ext:deno_cli_tsc/97_ts_host.js", crate::tsc::TS_HOST_SOURCE.as_str().into()));
     ext.esm_files.to_mut().push(ExtensionFileSource::new_computed("ext:deno_cli_tsc/98_lsp.js", crate::tsc::LSP_SOURCE.as_str().into()));
-    ext.js_files.to_mut().push(ExtensionFileSource::new_computed("ext:deno_cli_tsc/00_typescript.js", crate::tsc::TYPESCRIPT_SOURCE.as_str().into()));
+    ext.esm_files.to_mut().push(ExtensionFileSource::new_computed("ext:deno_cli_tsc/00_typescript.js", crate::tsc::TYPESCRIPT_SOURCE.as_str().into()));
     ext.esm_entry_point = Some("ext:deno_cli_tsc/99_main_compiler.js");
   }
 );
@@ -338,23 +345,64 @@ pub fn exec_request(
   });
   let exec_source = format!("globalThis.exec({request_value})");
 
-  let mut extensions =
-    deno_runtime::snapshot_info::get_extensions_in_snapshot();
+  let mut extensions = vec![];
   extensions.push(deno_cli_tsc::init(request, root_map, remapped_specifiers));
   let extension_code_cache = code_cache.map(|cache| {
     Rc::new(TscExtCodeCache::new(cache)) as Rc<dyn deno_core::ExtCodeCache>
   });
-  let mut runtime = JsRuntime::new(RuntimeOptions {
+  let mut main_worker =
+    deno_runtime::worker::MainWorker::bootstrap_from_options(
+      &ModuleSpecifier::parse("file:///main.ts").unwrap(),
+      WorkerServiceOptions::<DenoInNpmPackageChecker, CliNpmResolver, CliSys> {
+        blob_store: Default::default(),
+        broadcast_channel: Default::default(),
+        deno_rt_native_addon_loader: None,
+        feature_checker: Default::default(),
+        fs: Arc::new(deno_runtime::deno_fs::RealFs),
+        module_loader: Rc::new(deno_core::NoopModuleLoader),
+        node_services: None,
+        npm_process_state_provider: None,
+        permissions: PermissionsContainer::allow_all(Arc::new(
+          RuntimePermissionDescriptorParser::new(crate::sys::CliSys::default()),
+        )),
+        root_cert_store_provider: None,
+        fetch_dns_resolver: Default::default(),
+        shared_array_buffer_store: None,
+        compiled_wasm_module_store: None,
+        v8_code_cache: None,
+        bundle_provider: None,
+      },
+      WorkerOptions {
+        startup_snapshot: deno_snapshots::CLI_SNAPSHOT,
+        extensions,
+        ..Default::default()
+      },
+    );
+  eprintln!("HERE");
+  /*   let mut runtime = JsRuntime::new(RuntimeOptions {
     extensions,
     create_params: create_isolate_create_params(&crate::sys::CliSys::default()),
     startup_snapshot: deno_snapshots::CLI_SNAPSHOT,
     extension_code_cache,
     ..Default::default()
-  });
+  }); */
+  let runtime = &mut main_worker.js_runtime;
+
+  eprintln!("HERE2");
+  runtime
+    .op_state()
+    .borrow_mut()
+    .put(deno_runtime::snapshot_info::AllowAll);
+  runtime
+    .op_state()
+    .borrow_mut()
+    .put(crate::sys::CliSys::default());
 
+  eprintln!("HERE3");
   runtime
     .execute_script(located_script_name!(), exec_source)
     .map_err(ExecError::Js)?;
+  eprintln!("HERE4");
 
   let op_state = runtime.op_state();
   let mut op_state = op_state.borrow_mut();

runtime/js/99_main.js

@@ -543,6 +543,16 @@ const NOT_IMPORTED_OPS = [
   "op_deploy_token_get",
   "op_deploy_token_set",
   "op_deploy_token_delete",
+  
+  "op_load",
+  "op_is_node_file",
+  "op_emit",
+  "op_respond",
+  "op_libs",
+  "op_create_hash",
+  "op_remap_specifier",
+  "op_resolve",
+  "op_tsc_constants",
 ];
 
 function removeImportedOps() {