chore: rename PgTPath

Author: psteinroe

AGENTS.md

@@ -150,6 +150,21 @@ Many parser structures are generated from PostgreSQL's protobuf definitions usin
 ### Database Schema
 The `pgls_schema_cache` crate contains SQL queries in `src/queries/` that introspect the database schema to build the in-memory cache.
 
-### Multi-Platform Support  
+### Code Refactoring Tools
+The project has `ast-grep` available for advanced code search and refactoring tasks. ast-grep is a structural search/replace tool that understands code syntax, making it useful for:
+- Renaming types, functions, or variables across the codebase
+- Finding and replacing code patterns
+- Performing structural code transformations
+
+Example usage:
+```bash
+# Search for a pattern
+ast-grep --pattern 'struct $NAME { $$$FIELDS }'
+
+# Replace a pattern across files
+ast-grep --pattern 'OldType' --rewrite 'NewType' --update-all
+```
+
+### Multi-Platform Support
 The project includes platform-specific allocators and build configurations for Windows, macOS, and Linux.
 - Seeing the Treesitter tree for an SQL query can be helpful to debug and implement features. To do this, create a file with an SQL query, and run `just tree-print <file.sql>`.

crates/pgls_cli/src/execute/process_file.rs

@@ -5,7 +5,7 @@ use crate::execute::config::ExecutionMode;
 use crate::execute::walk::TraversalOptions;
 use check::check_file;
 use pgls_diagnostics::Error;
-use pgls_fs::PgTPath;
+use pgls_fs::PgLSPath;
 use std::marker::PhantomData;
 use std::ops::Deref;
 
