refactor a bit

Author: ShuiRuTian

editors/code/src/test_explorer/RunnableFacde.ts

@@ -6,6 +6,10 @@ import { TargetKind, NodeKind, type TestLikeNodeKind, type TestLocation } from "
 
 /**
  * A wrapper of `ra.Runnable` to provide typed/cached information rather than string.
+ *
+ * An important asumption is the format of `label` is
+ *   - if test, "test test::path". Because test always has name, so the later part could not be empty.
+ *   - if test module, "test-mod test::path". Attention, the later part could be empty if it's the root module of a target.
  */
 export class RunnableFacde {
     public readonly origin: ra.Runnable;
@@ -30,16 +34,20 @@ export class RunnableFacde {
 
     get workspaceRoot(): string {
         if (this._workspaceRoot) return this._workspaceRoot;
+
         const workspaceRoot = this.origin.args.workspaceRoot;
+
         assert(!!workspaceRoot);
+
         return this._workspaceRoot = workspaceRoot;
     }
 
     private _testKind?: TestLikeNodeKind;
 
     get testKind(): TestLikeNodeKind {
-        if (this._testKind) { return this._testKind; }
+        if (this._testKind)  return this._testKind;
         const testKindString = this.origin.label.split(' ')[0];
+
         switch (testKindString) {
             case 'test':
                 return this._testKind = NodeKind.Test;
@@ -81,7 +89,8 @@ export class RunnableFacde {
     private _targetKind?: TargetKind;
 
     get targetKind(): TargetKind {
-        if (this._targetKind) { return this._targetKind; }
+        if (this._targetKind) return this._targetKind;
+
         switch (true) {
             case this.origin.args.cargoArgs.includes("--lib"):
                 return this._targetKind = TargetKind.Library;
@@ -97,11 +106,15 @@ export class RunnableFacde {
     private _packageName?: string;
 
     get packageName(): string {
-        if (this._packageName) { return this._packageName; }
+        if (this._packageName) return this._packageName;
+
         const packageQualifiedNameIndex = this.origin.args.cargoArgs.findIndex(arg => arg === "--package") + 1;
+
         // The format of `packageQualifiedName` is `name:version`, like `hello:1.2.3`
         const packageQualifiedName = this.origin.args.cargoArgs[packageQualifiedNameIndex];
+
         assert(!!packageQualifiedName, "There should be a value for '--package' in runnable");
+
         return this._packageName = packageQualifiedName.split(':')[0]!;
     }
 
@@ -111,14 +124,18 @@ export class RunnableFacde {
      * Only have value if `targetKind` is `TargetKind.IntegrationTest`
      */
     get integrationTestFileName(): string | null {
-        if (this._integrationTestFileName !== undefined) { return this._integrationTestFileName; }
+
+        if (this._integrationTestFileName !== undefined) return this._integrationTestFileName;
+
         const integrationTestFileNameIndex = this.origin.args.cargoArgs.findIndex(arg => arg === "--test") + 1;
+
         if (integrationTestFileNameIndex === 0) {
             this._integrationTestFileName = null;
         } else {
             this._integrationTestFileName = this.origin.args.cargoArgs[integrationTestFileNameIndex];
             assert(typeof this._integrationTestFileName === "string","There should be a value for '--test' in runnable");
         }
+
         return this._integrationTestFileName;
     }
 
@@ -128,22 +145,27 @@ export class RunnableFacde {
      * Only have value if `targetKind` is `TargetKind.Binary`
      */
     get binaryTestFileName(): string | null {
-        if (this._binaryTestFileName !== undefined) { return this._binaryTestFileName; }
+        if (this._binaryTestFileName !== undefined) return this._binaryTestFileName;
+
         const integrationTestFileNameIndex = this.origin.args.cargoArgs.findIndex(arg => arg === "--bin") + 1;
+
         if (integrationTestFileNameIndex === 0) {
             this._binaryTestFileName = null;
         } else {
             this._binaryTestFileName = this.origin.args.cargoArgs[integrationTestFileNameIndex];
             assert(typeof this._binaryTestFileName === "string","There should be a value for '--bin' in runnable");
         }
+
         return this._binaryTestFileName;
     }
 
     private _uri?: vscode.Uri;
 
     get uri(): vscode.Uri {
-        if (this._uri) { return this._uri; }
+        if (this._uri) return this._uri;
+
         assert(!!this.origin.location?.targetUri, "Need to investigate why targetUri is undefined");
+
         return this._uri = vscode.Uri.parse(this.origin.location.targetUri);
     }
 
@@ -156,6 +178,7 @@ export class RunnableFacde {
      */
     get isTestModuleDeclarationRunnable() {
         assert(this.testKind === NodeKind.TestModule, "Only compare definition for test module.");
+
         return !this.isTestModuleFileDefinitionRunnable
             // filter out module with items
             // Not accurate. But who will write `mode xxx { ... }` in one line?
@@ -167,6 +190,7 @@ export class RunnableFacde {
      */
     get isTestModuleWithItemsRunnable() {
         assert(this.testKind === NodeKind.TestModule, "Only compare definition for test module.");
+
         return !this.isTestModuleFileDefinitionRunnable
             && !this.isTestModuleDeclarationRunnable;
     }
@@ -176,8 +200,11 @@ export class RunnableFacde {
      */
     get isTestModuleFileDefinitionRunnable() {
         const runnable = this.origin;
+
         assert(this.testKind === NodeKind.TestModule, "Only compare definition for test module.");
+
         assert(!!runnable.location, "Should always have location");
+        
         return isRangeValueEqual(
             runnable.location.targetRange,
             runnable.location.targetSelectionRange,

editors/code/src/test_explorer/RustcOutputAnalyzer.ts

@@ -1,7 +1,15 @@
 import * as vscode from "vscode";
 import { assert, assertNever } from "../util";
 import { getTestItemByTestLikeNode, getTestModelByTestItem } from "./discover_and_update";
-import { CargoPackageNode, NodeKind, Nodes, TargetNode, TestModuleNode, TestNode, getPackageNodeOfTestModelNode, getWorkspaceNodeOfTestModelNode, testModelTree } from "./test_model_tree";
+import {
+    type CargoPackageNode,
+    DummyRootNode,
+    NodeKind,
+    type TargetNode,
+    type TestModuleNode,
+    type TestNode,
+    getPackageNodeOfTestModelNode,
+} from "./test_model_tree";
 import { sep } from 'node:path';
 
 const targetPatternNamedCaptureGroup = {
@@ -93,23 +101,28 @@ abstract class RustcOutputAnalyzer {
             this._failureContextAnalyticsFlag = true;
             return;
         }
+
         if (this._failureContextAnalyticsFlag && stacktraceEndPattern.test(line)) {
             this._failureContextAnalyticsFlag = false;
             this.flushStackTraceAnalytics();
             return;
         }
+
         if (this._failureContextAnalyticsFlag) {
             const match = stacktraceTestCasePattern.exec(line);
             const rustcCasePath = match?.[1];
+
             if (rustcCasePath) {
                 const testItem = this._testItemLocator.findTestItemByRustcOutputCasePath(
                     this._currentNormalizedTargetName!,
                     this._currentTargetRelativePath!,
                     rustcCasePath);
+
                 if (!testItem) { assert(false, "Should never happened. Could not bear this error."); }
                 this.flushStackTraceAnalytics();
                 this._currentFailedRustcOutputTest = testItem;
             }
+
             this._currentFailedCaseOutputWithStackTrace.push(line);
         }
     }
@@ -154,12 +167,14 @@ class TestItemLocator {
     // We only allow one test case to be runned
     constructor(chosenRunnedTestItem: vscode.TestItem) {
         const node = getTestModelByTestItem(chosenRunnedTestItem);
+
         assert(node.kind === NodeKind.Test
             || node.kind === NodeKind.TestModule
             || node.kind === NodeKind.Target
             || node.kind === NodeKind.CargoPackage,
             "does not support workspace level, until we allow try to guess the target"
         );
+
         this._testModel = node;
     }
 
@@ -169,6 +184,7 @@ class TestItemLocator {
     findTestItemByRustcOutputCasePath(packageNormalizedName: string, targetRelativePath: string, path: string): vscode.TestItem | undefined {
         // const workspaceRootNode = getWorkspaceNodeOfTestModelNode(this._testModel);
         let targetNode = tryGetTargetNodeOfTestModelNode(this._testModel);
+
         if (!targetNode) {
             const packageNode = getPackageNodeOfTestModelNode(this._testModel);
 
@@ -183,10 +199,10 @@ class TestItemLocator {
 
             assert(targetCandidates.length === 1, "should find one and only one target node, but they might have same name and relative path, although it should be really rare");
             // REVIEW: What should we do if we found 2 or more candidates?
-            targetNode = targetCandidates[0];
+            targetNode = targetCandidates[0]!; // safe, we have checked the length
         }
 
-        const testNode = testModelTree.findTestLikeNodeUnderTarget(
+        const testNode = DummyRootNode.instance.findTestLikeNodeUnderTarget(
             targetNode,
             NodeKind.Test,
             path.split('::')

editors/code/src/test_explorer/TestItemControllerHelper.ts

@@ -1,4 +1,4 @@
-import * as vscode from "vscode";
+import type * as vscode from "vscode";
 import { testController } from ".";
 
 /**