feat: Add Directory.forget(). Will deprecate Directory.remove() in ne…

…xt major.

docs/navigation/directories.md

@@ -185,12 +185,12 @@ directory.deleteImmediatelySync();
 
 This isn't recommended though because it could possibly leave the file system in a halfway state if your code errors before it's done.
 
-### Removing
+### Forgetting
 
-Removes from main project object without deleting it:
+Forgets the directory from main project object without deleting it:
 
 ```ts
-directory.remove();
+directory.forget();
 ```
 
 Note that after doing this, the directory object and all its descendant source files and directories will not be available. If you want to use them again,

src/factories/DirectoryCache.ts

@@ -135,7 +135,7 @@ export class DirectoryCache {
         if (!isRootDir)
             this.addToDirectoriesByDirPath(newDirectory);
 
-        if (!newDirectory._hasLoadedParent())
+        if (!this.has(parentDirPath))
             this.orphanDirs.set(path, newDirectory);
 
         this.directoriesByPath.set(path, newDirectory);

src/fileSystem/Directory.ts

@@ -429,7 +429,7 @@ export class Directory {
         for (const dir of this.getDirectories())
             dir.delete();
         fileSystemWrapper.queueDelete(path);
-        this.remove();
+        this.forget();
     }
 
     /**
@@ -438,7 +438,7 @@ export class Directory {
     async deleteImmediately() {
         const {fileSystemWrapper} = this.global;
         const path = this.getPath();
-        this.remove();
+        this.forget();
         await fileSystemWrapper.deleteImmediately(path);
     }
 
@@ -453,24 +453,34 @@ export class Directory {
     }
 
     /**
-     * Removes the directory and all its descendants from the AST.
+     * Forgets the directory and all its descendants from the Project.
      *
      * Note: Does not delete the directory from the file system.
      */
-    remove() {
-        if (this._wasRemoved())
+    forget() {
+        if (this._wasForgotten())
             return;
 
         for (const sourceFile of this.getSourceFiles())
             sourceFile.forget();
 
         for (const dir of this.getDirectories())
-            dir.remove();
+            dir.forget();
 
         this.global.compilerFactory.removeDirectoryFromCache(this);
         this._global = undefined;
     }
 
+    /**
+     * Removes the directory and all its descendants from the AST.
+     *
+     * Note: Does not delete the directory from the file system.
+     * @deprecated - Use `.forget()`.
+     */
+    remove() {
+        this.forget();
+    }
+
     /**
      * Asynchronously saves the directory and all the unsaved source files to the disk.
      */
@@ -562,7 +572,7 @@ export class Directory {
     }
 
     /** @internal */
-    _wasRemoved() {
+    _wasForgotten() {
         return this._global == null;
     }
 
@@ -572,7 +582,7 @@ export class Directory {
     }
 
     private throwIfDeletedOrRemoved() {
-        if (this._wasRemoved())
+        if (this._wasForgotten())
             throw new errors.InvalidOperationError("Cannot use a directory that was deleted or removed.");
     }
 

src/next-major-deprecations.md

@@ -5,3 +5,4 @@ Remove:
 * `isEqualsExport` on `ExportAssignmentStructure`.
 * `Identifier.getDefinitionReferencingNodes`
 * `getRelativePathToSourceFile` and `getRelativePathToSourceFileAsModuleSpecifier`
+* `Directory.remove`

src/tests/fileSystem/directoryTests.ts

@@ -672,8 +672,8 @@ describe(nameof(Directory), () => {
 
             directory.delete();
             expect(fileSystem.getDeleteLog()).to.deep.equal([]);
-            expect(directory._wasRemoved()).to.be.true;
-            expect(childDir._wasRemoved()).to.be.true;
+            expect(directory._wasForgotten()).to.be.true;
+            expect(childDir._wasForgotten()).to.be.true;
             expect(sourceFile.wasForgotten()).to.be.true;
             expect(otherSourceFile.wasForgotten()).to.be.false;
             project.saveSync();
@@ -722,8 +722,8 @@ describe(nameof(Directory), () => {
             const otherSourceFile = project.createSourceFile("otherFile.ts");
 
             await directory.deleteImmediately();
-            expect(directory._wasRemoved()).to.be.true;
-            expect(childDir._wasRemoved()).to.be.true;
+            expect(directory._wasForgotten()).to.be.true;
+            expect(childDir._wasForgotten()).to.be.true;
             expect(sourceFile.wasForgotten()).to.be.true;
             expect(otherSourceFile.wasForgotten()).to.be.false;
             expect(fileSystem.getDeleteLog()).to.deep.equal([{ path: "/dir" }]);
@@ -740,29 +740,29 @@ describe(nameof(Directory), () => {
             const otherSourceFile = project.createSourceFile("otherFile.ts");
 
             directory.deleteImmediatelySync();
-            expect(directory._wasRemoved()).to.be.true;
-            expect(childDir._wasRemoved()).to.be.true;
+            expect(directory._wasForgotten()).to.be.true;
+            expect(childDir._wasForgotten()).to.be.true;
             expect(sourceFile.wasForgotten()).to.be.true;
             expect(otherSourceFile.wasForgotten()).to.be.false;
             expect(fileSystem.getDeleteLog()).to.deep.equal([{ path: "/dir" }]);
         });
     });
 
-    describe(nameof<Directory>(d => d.remove), () => {
-        it("should remove the file and all its descendants", () => {
+    describe(nameof<Directory>(d => d.forget), () => {
+        it("should forget the directory and all its descendants", () => {
             const project = getProject();
             const directory = project.createDirectory("dir");
             const childDir = directory.createDirectory("childDir");
             const sourceFile = directory.createSourceFile("file.ts");
             const otherSourceFile = project.createSourceFile("otherFile.ts");
 
-            directory.remove();
-            expect(directory._wasRemoved()).to.be.true;
+            directory.forget();
+            expect(directory._wasForgotten()).to.be.true;
             expect(() => directory.getPath()).to.throw();
-            expect(childDir._wasRemoved()).to.be.true;
+            expect(childDir._wasForgotten()).to.be.true;
             expect(sourceFile.wasForgotten()).to.be.true;
             expect(otherSourceFile.wasForgotten()).to.be.false;
-            expect(() => directory.remove()).to.not.throw();
+            expect(() => directory.forget()).to.not.throw();
         });
     });