@theia/workspace 1.77.0-next.57 → 1.77.0-next.63

package/src/browser/workspace-service.spec.ts

@@ -0,0 +1,274 @@
+// *****************************************************************************
+// Copyright (C) 2026 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import URI from '@theia/core/lib/common/uri';
+import { OS } from '@theia/core/lib/common/os';
+import { FileStat } from '@theia/filesystem/lib/common/files';
+import { WorkspaceService } from './workspace-service';
+
+disableJSDOM();
+
+describe('WorkspaceService root names', () => {
+
+    let originalIsWindows: boolean;
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+    after(() => {
+        disableJSDOM();
+    });
+    beforeEach(() => {
+        // Paths outside the workspace are rendered with `Path.fsPath()`, which branches on the backend OS.
+        originalIsWindows = OS.backend.isWindows;
+        OS.backend.isWindows = false;
+    });
+    afterEach(() => {
+        OS.backend.isWindows = originalIsWindows;
+    });
+
+    const workspaceWith = (...roots: string[]): WorkspaceService => Object.create(WorkspaceService.prototype, {
+        tryGetRoots: { value: () => roots.map(root => ({ resource: new URI(root), isDirectory: true })) }
+    });
+
+    const namesOf = (service: WorkspaceService): Record<string, string> =>
+        Object.fromEntries(Array.from(service.getRootNames(), ([name, uri]) => [name, uri.toString()]));
+
+    describe('getRootNames', () => {
+
+        it('names each root after its basename', () => {
+            expect(namesOf(workspaceWith('file:///home/user/frontend', 'file:///home/user/backend'))).to.deep.equal({
+                frontend: 'file:///home/user/frontend',
+                backend: 'file:///home/user/backend'
+            });
+        });
+
+        it('names all roots sharing a basename by the shortest tail that tells them apart', () => {
+            expect(namesOf(workspaceWith('file:///bob/app', 'file:///alice/app', 'file:///home/other'))).to.deep.equal({
+                'bob/app': 'file:///bob/app',
+                'alice/app': 'file:///alice/app',
+                other: 'file:///home/other'
+            });
+        });
+
+        it('uses as many parent segments as needed', () => {
+            expect(namesOf(workspaceWith('file:///a/src/app', 'file:///b/src/app', 'file:///b/lib/app'))).to.deep.equal({
+                'a/src/app': 'file:///a/src/app',
+                'b/src/app': 'file:///b/src/app',
+                'lib/app': 'file:///b/lib/app'
+            });
+        });
+
+        it('names a root with a shorter path than its peer by its whole path', () => {
+            expect(namesOf(workspaceWith('file:///app', 'file:///x/app'))).to.deep.equal({
+                app: 'file:///app',
+                'x/app': 'file:///x/app'
+            });
+        });
+
+        it('qualifies a name that another root name starts with', () => {
+            expect(namesOf(workspaceWith('file:///work/alice', 'file:///home/alice/app', 'file:///home/bob/app'))).to.deep.equal({
+                'work/alice': 'file:///work/alice',
+                'alice/app': 'file:///home/alice/app',
+                'bob/app': 'file:///home/bob/app'
+            });
+        });
+
+        it('qualifies the longer name if the shorter one is a whole path', () => {
+            expect(namesOf(workspaceWith('file:///alice', 'file:///home/alice/app', 'file:///home/bob/app'))).to.deep.equal({
+                alice: 'file:///alice',
+                'home/alice/app': 'file:///home/alice/app',
+                'bob/app': 'file:///home/bob/app'
+            });
+        });
+
+        it('does not qualify a name that the name of a root nested in it starts with', () => {
+            expect(namesOf(workspaceWith('file:///ws/x', 'file:///ws/x/app', 'file:///other/app'))).to.deep.equal({
+                x: 'file:///ws/x',
+                'x/app': 'file:///ws/x/app',
+                'other/app': 'file:///other/app'
+            });
+        });
+
+        it('does not depend on the order of the roots', () => {
+            expect(namesOf(workspaceWith('file:///alice/app', 'file:///bob/app')))
+                .to.deep.equal(namesOf(workspaceWith('file:///bob/app', 'file:///alice/app')));
+        });
+
+        it('names a root listed twice once, after its basename', () => {
+            expect(namesOf(workspaceWith('file:///home/user/app', 'file:///home/user/app'))).to.deep.equal({
+                app: 'file:///home/user/app'
+            });
+        });
+
+        it('returns the same names until the roots change', async () => {
+            let roots = [FileStat.dir('file:///alice/app')];
+            const service = new WorkspaceService();
+            service['computeRoots'] = async () => roots;
+            await service['updateRoots']();
+            const names = service.getRootNames();
+            expect(service.getRootNames()).to.equal(names);
+            roots = [...roots, FileStat.dir('file:///bob/app')];
+            await service['updateRoots']();
+            expect(Array.from(service.getRootNames().keys())).to.deep.equal(['alice/app', 'bob/app']);
+            expect(service.getRootName(new URI('file:///bob/app'))).to.equal('bob/app');
+        });
+
+        it('falls back to the URI for roots with the same path', () => {
+            expect(namesOf(workspaceWith('file:///x/app', 'memfs:/x/app'))).to.deep.equal({
+                'file:///x/app': 'file:///x/app',
+                'memfs:/x/app': 'memfs:/x/app'
+            });
+        });
+    });
+
+    describe('getRootPrefixedPath', () => {
+
+        it('prefixes the path with the name of the root', () => {
+            const service = workspaceWith('file:///alice/app', 'file:///bob/app');
+            expect(service.getRootPrefixedPath(new URI('file:///bob/app/src/index.ts'))).to.equal('bob/app/src/index.ts');
+            expect(service.getRootPrefixedPath(new URI('file:///bob/app'))).to.equal('bob/app');
+        });
+
+        it('uses the deepest root for nested roots', () => {
+            const service = workspaceWith('file:///ws/theia', 'file:///ws/theia/packages/core');
+            expect(service.getRootPrefixedPath(new URI('file:///ws/theia/packages/core/src/a.ts'))).to.equal('core/src/a.ts');
+        });
+
+        it('returns the absolute path for files outside the workspace', () => {
+            const service = workspaceWith('file:///ws/theia');
+            expect(service.getRootPrefixedPath(new URI('file:///tmp/a.ts'))).to.equal('/tmp/a.ts');
+        });
+    });
+
+    describe('resolveSupraRelativePath', () => {
+
+        const resolve = (service: WorkspaceService, path: string): string[] => service.resolveSupraRelativePath(path).map(uri => uri.toString());
+
+        it('resolves a path that starts with the basename of a root', () => {
+            const service = workspaceWith('file:///home/user/frontend', 'file:///home/user/backend');
+            expect(resolve(service, 'backend/src/index.ts')).to.deep.equal(['file:///home/user/backend/src/index.ts']);
+            expect(resolve(service, 'backend')).to.deep.equal(['file:///home/user/backend']);
+        });
+
+        it('resolves a path prefixed with more of the root path than its name', () => {
+            const service = workspaceWith('file:///alice/app');
+            expect(resolve(service, 'alice/app/src/index.ts')).to.deep.equal(['file:///alice/app/src/index.ts']);
+            expect(resolve(service, 'bob/app/src/index.ts')).to.deep.equal([]);
+        });
+
+        it('resolves a basename shared by several roots in each of them', () => {
+            const service = workspaceWith('file:///alice/app', 'file:///bob/app');
+            expect(resolve(service, 'app/src/index.ts')).to.deep.equal(['file:///alice/app/src/index.ts', 'file:///bob/app/src/index.ts']);
+            expect(resolve(service, 'bob/app/src/index.ts')).to.deep.equal(['file:///bob/app/src/index.ts']);
+        });
+
+        it('does not resolve absolute paths, paths leaving the root or paths without a root basename', () => {
+            const service = workspaceWith('file:///home/user/backend');
+            expect(resolve(service, '/home/user/backend/a.ts')).to.deep.equal([]);
+            expect(resolve(service, 'C:\\backend\\a.ts')).to.deep.equal([]);
+            expect(resolve(service, '../backend/a.ts')).to.deep.equal([]);
+            expect(resolve(service, 'src/index.ts')).to.deep.equal([]);
+        });
+    });
+
+    describe('splitRootPrefixedPath', () => {
+
+        const split = (service: WorkspaceService, path: string): { rootName: string; rootUri: string; rest: string } | undefined => {
+            const result = service.splitRootPrefixedPath(path);
+            return result && { ...result, rootUri: result.rootUri.toString() };
+        };
+
+        it('splits off the longest matching root name and keeps the rest as it is', () => {
+            const service = workspaceWith('file:///ws/x', 'file:///ws/x/app', 'file:///other/app');
+            expect(split(service, 'x/app/src/**/\\*.ts')).to.deep.equal({ rootName: 'x/app', rootUri: 'file:///ws/x/app', rest: 'src/**/\\*.ts' });
+            expect(split(service, 'x/lib/{a,b}.ts')).to.deep.equal({ rootName: 'x', rootUri: 'file:///ws/x', rest: 'lib/{a,b}.ts' });
+            expect(split(service, 'other/app')).to.deep.equal({ rootName: 'other/app', rootUri: 'file:///other/app', rest: '' });
+        });
+
+        it('does not split a path without a root name', () => {
+            const service = workspaceWith('file:///alice/app', 'file:///bob/app');
+            expect(split(service, 'app/src/index.ts')).to.be.undefined;
+        });
+    });
+
+    describe('resolveRootPrefixedPath', () => {
+
+        const resolve = (service: WorkspaceService, path: string): string | undefined => service.resolveRootPrefixedPath(path)?.toString();
+
+        it('resolves a path relative to the named root', () => {
+            const service = workspaceWith('file:///home/user/frontend', 'file:///home/user/backend');
+            expect(resolve(service, 'backend/src/index.ts')).to.equal('file:///home/user/backend/src/index.ts');
+            expect(resolve(service, 'backend')).to.equal('file:///home/user/backend');
+        });
+
+        it('resolves parent-qualified root names', () => {
+            const service = workspaceWith('file:///alice/app', 'file:///bob/app');
+            expect(resolve(service, 'bob/app/src/index.ts')).to.equal('file:///bob/app/src/index.ts');
+            expect(resolve(service, 'alice/app')).to.equal('file:///alice/app');
+        });
+
+        it('does not resolve a basename shared by several roots', () => {
+            const service = workspaceWith('file:///alice/app', 'file:///bob/app');
+            expect(resolve(service, 'app/src/index.ts')).to.be.undefined;
+        });
+
+        it('prefers the longest matching root name', () => {
+            const service = workspaceWith('file:///ws/x', 'file:///ws/x/app', 'file:///other/app');
+            expect(resolve(service, 'x/app/src/index.ts')).to.equal('file:///ws/x/app/src/index.ts');
+            expect(resolve(service, 'x/lib/index.ts')).to.equal('file:///ws/x/lib/index.ts');
+        });
+
+        it('accepts backslashes and redundant segments', () => {
+            const service = workspaceWith('file:///home/user/backend');
+            expect(resolve(service, 'backend\\src\\index.ts')).to.equal('file:///home/user/backend/src/index.ts');
+            expect(resolve(service, './backend/src/../lib/a.ts')).to.equal('file:///home/user/backend/lib/a.ts');
+        });
+
+        it('does not resolve absolute paths, URIs or paths leaving the root', () => {
+            const service = workspaceWith('file:///home/user/backend');
+            expect(resolve(service, '/home/user/backend/a.ts')).to.be.undefined;
+            expect(resolve(service, 'C:\\backend\\a.ts')).to.be.undefined;
+            expect(resolve(service, 'file:///home/user/backend/a.ts')).to.be.undefined;
+            expect(resolve(service, 'backend/../../etc/passwd')).to.be.undefined;
+        });
+
+        it('does not resolve paths without a root name', () => {
+            const service = workspaceWith('file:///home/user/backend');
+            expect(resolve(service, 'src/index.ts')).to.be.undefined;
+        });
+
+        it('is the inverse of getRootPrefixedPath', () => {
+            const service = workspaceWith('file:///alice/app', 'file:///bob/app', 'file:///ws/theia', 'file:///ws/theia/packages/core');
+            for (const file of ['file:///alice/app/a.ts', 'file:///bob/app/a.ts', 'file:///ws/theia/b.ts', 'file:///ws/theia/packages/core/c.ts']) {
+                expect(resolve(service, service.getRootPrefixedPath(new URI(file)))).to.equal(file);
+            }
+        });
+
+        it('is the inverse of getRootPrefixedPath for a root with a folder named like another root', () => {
+            const service = workspaceWith('file:///work/alice', 'file:///home/alice/app', 'file:///home/bob/app');
+            for (const file of ['file:///work/alice/app/x.ts', 'file:///home/alice/app/x.ts']) {
+                expect(resolve(service, service.getRootPrefixedPath(new URI(file)))).to.equal(file);
+            }
+        });
+    });
+});

