Show project dependencies hierarchically

Currently the Package Dependencies view lists all dependencies in a flat
list. This list not only includes those explicitly defined in the
project's Package.swift, but also all the dependencies of dependencies.

As such its difficult to tell at a glance how a dependency is included.
It can also be confusing to see dependencies in the list that you did
not explicitly add.

Instead, show a top level list that is only the dependencies explicitly
defined in Package.swift. Expanding one shows any child dependencies of
the dependency. The files in the dependency's folder are still shown as
well, just after any child deps.

Author: plemarquand

src/FolderContext.ts

@@ -128,13 +128,14 @@ export class FolderContext implements vscode.Disposable {
         await this.swiftPackage.reloadPackageResolved();
     }
 
+    /** reload workspace-state.json for this folder */
+    async reloadWorkspaceState() {
+        await this.swiftPackage.reloadWorkspaceState();
+    }
+
     /** Load Swift Plugins and store in Package */
     async loadSwiftPlugins() {
-        const plugins = await SwiftPackage.loadPlugins(
-            this.folder,
-            this.workspaceContext.toolchain
-        );
-        this.swiftPackage.plugins = plugins;
+        await this.swiftPackage.loadSwiftPlugins(this.workspaceContext.toolchain);
     }
 
     /**

src/PackageWatcher.ts

@@ -15,6 +15,7 @@
 import * as vscode from "vscode";
 import { FolderContext } from "./FolderContext";
 import { FolderOperation, WorkspaceContext } from "./WorkspaceContext";
+import { BuildFlags } from "./toolchain/BuildFlags";
 
 /**
  * Watches for changes to **Package.swift** and **Package.resolved**.
@@ -25,6 +26,7 @@ import { FolderOperation, WorkspaceContext } from "./WorkspaceContext";
 export class PackageWatcher {
     private packageFileWatcher?: vscode.FileSystemWatcher;
     private resolvedFileWatcher?: vscode.FileSystemWatcher;
+    private workspaceStateFileWatcher?: vscode.FileSystemWatcher;
 
     constructor(
         private folderContext: FolderContext,
@@ -38,6 +40,7 @@ export class PackageWatcher {
     install() {
         this.packageFileWatcher = this.createPackageFileWatcher();
         this.resolvedFileWatcher = this.createResolvedFileWatcher();
+        this.workspaceStateFileWatcher = this.createWorkspaceStateFileWatcher();
     }
 
     /**
@@ -47,6 +50,7 @@ export class PackageWatcher {
     dispose() {
         this.packageFileWatcher?.dispose();
         this.resolvedFileWatcher?.dispose();
+        this.workspaceStateFileWatcher?.dispose();
     }
 
     private createPackageFileWatcher(): vscode.FileSystemWatcher {
@@ -69,6 +73,20 @@ export class PackageWatcher {
         return watcher;
     }
 
+    private createWorkspaceStateFileWatcher(): vscode.FileSystemWatcher {
+        const uri = vscode.Uri.joinPath(
+            vscode.Uri.file(
+                BuildFlags.buildDirectoryFromWorkspacePath(this.folderContext.folder.fsPath, true)
+            ),
+            "workspace-state.json"
+        );
+        const watcher = vscode.workspace.createFileSystemWatcher(uri.fsPath);
+        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**.
      *
@@ -95,4 +113,14 @@ export class PackageWatcher {
             this.workspaceContext.fireEvent(this.folderContext, FolderOperation.resolvedUpdated);
         }
     }
+
+    /**
+     * Handles a create or change event for **.build/workspace-state.json**.
+     *
+     * This will resolve any changes in the workspace-state.
+     */
+    private async handleWorkspaceStateChange() {
+        await this.folderContext.reloadWorkspaceState();
+        this.workspaceContext.fireEvent(this.folderContext, FolderOperation.workspaceStateUpdated);
+    }
 }

src/SwiftPackage.ts

