load packages from workspace-state.json, missing packages can show

package.json

@@ -296,13 +296,17 @@
           "command": "swift.useLocalDependency",
           "when": "view == packageDependencies && viewItem == remote"
         },
+        {
+          "command": "swift.editDependency",
+          "when": "view == packageDependencies && viewItem == remote"
+        },
         {
           "command": "swift.uneditDependency",
-          "when": "view == packageDependencies && viewItem == editing"
+          "when": "view == packageDependencies && viewItem == edited"
         },
         {
           "command": "swift.openInWorkspace",
-          "when": "view == packageDependencies && viewItem == editing"
+          "when": "view == packageDependencies && viewItem == edited"
         },
         {
           "command": "swift.openInWorkspace",
@@ -434,3 +438,4 @@
     "vscode-languageclient": "^8.0.0"
   }
 }
+

src/FolderContext.ts

@@ -16,7 +16,7 @@ import * as vscode from "vscode";
 import * as path from "path";
 import { LinuxMain } from "./LinuxMain";
 import { PackageWatcher } from "./PackageWatcher";
-import { SwiftPackage } from "./SwiftPackage";
+import { SwiftPackage, WorkspaceStateDependency } from "./SwiftPackage";
 import { TestExplorer } from "./TestExplorer/TestExplorer";
 import { WorkspaceContext, FolderEvent } from "./WorkspaceContext";
 import { BackgroundCompilation } from "./BackgroundCompilation";
@@ -150,11 +150,19 @@ export class FolderContext implements vscode.Disposable {
                     return item.state.name === "edited" && item.state.path;
                 })
                 .map(item => {
-                    return { name: item.packageRef.identity, folder: item.state.path! };
+                    return {
+                        name: item.packageRef.identity,
+                        folder: item.state.path!,
+                    };
                 }) ?? []
         );
     }
 
+    /** Get list in-use packages */
+    async resolveDependencyGraph(): Promise<WorkspaceStateDependency[]> {
+        return await this.swiftPackage.resolveDependencyGraph();
+    }
+
     static uriName(uri: vscode.Uri): string {
         return path.basename(uri.fsPath);
     }

src/PackageWatcher.ts

@@ -14,6 +14,7 @@
 
 import * as vscode from "vscode";
 import { FolderContext } from "./FolderContext";
+import { buildDirectoryFromWorkspacePath } from "./utilities/utilities";
 import { FolderEvent, WorkspaceContext } from "./WorkspaceContext";
 
 /**
@@ -25,6 +26,7 @@ import { FolderEvent, WorkspaceContext } from "./WorkspaceContext";
 export class PackageWatcher {
     private packageFileWatcher?: vscode.FileSystemWatcher;
     private resolvedFileWatcher?: vscode.FileSystemWatcher;
+    private workspaceStateFileWatcher?: vscode.FileSystemWatcher;
 
     constructor(private folderContext: FolderContext, private workspaceContext: WorkspaceContext) {}
 
@@ -35,6 +37,7 @@ export class PackageWatcher {
     install() {
         this.packageFileWatcher = this.createPackageFileWatcher();
         this.resolvedFileWatcher = this.createResolvedFileWatcher();
+        this.workspaceStateFileWatcher = this.createWorkspaceStateFileWatcher();
     }
 
     /**
@@ -44,6 +47,7 @@ export class PackageWatcher {
     dispose() {
         this.packageFileWatcher?.dispose();
         this.resolvedFileWatcher?.dispose();
+        this.workspaceStateFileWatcher?.dispose();
     }
 
     private createPackageFileWatcher(): vscode.FileSystemWatcher {
@@ -66,6 +70,20 @@ export class PackageWatcher {
         return watcher;
     }
 
+    private createWorkspaceStateFileWatcher(): vscode.FileSystemWatcher {
+        const uri = vscode.Uri.file(
+            buildDirectoryFromWorkspacePath(this.folderContext.folder.fsPath, true)
+        );
+
+        const watcher = vscode.workspace.createFileSystemWatcher(
+            new vscode.RelativePattern(uri, "workspace-state.json")
+        );
+        watcher.onDidCreate(async () => await this.handleWorkspaceStateChange());
+        watcher.onDidChange(async () => await this.handleWorkspaceStateChange());
+        watcher.onDidDelete(async () => await this.handleWorkspaceStateChange());
+        return watcher;
+    }
+
     /**
      * Handles a create or change event for **Package.swift**.
      *
@@ -88,4 +106,13 @@ export class PackageWatcher {
         await this.folderContext.reloadPackageResolved();
         this.workspaceContext.fireEvent(this.folderContext, FolderEvent.resolvedUpdated);
     }
+
+    /**
+     * Handles a create or change event for **workspace-state.json**.
+     *
+     * This will resolve any changes in the workspace-state.json
+     */
+    private async handleWorkspaceStateChange() {
+        this.workspaceContext.fireEvent(this.folderContext, FolderEvent.workspaceStateUpdated);
+    }
 }

