fix(compiler-cli): ensure LogicalFileSystem handles case-sensitivity (#36968)

The `LogicalFileSystem` was not taking into account the
case-sensitivity of the file-system when caching logical
file paths.

PR Close #36968

packages/compiler-cli/src/ngtsc/file_system/src/logical.ts

@@ -53,10 +53,13 @@ export class LogicalFileSystem {
    */
   private cache: Map<AbsoluteFsPath, LogicalProjectPath|null> = new Map();
 
-  constructor(rootDirs: AbsoluteFsPath[]) {
+  constructor(rootDirs: AbsoluteFsPath[], private compilerHost: ts.CompilerHost) {
     // Make a copy and sort it by length in reverse order (longest first). This speeds up lookups,
     // since there's no need to keep going through the array once a match is found.
-    this.rootDirs = rootDirs.concat([]).sort((a, b) => b.length - a.length);
+    this.rootDirs =
+        rootDirs.map(dir => this.compilerHost.getCanonicalFileName(dir) as AbsoluteFsPath)
+            .concat([])
+            .sort((a, b) => b.length - a.length);
   }
 
   /**
@@ -76,11 +79,13 @@ export class LogicalFileSystem {
    * of the TS project's root directories.
    */
   logicalPathOfFile(physicalFile: AbsoluteFsPath): LogicalProjectPath|null {
-    if (!this.cache.has(physicalFile)) {
+    const canonicalFilePath =
+        this.compilerHost.getCanonicalFileName(physicalFile) as AbsoluteFsPath;
+    if (!this.cache.has(canonicalFilePath)) {
       let logicalFile: LogicalProjectPath|null = null;
       for (const rootDir of this.rootDirs) {
-        if (physicalFile.startsWith(rootDir)) {
-          logicalFile = this.createLogicalProjectPath(physicalFile, rootDir);
+        if (isWithinBasePath(rootDir, canonicalFilePath)) {
+          logicalFile = this.createLogicalProjectPath(canonicalFilePath, rootDir);
           // The logical project does not include any special "node_modules" nested directories.
           if (logicalFile.indexOf('/node_modules/') !== -1) {
             logicalFile = null;
@@ -89,9 +94,9 @@ export class LogicalFileSystem {
           }
         }
       }
-      this.cache.set(physicalFile, logicalFile);
+      this.cache.set(canonicalFilePath, logicalFile);
     }
-    return this.cache.get(physicalFile)!;
+    return this.cache.get(canonicalFilePath)!;
   }
 
   private createLogicalProjectPath(file: AbsoluteFsPath, rootDir: AbsoluteFsPath):
@@ -100,3 +105,11 @@ export class LogicalFileSystem {
     return (logicalPath.startsWith('/') ? logicalPath : '/' + logicalPath) as LogicalProjectPath;
   }
 }
+
+/**
+ * Is the `path` a descendant of the `base`?
+ * E.g. `foo/bar/zee` is within `foo/bar` but not within `foo/car`.
+ */
+function isWithinBasePath(base: AbsoluteFsPath, path: AbsoluteFsPath): boolean {
+  return !relative(base, path).startsWith('..');
+}

packages/compiler-cli/src/ngtsc/file_system/test/logical_spec.ts

@@ -6,18 +6,24 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {absoluteFrom} from '../src/helpers';
+import {NgtscCompilerHost} from '../src/compiler_host';
+import {absoluteFrom, getFileSystem} from '../src/helpers';
 import {LogicalFileSystem, LogicalProjectPath} from '../src/logical';
 import {runInEachFileSystem} from '../testing';
 
 runInEachFileSystem(() => {
   describe('logical paths', () => {
     let _: typeof absoluteFrom;
-    beforeEach(() => _ = absoluteFrom);
+    let host: NgtscCompilerHost;
+
+    beforeEach(() => {
+      _ = absoluteFrom;
+      host = new NgtscCompilerHost(getFileSystem());
+    });
 
     describe('LogicalFileSystem', () => {
       it('should determine logical paths in a single root file system', () => {
-        const fs = new LogicalFileSystem([_('/test')]);
+        const fs = new LogicalFileSystem([_('/test')], host);
         expect(fs.logicalPathOfFile(_('/test/foo/foo.ts')))
             .toEqual('/foo/foo' as LogicalProjectPath);
         expect(fs.logicalPathOfFile(_('/test/bar/bar.ts')))
@@ -26,23 +32,23 @@ runInEachFileSystem(() => {
       });
 
       it('should determine logical paths in a multi-root file system', () => {
-        const fs = new LogicalFileSystem([_('/test/foo'), _('/test/bar')]);
+        const fs = new LogicalFileSystem([_('/test/foo'), _('/test/bar')], host);
         expect(fs.logicalPathOfFile(_('/test/foo/foo.ts'))).toEqual('/foo' as LogicalProjectPath);
         expect(fs.logicalPathOfFile(_('/test/bar/bar.ts'))).toEqual('/bar' as LogicalProjectPath);
       });
 
       it('should continue to work when one root is a child of another', () => {
-        const fs = new LogicalFileSystem([_('/test'), _('/test/dist')]);
+        const fs = new LogicalFileSystem([_('/test'), _('/test/dist')], host);
         expect(fs.logicalPathOfFile(_('/test/foo.ts'))).toEqual('/foo' as LogicalProjectPath);
         expect(fs.logicalPathOfFile(_('/test/dist/foo.ts'))).toEqual('/foo' as LogicalProjectPath);
       });
 
       it('should always return `/` prefixed logical paths', () => {
-        const rootFs = new LogicalFileSystem([_('/')]);
+        const rootFs = new LogicalFileSystem([_('/')], host);
         expect(rootFs.logicalPathOfFile(_('/foo/foo.ts')))
             .toEqual('/foo/foo' as LogicalProjectPath);
 
-        const nonRootFs = new LogicalFileSystem([_('/test/')]);
+        const nonRootFs = new LogicalFileSystem([_('/test/')], host);
         expect(nonRootFs.logicalPathOfFile(_('/test/foo/foo.ts')))
             .toEqual('/foo/foo' as LogicalProjectPath);
       });