@@ -47,10 +47,18 @@ export interface Target {
 /** Swift Package Manager dependency */
 export interface Dependency {
     identity: string;
-    type?: string; // fileSystem, sourceControl or registry
+    type?: string;
     requirement?: object;
     url?: string;
     path?: string;
+    dependencies: Dependency[];
+}
+
+export interface ResolvedDependency extends Omit<Omit<Dependency, "type">, "path"> {
+    version: string;
+    type: string;
+    path: string;
+    location: string;
 }
 
 /** Swift Package.resolved file */
@@ -187,18 +195,23 @@ export class SwiftPackage implements PackageContents {
     private constructor(
         readonly folder: vscode.Uri,
         private contents: SwiftPackageState,
-        public resolved: PackageResolved | undefined
+        public resolved: PackageResolved | undefined,
+        private workspaceState: WorkspaceState | undefined
     ) {}
 
     /**
      * Create a SwiftPackage from a folder
      * @param folder folder package is in
      * @returns new SwiftPackage
      */
-    static async create(folder: vscode.Uri, toolchain: SwiftToolchain): Promise<SwiftPackage> {
+    public static async create(
+        folder: vscode.Uri,
+        toolchain: SwiftToolchain
+    ): Promise<SwiftPackage> {
         const contents = await SwiftPackage.loadPackage(folder, toolchain);
         const resolved = await SwiftPackage.loadPackageResolved(folder);
-        return new SwiftPackage(folder, contents, resolved);
+        const workspaceState = await SwiftPackage.loadWorkspaceState(folder);
+        return new SwiftPackage(folder, contents, resolved, workspaceState);
     }
 
     /**
@@ -211,15 +224,28 @@ export class SwiftPackage implements PackageContents {
         toolchain: SwiftToolchain
     ): Promise<SwiftPackageState> {
         try {
-            let { stdout } = await execSwift(["package", "describe", "--type", "json"], toolchain, {
+            // Use swift package describe to describe the package targets, products, and platforms
+            const describe = await execSwift(["package", "describe", "--type", "json"], toolchain, {
                 cwd: folder.fsPath,
             });
-            // remove lines from `swift package describe` until we find a "{"
-            while (!stdout.startsWith("{")) {
-                const firstNewLine = stdout.indexOf("\n");
-                stdout = stdout.slice(firstNewLine + 1);
-            }
-            return JSON.parse(stdout);
+            const packageState = JSON.parse(
+                SwiftPackage.trimStdout(describe.stdout)
+            ) as PackageContents;
+
+            // Use swift package show-dependencies to get the dependencies in a tree format
+            const dependencies = await execSwift(
+                ["package", "show-dependencies", "--format", "json"],
+                toolchain,
+                {
+                    cwd: folder.fsPath,
+                }
+            );
+
+            packageState.dependencies = JSON.parse(
+                SwiftPackage.trimStdout(dependencies.stdout)
+            ).dependencies;
+
+            return packageState;
         } catch (error) {
             const execError = error as { stderr: string };
             // if caught error and it begins with "error: root manifest" then there is no Package.swift
@@ -237,7 +263,9 @@ export class SwiftPackage implements PackageContents {
         }
     }
 
-    static async loadPackageResolved(folder: vscode.Uri): Promise<PackageResolved | undefined> {
+    private static async loadPackageResolved(
+        folder: vscode.Uri
+    ): Promise<PackageResolved | undefined> {
         try {
             const uri = vscode.Uri.joinPath(folder, "Package.resolved");
             const contents = await fs.readFile(uri.fsPath, "utf8");
@@ -248,7 +276,7 @@ export class SwiftPackage implements PackageContents {
         }
     }
 
-    static async loadPlugins(
+    private static async loadPlugins(
         folder: vscode.Uri,
         toolchain: SwiftToolchain
     ): Promise<PackagePlugin[]> {
@@ -280,12 +308,12 @@ export class SwiftPackage implements PackageContents {
      * Load workspace-state.json file for swift package
      * @returns Workspace state
      */
-    public async loadWorkspaceState(): Promise<WorkspaceState | undefined> {
+    private static async loadWorkspaceState(
+        folder: vscode.Uri
+    ): Promise<WorkspaceState | undefined> {
         try {
             const uri = vscode.Uri.joinPath(
-                vscode.Uri.file(
-                    BuildFlags.buildDirectoryFromWorkspacePath(this.folder.fsPath, true)
-                ),
+                vscode.Uri.file(BuildFlags.buildDirectoryFromWorkspacePath(folder.fsPath, true)),
                 "workspace-state.json"
             );
             const contents = await fs.readFile(uri.fsPath, "utf8");
@@ -306,6 +334,14 @@ export class SwiftPackage implements PackageContents {
         this.resolved = await SwiftPackage.loadPackageResolved(this.folder);
     }
 
+    public async reloadWorkspaceState() {
+        this.workspaceState = await SwiftPackage.loadWorkspaceState(this.folder);
+    }
+
+    public async loadSwiftPlugins(toolchain: SwiftToolchain) {
+        this.plugins = await SwiftPackage.loadPlugins(this.folder, toolchain);
+    }
+
     /** Return if has valid contents */
     public get isValid(): boolean {
         return isPackage(this.contents);
@@ -325,6 +361,88 @@ export class SwiftPackage implements PackageContents {
         return this.contents !== undefined;
     }
 
+    public rootDependencies(): ResolvedDependency[] {
+        // Correlate the root dependencies found in the Package.swift with their
+        // checked out versions in the workspace-state.json.
+        const result = this.dependencies.map(dependency =>
+            this.resolveDependencyAgainstWorkspaceState(dependency)
+        );
+        return result;
+    }
+
+    private resolveDependencyAgainstWorkspaceState(dependency: Dependency): ResolvedDependency {
+        const workspaceStateDep = this.workspaceState?.object.dependencies.find(
+            dep => dep.packageRef.identity === dependency.identity
+        );
+        return {
+            ...dependency,
+            version: workspaceStateDep?.state.checkoutState?.version ?? "",
+            path: workspaceStateDep
+                ? this.dependencyPackagePath(workspaceStateDep, this.folder.fsPath)
+                : "",
+            type: workspaceStateDep ? this.dependencyType(workspaceStateDep) : "",
+            location: workspaceStateDep ? workspaceStateDep.packageRef.location : "",
+        };
+    }
+
+    public async childDependencies(dependency: Dependency): Promise<ResolvedDependency[]> {
+        return dependency.dependencies.map(dep => this.resolveDependencyAgainstWorkspaceState(dep));
+    }
+
+    /**
+     *  * Get package source path of dependency
+     * `editing`: dependency.state.path ?? workspacePath + Packages/ + dependency.subpath
+     * `local`: dependency.packageRef.location
+     * `remote`: buildDirectory + checkouts + dependency.packageRef.location
+     * @param dependency
+     * @param workspaceFolder
+     * @return the package path based on the type
+     */
+    private dependencyPackagePath(
+        dependency: WorkspaceStateDependency,
+        workspaceFolder: string
+    ): string {
+        const type = this.dependencyType(dependency);
+        if (type === "editing") {
+            return (
+                dependency.state.path ?? path.join(workspaceFolder, "Packages", dependency.subpath)
+            );
+        } else if (type === "local") {
+            return dependency.state.path ?? dependency.packageRef.location;
+        } else {
+            // remote
+            const buildDirectory = BuildFlags.buildDirectoryFromWorkspacePath(
+                workspaceFolder,
+                true
+            );
+            if (dependency.packageRef.kind === "registry") {
+                return path.join(buildDirectory, "registry", "downloads", dependency.subpath);
+            } else {
+                return path.join(buildDirectory, "checkouts", dependency.subpath);
+            }
+        }
+    }
+
+    /**
+     * Get type of WorkspaceStateDependency for displaying in the tree: real version | edited | local
+     * @param dependency
+     * @return "local" | "remote" | "editing"
+     */
+    private dependencyType(dependency: WorkspaceStateDependency): "local" | "remote" | "editing" {
+        if (dependency.state.name === "edited") {
+            return "editing";
+        } else if (
+            dependency.packageRef.kind === "local" ||
+            dependency.packageRef.kind === "fileSystem"
+        ) {
+            // need to check for both "local" and "fileSystem" as swift 5.5 and earlier
+            // use "local" while 5.6 and later use "fileSystem"
+            return "local";
+        } else {
+            return "remote";
+        }
+    }
+
     /** name of Swift Package */
     get name(): string {
         return (this.contents as PackageContents)?.name ?? "";
@@ -375,6 +493,15 @@ export class SwiftPackage implements PackageContents {
         const filePath = path.relative(this.folder.fsPath, file);
         return this.targets.find(target => isPathInsidePath(filePath, target.path));
     }
+
+    private static trimStdout(stdout: string): string {
+        // remove lines from `swift package describe` until we find a "{"
+        while (!stdout.startsWith("{")) {
+            const firstNewLine = stdout.indexOf("\n");
+            stdout = stdout.slice(firstNewLine + 1);
+        }
+        return stdout;
+    }
 }
 
 export enum TargetType {

src/WorkspaceContext.ts

@@ -680,6 +680,8 @@ export enum FolderOperation {
     packageUpdated = "packageUpdated",
     // Package.resolved has been updated
     resolvedUpdated = "resolvedUpdated",
+    // .build/workspace-state.json has been updated
+    workspaceStateUpdated = "workspaceStateUpdated",
 }
 
 /** Workspace Folder Event */