wip on new predictor versions

Author: connor4312

src/adapter/breakpointPredictor.ts

@@ -106,6 +106,8 @@ export class BreakpointsPredictor {
 type DiscoveredMetadata = ISourceMapMetadata & { sourceUrl: string; resolvedPath: string };
 type MetadataMap = Map<string, Set<DiscoveredMetadata>>;
 
+const defaultFileMappings = ['**/*.js', '!node_modules/**'];
+
 class DirectoryScanner {
   private _predictor: BreakpointsPredictor;
   private _sourcePathToCompiled: Promise<MetadataMap>;
@@ -135,7 +137,8 @@ class DirectoryScanner {
     };
 
     const start = Date.now();
-    const todo = Object.values(await this.repo.findAllChildren(absolutePath)).map(
+    await this.repo.streamAllChildren(
+      defaultFileMappings.map(m => `${absolutePath}/${m}`),
       async metadata => {
         const baseUrl = metadata.sourceMapUrl.startsWith('data:')
           ? metadata.compiledPath
@@ -175,7 +178,6 @@ class DirectoryScanner {
       },
     );
 
-    await Promise.all(todo);
     console.log('runtime using', this.repo.constructor.name, Date.now() - start);
     return sourcePathToCompiled;
   }

src/adapter/debugAdapter.ts

@@ -15,8 +15,7 @@ import { Cdp } from '../cdp/api';
 import { ISourcePathResolver } from '../common/sourcePathResolver';
 import { AnyLaunchConfiguration } from '../configuration';
 import { RawTelemetryReporter } from '../telemetry/telemetryReporter';
-import { RipGrepSourceMapRepository } from '../common/sourceMaps/ripGrepSourceMapRepository';
-import { NodeSourceMapRepository } from '../common/sourceMaps/nodeSourceMapRepository';
+import { CodeSearchSourceMapRepository } from '../common/sourceMaps/codeSearchSourceMapRepository';
 import { BreakpointsPredictor, BreakpointPredictionCache } from './breakpointPredictor';
 import { CorrelatedCache } from '../common/sourceMaps/mtimeCorrelatedCache';
 import { join } from 'path';
@@ -72,9 +71,7 @@ export class DebugAdapter {
       })),
     );
 
-    const sourceMapRepo = launchConfig.__ripGrepStoragePath
-      ? RipGrepSourceMapRepository.create(launchConfig.__ripGrepStoragePath)
-      : new NodeSourceMapRepository();
+    const sourceMapRepo = CodeSearchSourceMapRepository.createOrFallback();
     const bpCache: BreakpointPredictionCache | undefined = launchConfig.__workspaceCachePath
       ? new CorrelatedCache(join(launchConfig.__workspaceCachePath, 'bp-predict.json'))
       : undefined;

src/baseConfigurationProvider.ts