@@ -103,7 +103,7 @@ impl<'ctx, 'app> Deref for SharedTraversalOptions<'ctx, 'app> {
 /// diagnostics were emitted, or compare the formatted code with the original
 /// content of the file and emit a diff or write the new content to the disk if
 /// write mode is enabled
-pub(crate) fn process_file(ctx: &TraversalOptions, pgls_path: &PgTPath) -> FileResult {
+pub(crate) fn process_file(ctx: &TraversalOptions, pgls_path: &PgLSPath) -> FileResult {
     tracing::trace_span!("process_file", path = ?pgls_path).in_scope(move || {
         let shared_context = &SharedTraversalOptions::new(ctx);
 

crates/pgls_cli/src/execute/process_file/workspace_file.rs

@@ -1,7 +1,7 @@
 use crate::execute::diagnostics::{ResultExt, ResultIoExt};
 use crate::execute::process_file::SharedTraversalOptions;
 use pgls_diagnostics::{Error, category};
-use pgls_fs::{File, OpenOptions, PgTPath};
+use pgls_fs::{File, OpenOptions, PgLSPath};
 use pgls_workspace::workspace::{FileGuard, OpenFileParams};
 use pgls_workspace::{Workspace, WorkspaceError};
 use std::path::{Path, PathBuf};
@@ -24,7 +24,7 @@ impl<'ctx, 'app> WorkspaceFile<'ctx, 'app> {
         ctx: &SharedTraversalOptions<'ctx, 'app>,
         path: &Path,
     ) -> Result<Self, Error> {
-        let pgls_path = PgTPath::new(path);
+        let pgls_path = PgLSPath::new(path);
         let open_options = OpenOptions::default()
             .read(true)
             .write(ctx.config.allows_writes());

crates/pgls_cli/src/execute/walk.rs

@@ -5,7 +5,7 @@ use crate::reporter::{Report, TraversalData};
 use crate::{CliDiagnostic, CliSession};
 use crossbeam::channel::{Receiver, Sender, unbounded};
 use pgls_diagnostics::{DiagnosticExt, Error, Resource};
-use pgls_fs::{FileSystem, PathInterner, PgTPath};
+use pgls_fs::{FileSystem, PathInterner, PgLSPath};
 use pgls_fs::{TraversalContext, TraversalScope};
 use pgls_workspace::dome::Dome;
 use pgls_workspace::workspace::IsPathIgnoredParams;
@@ -133,7 +133,7 @@ fn traverse_inputs(
     fs: &dyn FileSystem,
     inputs: Vec<OsString>,
     ctx: &TraversalOptions,
-) -> (Duration, BTreeSet<PgTPath>) {
+) -> (Duration, BTreeSet<PgLSPath>) {
     let start = Instant::now();
     fs.traversal(Box::new(move |scope: &dyn TraversalScope| {
         for input in inputs {
@@ -299,11 +299,11 @@ pub(crate) struct TraversalOptions<'ctx, 'app> {
     pub(crate) remaining_diagnostics: &'ctx AtomicU32,
 
     /// List of paths that should be processed
-    pub(crate) evaluated_paths: RwLock<BTreeSet<PgTPath>>,
+    pub(crate) evaluated_paths: RwLock<BTreeSet<PgLSPath>>,
 }
 
 impl TraversalOptions<'_, '_> {
-    pub(crate) fn increment_changed(&self, path: &PgTPath) {
+    pub(crate) fn increment_changed(&self, path: &PgLSPath) {
         self.changed.fetch_add(1, Ordering::Relaxed);
         self.evaluated_paths
             .write()
@@ -329,15 +329,15 @@ impl TraversalContext for TraversalOptions<'_, '_> {
         &self.interner
     }
 
-    fn evaluated_paths(&self) -> BTreeSet<PgTPath> {
+    fn evaluated_paths(&self) -> BTreeSet<PgLSPath> {
         self.evaluated_paths.read().unwrap().clone()
     }
 
     fn push_diagnostic(&self, error: Error) {
         self.push_message(error);
     }
 
-    fn can_handle(&self, pgls_path: &PgTPath) -> bool {
+    fn can_handle(&self, pgls_path: &PgLSPath) -> bool {
         let path = pgls_path.as_path();
 
         let is_valid_file = self.fs.path_is_file(path)
@@ -372,22 +372,22 @@ impl TraversalContext for TraversalOptions<'_, '_> {
         true
     }
 
-    fn handle_path(&self, path: PgTPath) {
+    fn handle_path(&self, path: PgLSPath) {
         handle_file(self, &path)
     }
 
-    fn store_path(&self, path: PgTPath) {
+    fn store_path(&self, path: PgLSPath) {
         self.evaluated_paths
             .write()
             .unwrap()
-            .insert(PgTPath::new(path.as_path()));
+            .insert(PgLSPath::new(path.as_path()));
     }
 }
 
 /// This function wraps the [process_file] function implementing the traversal
 /// in a [catch_unwind] block and emit diagnostics in case of error (either the
 /// traversal function returns Err or panics)
-fn handle_file(ctx: &TraversalOptions, path: &PgTPath) {
+fn handle_file(ctx: &TraversalOptions, path: &PgLSPath) {
     match catch_unwind(move || process_file(ctx, path)) {
         Ok(Ok(FileStatus::Changed)) => {
             ctx.increment_changed(path);

crates/pgls_cli/src/reporter/mod.rs

@@ -7,7 +7,7 @@ use crate::cli_options::{CliOptions, CliReporter};
 use crate::diagnostics::CliDiagnostic;
 use pgls_console::Console;
 use pgls_diagnostics::{Error, Severity};
-use pgls_fs::PgTPath;
+use pgls_fs::PgLSPath;
 use std::collections::BTreeSet;
 use std::path::PathBuf;
 use std::time::Duration;
@@ -54,7 +54,7 @@ impl From<CliReporter> for ReportMode {
 
 #[derive(Debug)]
 pub struct TraversalData {
-    pub evaluated_paths: BTreeSet<PgTPath>,
+    pub evaluated_paths: BTreeSet<PgLSPath>,
     pub changed: usize,
     pub unchanged: usize,
     pub matches: usize,

crates/pgls_cli/src/reporter/terminal.rs

@@ -4,7 +4,7 @@ use pgls_console::fmt::Formatter;
 use pgls_console::{Console, ConsoleExt, fmt, markup};
 use pgls_diagnostics::advice::ListAdvice;
 use pgls_diagnostics::{Diagnostic, Error, PrintDiagnostic};
-use pgls_fs::PgTPath;
+use pgls_fs::PgLSPath;
 use std::borrow::Cow;
 use std::collections::BTreeSet;
 
@@ -51,7 +51,7 @@ fn log_diagnostics(console: &mut dyn Console, config: &ReportConfig, diagnostics
     }
 }
 
-fn log_evaluated_paths(console: &mut dyn Console, evaluated_paths: &BTreeSet<PgTPath>) {
+fn log_evaluated_paths(console: &mut dyn Console, evaluated_paths: &BTreeSet<PgLSPath>) {
     let evaluated_paths_diagnostic = EvaluatedPathsDiagnostic {
         advice: ListAdvice {
             list: evaluated_paths

crates/pgls_fs/src/fs.rs

@@ -1,4 +1,4 @@
-use crate::{PathInterner, PgTPath};
+use crate::{PathInterner, PgLSPath};
 pub use memory::{ErrorEntry, MemoryFileSystem};
 pub use os::OsFileSystem;
 use oxc_resolver::{Resolution, ResolveError};
@@ -313,18 +313,18 @@ pub trait TraversalContext: Sync {
     /// Checks if the traversal context can handle a particular path, used as
     /// an optimization to bail out of scheduling a file handler if it wouldn't
     /// be able to process the file anyway
-    fn can_handle(&self, path: &PgTPath) -> bool;
+    fn can_handle(&self, path: &PgLSPath) -> bool;
 
     /// This method will be called by the traversal for each file it finds
     /// where [TraversalContext::can_handle] returned true
-    fn handle_path(&self, path: PgTPath);
+    fn handle_path(&self, path: PgLSPath);
 
     /// This method will be called by the traversal for each file it finds
     /// where [TraversalContext::store_path] returned true
-    fn store_path(&self, path: PgTPath);
+    fn store_path(&self, path: PgLSPath);
 
     /// Returns the paths that should be handled
-    fn evaluated_paths(&self) -> BTreeSet<PgTPath>;
+    fn evaluated_paths(&self) -> BTreeSet<PgLSPath>;
 }
 
 impl<T> FileSystem for Arc<T>

crates/pgls_fs/src/fs/memory.rs

@@ -11,7 +11,7 @@ use parking_lot::{Mutex, RawMutex, RwLock, lock_api::ArcMutexGuard};
 use pgls_diagnostics::{Error, Severity};
 
 use crate::fs::OpenOptions;
-use crate::{FileSystem, PgTPath, TraversalContext, TraversalScope};
+use crate::{FileSystem, PgLSPath, TraversalContext, TraversalScope};
 
 use super::{BoxedTraversal, ErrorKind, File, FileSystemDiagnostic};
 
@@ -307,7 +307,7 @@ impl<'scope> TraversalScope<'scope> for MemoryTraversalScope<'scope> {
 
                 if should_process_file {
                     let _ = ctx.interner().intern_path(path.into());
-                    let pgls_path = PgTPath::new(path);
+                    let pgls_path = PgLSPath::new(path);
                     if !ctx.can_handle(&pgls_path) {
                         continue;
                     }
@@ -338,7 +338,7 @@ impl<'scope> TraversalScope<'scope> for MemoryTraversalScope<'scope> {
     }
 
     fn handle(&self, context: &'scope dyn TraversalContext, path: PathBuf) {
-        context.handle_path(PgTPath::new(path));
+        context.handle_path(PgLSPath::new(path));
     }
 }
 
@@ -354,7 +354,7 @@ mod tests {
     use parking_lot::Mutex;
     use pgls_diagnostics::Error;
 
-    use crate::{FileSystem, MemoryFileSystem, PathInterner, PgTPath, TraversalContext};
+    use crate::{FileSystem, MemoryFileSystem, PathInterner, PgLSPath, TraversalContext};
     use crate::{OpenOptions, fs::FileSystemExt};
 
     #[test]
@@ -521,7 +521,7 @@ mod tests {
 
         struct TestContext {
             interner: PathInterner,
-            visited: Mutex<BTreeSet<PgTPath>>,
+            visited: Mutex<BTreeSet<PgLSPath>>,
         }
 
         impl TraversalContext for TestContext {
@@ -533,19 +533,19 @@ mod tests {
                 panic!("unexpected error {err:?}")
             }
 
-            fn can_handle(&self, _: &PgTPath) -> bool {
+            fn can_handle(&self, _: &PgLSPath) -> bool {
                 true
             }
 
-            fn handle_path(&self, path: PgTPath) {
+            fn handle_path(&self, path: PgLSPath) {
                 self.visited.lock().insert(path.to_written());
             }
 
-            fn store_path(&self, path: PgTPath) {
+            fn store_path(&self, path: PgLSPath) {
                 self.visited.lock().insert(path);
             }
 
-            fn evaluated_paths(&self) -> BTreeSet<PgTPath> {
+            fn evaluated_paths(&self) -> BTreeSet<PgLSPath> {
                 let lock = self.visited.lock();
                 lock.clone()
             }
@@ -566,8 +566,8 @@ mod tests {
         swap(&mut visited, ctx.visited.get_mut());
 
         assert_eq!(visited.len(), 2);
-        assert!(visited.contains(&PgTPath::new("dir1/file1")));
-        assert!(visited.contains(&PgTPath::new("dir1/file2")));
+        assert!(visited.contains(&PgLSPath::new("dir1/file1")));
+        assert!(visited.contains(&PgLSPath::new("dir1/file2")));
 
         // Traverse a single file
         fs.traversal(Box::new(|scope| {
@@ -578,6 +578,6 @@ mod tests {
         swap(&mut visited, ctx.visited.get_mut());
 
         assert_eq!(visited.len(), 1);
-        assert!(visited.contains(&PgTPath::new("dir2/file2")));
+        assert!(visited.contains(&PgLSPath::new("dir2/file2")));
     }
 }

crates/pgls_fs/src/fs/os.rs

@@ -2,7 +2,7 @@
 use super::{BoxedTraversal, ErrorKind, File, FileSystemDiagnostic};
 use crate::fs::OpenOptions;
 use crate::{
-    FileSystem, PgTPath,
+    FileSystem, PgLSPath,
     fs::{TraversalContext, TraversalScope},
 };
 use oxc_resolver::{Resolution, ResolveError, ResolveOptions, Resolver};
@@ -211,7 +211,7 @@ impl<'scope> TraversalScope<'scope> for OsTraversalScope<'scope> {
 
     fn handle(&self, context: &'scope dyn TraversalContext, path: PathBuf) {
         self.scope.spawn(move |_| {
-            context.handle_path(PgTPath::new(path));
+            context.handle_path(PgLSPath::new(path));
         });
     }
 }
@@ -289,7 +289,7 @@ fn handle_any_file<'scope>(
     }
 
     if file_type.is_symlink() {
-        if !ctx.can_handle(&PgTPath::new(path.clone())) {
+        if !ctx.can_handle(&PgLSPath::new(path.clone())) {
             return;
         }
         let Ok((target_path, target_file_type)) = expand_symbolic_link(path.clone(), ctx) else {
@@ -320,7 +320,7 @@ fn handle_any_file<'scope>(
         if let Some(file_name) = path.file_name() {
             let new_origin_path = old_origin_path.join(file_name);
             origin_path = Some(new_origin_path.clone());
-            PgTPath::new(new_origin_path)
+            PgLSPath::new(new_origin_path)
         } else {
             ctx.push_diagnostic(Error::from(FileSystemDiagnostic {
                 path: path.to_string_lossy().to_string(),
@@ -330,7 +330,7 @@ fn handle_any_file<'scope>(
             return;
         }
     } else {
-        PgTPath::new(&path)
+        PgLSPath::new(&path)
     };
 
     // Performing this check here let's us skip unsupported
@@ -351,7 +351,7 @@ fn handle_any_file<'scope>(
 
     if file_type.is_file() {
         scope.spawn(move |_| {
-            ctx.store_path(PgTPath::new(path));
+            ctx.store_path(PgLSPath::new(path));
         });
         return;
     }

crates/pgls_fs/src/lib.rs

@@ -7,7 +7,7 @@ mod path;
 
 pub use dir::ensure_cache_dir;
 pub use interner::PathInterner;
-pub use path::PgTPath;
+pub use path::PgLSPath;
 
 pub use fs::{
     AutoSearchResult, ConfigName, ErrorEntry, File, FileSystem, FileSystemDiagnostic,