src/SwiftPackage.ts

@@ -14,6 +14,7 @@
 
 import * as vscode from "vscode";
 import * as fs from "fs/promises";
+import * as path from "path";
 import {
     buildDirectoryFromWorkspacePath,
     execSwift,
@@ -117,9 +118,17 @@ export interface WorkspaceState {
     version: number;
 }
 
+/** branch + revision || revision + version */
+export interface CheckoutState {
+    branch: string | null;
+    revision: string;
+    version: string | null;
+}
+
 export interface WorkspaceStateDependency {
     packageRef: { identity: string; kind: string; location: string; name: string };
-    state: { name: string; path?: string };
+    state: { name: string; path?: string; checkoutState?: CheckoutState };
+    subpath: string;
 }
 
 export interface PackagePlugin {
@@ -143,6 +152,61 @@ function isError(state: SwiftPackageState): state is Error {
     return state instanceof Error;
 }
 
+/**
+ * Get version of WorkspaceStateDependency for displaying in the tree
+ * @param dependency
+ * @return real version | edited | local
+ */
+export function dependencyVersion(dependency: WorkspaceStateDependency): string {
+    return dependency.packageRef.kind === "fileSystem"
+        ? "local"
+        : dependency.state.checkoutState?.version ??
+              dependency.state.checkoutState?.branch ??
+              "edited";
+}
+
+/**
+ * Get type of WorkspaceStateDependency for displaying in the tree: real version | edited | local
+ * @param dependency
+ * @return "local" | "remote" | "edited"
+ */
+export function dependencyType(
+    dependency: WorkspaceStateDependency
+): "local" | "remote" | "edited" {
+    return dependency.state.name === "edited"
+        ? "edited"
+        : dependency.packageRef.kind === "fileSystem"
+        ? "local"
+        : "remote";
+}
+
+/**
+ * Get type of WorkspaceStateDependency for displaying in the tree: real version | edited | local
+ * `edited`: dependency.state.path ?? workspacePath + Packages/ + dependency.subpath
+ * `local`: dependency.packageRef.location
+ * `remote`: buildDirectory + checkouts + dependency.packageRef.location
+ * @param dependency
+ * @return the package path based on the type
+ */
+export function dependencyPackagePath(
+    dependency: WorkspaceStateDependency,
+    workspaceFolder: string
+): string {
+    const type = dependencyType(dependency);
+    let packagePath = "";
+    if (type === "edited") {
+        packagePath =
+            dependency.state.path ?? path.join(workspaceFolder, "Packages", dependency.subpath);
+    } else if (type === "local") {
+        packagePath = dependency.state.path ?? dependency.packageRef.location;
+    } else {
+        // remote
+        const buildDirectory = buildDirectoryFromWorkspacePath(workspaceFolder, true);
+        packagePath = path.join(buildDirectory, "checkouts", dependency.subpath);
+    }
+    return packagePath;
+}
+
 /**
  * Class holding Swift Package Manager Package
  */
@@ -267,6 +331,73 @@ export class SwiftPackage implements PackageContents {
         }
     }
 
+    /**
+     * tranverse the dependency tree
+     * in each node, call `swift package describe` to get the child dependencies and do it recursively
+     * @returns all dependencies in flat list
+     */
+    async resolveDependencyGraph(): Promise<WorkspaceStateDependency[]> {
+        const workspaceState = await this.loadWorkspaceState();
+        const workspaceStateDependencies = workspaceState?.object.dependencies ?? [];
+
+        if (workspaceStateDependencies.length === 0) {
+            return [];
+        }
+
+        const contents = this.contents as PackageContents;
+        const showingDependencies = new Set<string>();
+        await this.getChildDependencies(contents, workspaceStateDependencies, showingDependencies);
+
+        // filter workspaceStateDependencies that in showingDependencies
+        return workspaceStateDependencies.filter(dependency =>
+            showingDependencies.has(dependency.packageRef.identity)
+        );
+    }
+
+    /**
+     * tranverse the dependency tree
+     * @param dependency current node
+     * @param workspaceStateDependencies all dependencies in workspace-state.json
+     * @param showingDependencies result of dependencies that are showing in the tree
+     * @returns
+     */
+    private async getChildDependencies(
+        dependency: PackageContents,
+        workspaceStateDependencies: WorkspaceStateDependency[],
+        showingDependencies: Set<string>
+    ) {
+        for (let i = 0; i < dependency.dependencies.length; i++) {
+            const childDependency = dependency.dependencies[i];
+            if (showingDependencies.has(childDependency.identity)) {
+                return;
+            }
+            showingDependencies.add(childDependency.identity);
+            const workspaceStateDependency = workspaceStateDependencies.find(
+                workspaceStateDependency =>
+                    workspaceStateDependency.packageRef.identity === childDependency.identity
+            );
+            if (workspaceStateDependency) {
+                showingDependencies.add(workspaceStateDependency.packageRef.identity);
+            }
+
+            if (workspaceStateDependency === undefined) {
+                return;
+            }
+
+            const packagePath = dependencyPackagePath(workspaceStateDependency, this.folder.fsPath);
+
+            const childDependencyContents = (await SwiftPackage.loadPackage(
+                vscode.Uri.file(packagePath)
+            )) as PackageContents;
+
+            await this.getChildDependencies(
+                childDependencyContents,
+                workspaceStateDependencies,
+                showingDependencies
+            );
+        }
+    }
+
     /** Reload swift package */
     public async reload() {
         this.contents = await SwiftPackage.loadPackage(this.folder);

src/WorkspaceContext.ts

@@ -131,9 +131,12 @@ export class WorkspaceContext implements vscode.Disposable {
                     this.updateContextKeys(folder);
                     break;
                 case FolderEvent.resolvedUpdated:
+                    break;
+                case FolderEvent.workspaceStateUpdated:
                     if (folder === this.currentFolder) {
                         this.updateContextKeys(folder);
                     }
+                    break;
             }
         });
         this.subscriptions = [
@@ -491,6 +494,8 @@ export enum FolderEvent {
     packageUpdated = "packageUpdated",
     // Package.resolved has been updated
     resolvedUpdated = "resolvedUpdated",
+    // `workspace-state.json` is updated, update dependency tree only by this event
+    workspaceStateUpdated = "workspaceStateUpdated",
 }
 
 /** Workspace Folder observer function */

src/commands.ts

@@ -432,11 +432,12 @@ function updateAfterError(result: boolean, folderContext: FolderContext) {
     const triggerResolvedUpdatedEvent = folderContext.hasResolveErrors;
     // set has resolve errors flag
     folderContext.hasResolveErrors = !result;
+
     // if previous folder state was with resolve errors, and now it is without then
-    // send Package.resolved updated event to trigger display of package dependencies
+    // send workspace-state.json updated event to trigger display of package dependencies
     // view
     if (triggerResolvedUpdatedEvent && !folderContext.hasResolveErrors) {
-        folderContext.fireEvent(FolderEvent.resolvedUpdated);
+        folderContext.fireEvent(FolderEvent.workspaceStateUpdated);
     }
 }
 
@@ -455,17 +456,17 @@ export function register(ctx: WorkspaceContext) {
         vscode.commands.registerCommand("swift.openPackage", () => openPackage(ctx)),
         vscode.commands.registerCommand("swift.useLocalDependency", item => {
             if (item instanceof PackageNode) {
-                useLocalDependency(item.name, ctx);
+                useLocalDependency(item.identity, ctx);
             }
         }),
         vscode.commands.registerCommand("swift.editDependency", item => {
             if (item instanceof PackageNode) {
-                editDependency(item.name, ctx);
+                editDependency(item.identity, ctx);
             }
         }),
         vscode.commands.registerCommand("swift.uneditDependency", item => {
             if (item instanceof PackageNode) {
-                uneditDependency(item.name, ctx);
+                uneditDependency(item.identity, ctx);
             }
         }),
         vscode.commands.registerCommand("swift.openInWorkspace", item => {