@@ -96,7 +96,6 @@ export abstract class BaseConfigurationProvider<T extends AnyLaunchConfiguration
    */
   protected commonResolution(config: T): T {
     config.trace = fulfillLoggerOptions(config.trace, this.extensionContext.logPath);
-    config.__ripGrepStoragePath = this.extensionContext.globalStoragePath;
     config.__workspaceCachePath = this.extensionContext.storagePath;
 
     return config;

src/common/sourceMaps/codeSearchSourceMapRepository.ts

@@ -0,0 +1,88 @@
+/*---------------------------------------------------------
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------*/
+
+import { ISourceMapMetadata } from './sourceMap';
+import { ISourceMapRepository, createMetadataForFile } from './sourceMapRepository';
+import { NodeSourceMapRepository } from './nodeSourceMapRepository';
+import { logger } from '../logging/logger';
+import { LogTag } from '../logging';
+import { forceForwardSlashes } from '../pathUtils';
+
+type FindTextFn = (typeof import('vscode'))['workspace']['findTextInFiles'];
+
+/**
+ * A source map repository that uses VS Code's proposed search API to
+ * look for candidate files.
+ */
+export class CodeSearchSourceMapRepository implements ISourceMapRepository {
+  constructor(private readonly findFn: FindTextFn) {}
+
+  public static createOrFallback() {
+    try {
+      const code: typeof import('vscode') = require('vscode');
+      if (code.workspace.findTextInFiles) {
+        return new CodeSearchSourceMapRepository(
+          code.workspace.findTextInFiles.bind(code.workspace),
+        );
+      }
+    } catch {
+      // ignored -- VS won't have vscode as a viable import, fall back to the memory/node.js version
+    }
+
+    return new NodeSourceMapRepository();
+  }
+
+  /**
+   * Returns the sourcemaps in the directory, given as an absolute path..
+   */
+  public async findDirectChildren(
+    _absolutePath: string,
+  ): Promise<{ [path: string]: Required<ISourceMapMetadata> }> {
+    throw new Error('not implemented');
+  }
+
+  /**
+   * Recursively finds all children of the given direcotry.
+   */
+  public async streamAllChildren<T>(
+    patterns: ReadonlyArray<string>,
+    onChild: (child: Required<ISourceMapMetadata>) => Promise<T>,
+  ): Promise<T[]> {
+    const todo: Promise<T | void>[] = [];
+
+    await this.findFn(
+      { pattern: 'sourceMappingURL', isCaseSensitive: true },
+      {
+        // todo(connor4312): is this correct way to join globs for search?
+        include: forceForwardSlashes(patterns.filter(p => !p.startsWith('!')).join(', ')),
+        exclude:
+          patterns
+            .filter(p => p.startsWith('!'))
+            .map(p => forceForwardSlashes(p.slice(1)))
+            .join(','),
+        useIgnoreFiles: false,
+        useGlobalIgnoreFiles: false,
+        followSymlinks: true,
+        previewOptions: { charsPerLine: Number.MAX_SAFE_INTEGER, matchLines: 1 },
+        beforeContext: 0,
+        afterContext: 0,
+      },
+      result => {
+        const text = 'text' in result ? result.text : result.preview.text;
+        todo.push(
+          createMetadataForFile(result.uri.fsPath, text)
+            .then(parsed => parsed && onChild(parsed))
+            .catch(error =>
+              logger.warn(LogTag.SourceMapParsing, 'Error parsing source map', {
+                error,
+                file: result.uri.fsPath,
+              }),
+            ),
+        );
+      },
+    );
+
+    return (await Promise.all(todo)).filter((t): t is T => t !== undefined);
+  }
+}

src/common/sourceMaps/ripGrepSourceMapRepository.ts

@@ -3,15 +3,53 @@
  *--------------------------------------------------------*/
 
 import { ISourceMapMetadata } from './sourceMap';
+import { parseSourceMappingUrl } from '../sourceUtils';
+import { completeUrl, absolutePathToFileUrl } from '../urlUtils';
+import { stat, readfile } from '../fsUtils';
 
 export interface ISourceMapRepository {
   /**
-   * Returns the sourcemaps in the directory, given as an absolute path.
+   * Recursively finds all children matching the given glob, calling `onChild`
+   * when children are found and returning a promise that resolves once all
+   * children have been discovered.
    */
-  findDirectChildren(absolutePath: string): Promise<{ [path: string]: Required<ISourceMapMetadata> }>;
-
-  /**
-   * Recursively finds all children of the given direcotry.
-   */
-  findAllChildren(absolutePath: string): Promise<{ [key: string]: Required<ISourceMapMetadata> }>;
+  streamAllChildren<T>(
+    patterns: ReadonlyArray<string>,
+    onChild: (child: Required<ISourceMapMetadata>) => Promise<T>,
+  ): Promise<T[]>;
 }
+
+/**
+ * Generates source map metadata from a path on disk and file contents.
+ * @param compiledPath -- Absolute path of the .js file on disk
+ * @param fileContents -- Read contents of the file
+ */
+export const createMetadataForFile = async (compiledPath: string, fileContents?: string) => {
+  if (typeof fileContents === 'undefined') {
+    fileContents = await readfile(compiledPath);
+  }
+
+  let sourceMapUrl = parseSourceMappingUrl(fileContents);
+  if (!sourceMapUrl) {
+    return;
+  }
+
+  sourceMapUrl = completeUrl(absolutePathToFileUrl(compiledPath), sourceMapUrl);
+  if (!sourceMapUrl) {
+    return;
+  }
+
+  if (!sourceMapUrl.startsWith('data:') && !sourceMapUrl.startsWith('file://')) {
+    return;
+  }
+
+  const stats = await stat(compiledPath);
+  if (!stats) {
+    return;
+  }
+  return {
+    compiledPath,
+    sourceMapUrl: sourceMapUrl!,
+    mtime: stats && stats.mtimeMs,
+  };
+};

src/common/sourceMaps/sourceMapRepository.ts

@@ -131,13 +131,6 @@ export interface IBaseConfiguration extends IMandatedConfiguration, Dap.LaunchPa
    */
   __workspaceFolder: string;
 
-  /**
-   * If set, ripgrep will be used for discovering local sourcemaps and will
-   * be stored in this folder after downloading. If this is omitted, we'll
-   * use a plain Node.js strategy for grepping instead.
-   */
-  __ripGrepStoragePath?: string;
-
   /**
    * Cache directory for workspace-related configuration.
    */