package/src/browser/workspace-service.ts

@@ -16,6 +16,7 @@
 
 import { injectable, inject, postConstruct, named } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
+import { Path } from '@theia/core/lib/common/path';
 import { WorkspaceServer, UntitledWorkspaceService, WorkspaceFileService } from '../common';
 import { WindowService } from '@theia/core/lib/browser/window/window-service';
 import { DEFAULT_WINDOW_HASH } from '@theia/core/lib/common/window';
@@ -312,6 +313,7 @@ export class WorkspaceService implements FrontendApplicationContribution, Worksp
         }
         if (rootsChanged) {
             this._roots = newRoots;
+            this.rootNamesCache = undefined;
             this.deferredRoots.resolve(this._roots); // in order to resolve first
             this.deferredRoots = new Deferred<FileStat[]>();
             this.deferredRoots.resolve(this._roots);
@@ -596,6 +598,7 @@ export class WorkspaceService implements FrontendApplicationContribution, Worksp
             this.windowService.setSafeToShutDown();
             this._workspace = undefined;
             this._roots.length = 0;
+            this.rootNamesCache = undefined;
 
             if (!this.isRemoteSession()) {
                 await this.server.setMostRecentlyUsedWorkspace('');
@@ -833,7 +836,7 @@ export class WorkspaceService implements FrontendApplicationContribution, Worksp
         if (!rootUri) {
             return uri.path.fsPath();
         }
-        const rootName = rootUri.path.base;
+        const rootName = this.getRootName(rootUri) ?? rootUri.path.base;
         const relative = rootUri.relative(uri);
         if (!relative || relative.toString() === '') {
             return rootName;
@@ -841,6 +844,217 @@ export class WorkspaceService implements FrontendApplicationContribution, Worksp
         return `${rootName}/${relative.toString()}`;
     }
 
+    /**
+     * Returns a unique name for each workspace root, in workspace order.
+     *
+     * A root is named after its directory basename, e.g. `backend`. Roots that share a basename are
+     * treated as peers: each of them is named after the shortest tail of its path that tells them
+     * apart, e.g. `alice/app` and `bob/app`. A name that another name starts with, e.g. `alice` next to
+     * `alice/app`, is qualified in the same way, e.g. `work/alice`, so that every path resolves to the root
+     * it came from. The names are thus always the ending of the real path, so they match what appears in
+     * terminal output, compiler errors and the like.
+     *
+     * These are the root names used by {@link getRootPrefixedPath} and resolved by {@link resolveRootPrefixedPath}.
+     */
+    getRootNames(): ReadonlyMap<string, URI> {
+        return this.getRootNamesCache().names;
+    }
+
+    /**
+     * The root names, and the names by root URI, which depend on each other. Reset whenever the roots change.
+     */
+    protected rootNamesCache: { names: ReadonlyMap<string, URI>; namesByRoot: ReadonlyMap<string, string> } | undefined;
+
+    protected getRootNamesCache(): { names: ReadonlyMap<string, URI>; namesByRoot: ReadonlyMap<string, string> } {
+        if (!this.rootNamesCache) {
+            const names = this.computeRootNames(this.tryGetRoots());
+            const namesByRoot = new Map(Array.from(names, ([name, uri]) => [uri.toString(), name]));
+            this.rootNamesCache = { names, namesByRoot };
+        }
+        return this.rootNamesCache;
+    }
+
+    protected computeRootNames(workspaceRoots: FileStat[]): Map<string, URI> {
+        const roots: URI[] = [];
+        for (const root of workspaceRoots) {
+            if (!roots.some(other => other.isEqual(root.resource))) {
+                roots.push(root.resource);
+            }
+        }
+        const byBasename = new Map<string, URI[]>();
+        for (const root of roots) {
+            const peers = byBasename.get(root.path.base) ?? [];
+            peers.push(root);
+            byBasename.set(root.path.base, peers);
+        }
+        const names = new Map<string, URI>();
+        for (const root of roots) {
+            names.set(this.computeRootName(root, byBasename.get(root.path.base)!), root);
+        }
+        return this.qualifyRootNames(names);
+    }
+
+    /**
+     * Returns the name of the given workspace root, as assigned by {@link getRootNames}, or
+     * `undefined` if the URI is not a workspace root.
+     */
+    getRootName(rootUri: URI): string | undefined {
+        return this.getRootNamesCache().namesByRoot.get(rootUri.toString());
+    }
+
+    /**
+     * Resolves a path in the format of {@link getRootPrefixedPath}, i.e. `<rootName>/<relativePath>`
+     * or a bare `<rootName>`, to a URI. If more than one root name is a prefix of the path, which is
+     * the case when a root named `a` has a subfolder `b` and another root is named `a/b`, the longest
+     * one wins.
+     *
+     * @returns `undefined` if the path is absolute, does not start with a root name or leaves its root.
+     */
+    resolveRootPrefixedPath(rootPrefixedPath: string): URI | undefined {
+        const path = new Path(Path.normalizePathSeparator(rootPrefixedPath)).normalize();
+        if (path.isAbsolute || Path.isDrive(path.toString().split('/')[0])) {
+            return undefined;
+        }
+        const segments = path.toString().split('/').filter(segment => segment.length > 0);
+        if (segments.includes('..')) {
+            return undefined;
+        }
+        const match = this.splitRootPrefixedPath(segments.join('/'));
+        if (!match) {
+            return undefined;
+        }
+        return match.rest ? match.rootUri.resolve(match.rest) : match.rootUri;
+    }
+
+    /**
+     * Resolves a path that contains the basename of a workspace root, preceded by nothing or by the
+     * trailing segments of the root's parent path, e.g. `bob/app/src` for the root `/home/bob/app`.
+     * Unlike {@link resolveRootPrefixedPath}, this does not depend on the current root names, so it
+     * also resolves paths that were prefixed with a root name before the workspace roots changed.
+     *
+     * @returns the distinct candidates in workspace order, which are several if the path is ambiguous,
+     * or none if the path is absolute, leaves its root or does not contain the basename of a root.
+     */
+    resolveSupraRelativePath(supraRelativePath: string): URI[] {
+        const path = new Path(Path.normalizePathSeparator(supraRelativePath)).normalize();
+        const segments = path.toString().split('/').filter(segment => segment.length > 0);
+        if (path.isAbsolute || Path.isDrive(segments[0] ?? '') || segments.includes('..')) {
+            return [];
+        }
+        const candidates: URI[] = [];
+        for (const root of this.tryGetRoots()) {
+            const candidate = this.resolveSupraRelativeSegments(root.resource, segments);
+            if (candidate && !candidates.some(other => other.isEqual(candidate))) {
+                candidates.push(candidate);
+            }
+        }
+        return candidates;
+    }
+
+    /**
+     * Resolves `segments` against the given root as described in {@link resolveSupraRelativePath}.
+     */
+    protected resolveSupraRelativeSegments(rootUri: URI, segments: string[]): URI | undefined {
+        const rootBasename = rootUri.path.base;
+        const rootPathSegments = rootUri.path.toString().split('/').filter(segment => segment.length > 0);
+        const rootPrecedingSegments = rootPathSegments.slice(0, rootPathSegments.length - 1);
+        for (let i = 0; i < segments.length; i++) {
+            if (segments[i] !== rootBasename) {
+                continue;
+            }
+            const pathPrecedingSegments = segments.slice(0, i);
+            if (pathPrecedingSegments.length > rootPrecedingSegments.length) {
+                continue;
+            }
+            const rootTail = rootPrecedingSegments.slice(rootPrecedingSegments.length - pathPrecedingSegments.length);
+            if (pathPrecedingSegments.every((segment, j) => segment === rootTail[j])) {
+                const rest = segments.slice(i + 1).join('/');
+                return rest ? rootUri.resolve(rest) : rootUri;
+            }
+        }
+        return undefined;
+    }
+
+    /**
+     * Splits a `/`-separated path that starts with a root name, as in {@link getRootPrefixedPath}, into
+     * that root and the rest of the path, which is empty for a bare root name. The rest is not normalized,
+     * so it may as well be a glob. If more than one root name is a prefix of the path, the longest one wins.
+     *
+     * @returns `undefined` if the path does not start with a root name.
+     */
+    splitRootPrefixedPath(rootPrefixedPath: string): { rootName: string; rootUri: URI; rest: string } | undefined {
+        const segments = rootPrefixedPath.split('/');
+        let match: { rootName: string; rootUri: URI; length: number } | undefined;
+        for (const [rootName, rootUri] of this.getRootNames()) {
+            const nameSegments = rootName.split('/');
+            const matches = nameSegments.length <= segments.length && nameSegments.every((segment, i) => segment === segments[i]);
+            if (matches && (!match || nameSegments.length > match.length)) {
+                match = { rootName, rootUri, length: nameSegments.length };
+            }
+        }
+        return match && { rootName: match.rootName, rootUri: match.rootUri, rest: segments.slice(match.length).join('/') };
+    }
+
+    /**
+     * Computes the name of a root from the roots that share its basename (including itself).
+     */
+    protected computeRootName(root: URI, peers: URI[]): string {
+        if (peers.length === 1) {
+            return root.path.base || root.path.toString();
+        }
+        const segmentsOf = (uri: URI): string[] => uri.path.toString().split('/').filter(segment => segment.length > 0);
+        const rootSegments = segmentsOf(root);
+        const peerSegments = peers.filter(peer => !peer.isEqual(root)).map(segmentsOf);
+        // A root with a shorter path than a peer, e.g. `/app` next to `/x/app`, is named by its whole path, `app`.
+        const maxLength = Math.max(rootSegments.length, ...peerSegments.map(segments => segments.length));
+        for (let length = 2; length <= maxLength; length++) {
+            const tail = rootSegments.slice(-length).join('/');
+            if (peerSegments.every(segments => segments.slice(-length).join('/') !== tail)) {
+                return tail;
+            }
+        }
+        // The paths are the same, e.g. in different URI schemes, so only the full URI tells them apart.
+        return root.toString();
+    }
+
+    /**
+     * Qualifies a root name that another root name starts with, e.g. `alice` next to `alice/app`, by more
+     * segments of its path, as a path in the one root would otherwise resolve to the other. If the root
+     * named `alice/app` is the `app` folder of the root named `alice`, the names are left as they are:
+     * the nested root is then also the one that {@link getRootPrefixedPath} names its files after.
+     */
+    protected qualifyRootNames(names: Map<string, URI>): Map<string, URI> {
+        const entries = Array.from(names, ([name, root]) => ({ name, root }));
+        let qualified = true;
+        while (qualified) {
+            qualified = false;
+            for (const shorter of entries) {
+                for (const longer of entries) {
+                    if (longer.name.startsWith(shorter.name + '/')
+                        && !shorter.root.resolve(longer.name.substring(shorter.name.length + 1)).isEqual(longer.root)) {
+                        qualified = this.qualifyRootName(shorter) || this.qualifyRootName(longer) || qualified;
+                    }
+                }
+            }
+        }
+        return new Map(entries.map(({ name, root }) => [name, root]));
+    }
+
+    /**
+     * Adds the next parent segment to the name of a root, unless the name is its whole path or its URI already.
+     *
+     * @returns whether the name was qualified
+     */
+    protected qualifyRootName(entry: { name: string; root: URI }): boolean {
+        const segments = entry.root.path.toString().split('/').filter(segment => segment.length > 0);
+        const length = entry.name.split('/').length;
+        if (entry.name === entry.root.toString() || length >= segments.length) {
+            return false;
+        }
+        entry.name = segments.slice(-(length + 1)).join('/');
+        return true;
+    }
+
     areWorkspaceRoots(uris: URI[]): boolean {
         if (!uris.length) {
             return false;

package/src/browser/workspace-uri-contribution.spec.ts

@@ -22,7 +22,7 @@ import * as sinon from 'sinon';
 import { Container } from '@theia/core/shared/inversify';
 import { Event } from '@theia/core/lib/common/event';
 import { ApplicationShell, WidgetManager } from '@theia/core/lib/browser';
-import { DefaultUriLabelProviderContribution } from '@theia/core/lib/browser/label-provider';
+import { DefaultUriLabelProviderContribution, DidChangeLabelEvent } from '@theia/core/lib/browser/label-provider';
 import { WorkspaceUriLabelProviderContribution } from './workspace-uri-contribution';
 import URI from '@theia/core/lib/common/uri';
 import { WorkspaceVariableContribution } from './workspace-variable-contribution';
@@ -40,6 +40,12 @@ after(() => disableJSDOM());
 let container: Container;
 let labelProvider: WorkspaceUriLabelProviderContribution;
 let roots: FileStat[];
+let workspaceService: WorkspaceService;
+/** Changes the roots, as `WorkspaceService.updateRoots` does, which resets their names. */
+const setRoots = (newRoots: FileStat[]): void => {
+    roots = newRoots;
+    workspaceService['rootNamesCache'] = undefined;
+};
 beforeEach(() => {
     roots = [FileStat.dir('file:///workspace')];
 
@@ -53,7 +59,7 @@ beforeEach(() => {
         onDidCreateWidget: Event.None
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } as any);
-    const workspaceService = new WorkspaceService();
+    workspaceService = new WorkspaceService();
     workspaceService.tryGetRoots = () => roots;
     container.bind(WorkspaceService).toConstantValue(workspaceService);
     container.bind(WorkspaceVariableContribution).toSelf().inSingletonScope();
@@ -138,6 +144,42 @@ describe('WorkspaceUriLabelProviderContribution class', () => {
             const name = labelProvider.getName(file);
             expect(name).eq('jacques.doc');
         });
+
+        it('should return the folder name of a workspace root', () => {
+            setRoots([FileStat.dir('file:///home/alice/app'), FileStat.dir('file:///home/bob/lib')]);
+            expect(labelProvider.getName(FileStat.dir('file:///home/alice/app'))).eq('app');
+        });
+
+        it('should return the unique names of workspace roots sharing a folder name', () => {
+            setRoots([FileStat.dir('file:///home/alice/app'), FileStat.dir('file:///home/bob/app')]);
+            expect(labelProvider.getName(FileStat.dir('file:///home/alice/app'))).eq('alice/app');
+            expect(labelProvider.getName(new URI('file:///home/bob/app'))).eq('bob/app');
+        });
+
+        it('should return the folder name of a folder that shares its name with a workspace root', () => {
+            setRoots([FileStat.dir('file:///home/alice/app'), FileStat.dir('file:///home/bob/app')]);
+            expect(labelProvider.getName(FileStat.dir('file:///home/alice/app/app'))).eq('app');
+        });
+
+        it('should notify a change of the name of a workspace root when a root sharing its folder name is added', () => {
+            setRoots([FileStat.dir('file:///home/alice/app'), FileStat.dir('file:///home/other')]);
+            workspaceService['onWorkspaceChangeEmitter'].fire(roots);
+            const events: DidChangeLabelEvent[] = [];
+            labelProvider.onDidChange(event => events.push(event));
+            setRoots([...roots, FileStat.dir('file:///home/bob/app')]);
+            workspaceService['onWorkspaceChangeEmitter'].fire(roots);
+            expect(events.some(event => event.affects(new URI('file:///home/alice/app')))).to.be.true;
+            expect(events.some(event => event.affects(FileStat.dir('file:///home/alice/app')))).to.be.true;
+            expect(events.some(event => event.affects(new URI('file:///home/other')))).to.be.false;
+            expect(labelProvider.getName(new URI('file:///home/alice/app'))).eq('alice/app');
+        });
+    });
+
+    describe('getDetails()', () => {
+        it('should prefix the path of a file with the unique name of its workspace root', () => {
+            setRoots([FileStat.dir('file:///home/alice/app'), FileStat.dir('file:///home/bob/app')]);
+            expect(labelProvider.getDetails(new URI('file:///home/bob/app/src/index.ts'))).eq('bob/app • src');
+        });
     });
 
     describe('getLongName()', () => {
@@ -176,7 +218,7 @@ describe('WorkspaceUriLabelProviderContribution class', () => {
         });
 
         it('should return the path of a file if WorkspaceService returns no roots', () => {
-            roots = [];
+            setRoots([]);
             const file = new URI('file:///tmp/prout.txt');
             const longName = labelProvider.getLongName(file);