ide: create/alter/drop server goto def

crates/squawk_github/Cargo.toml

@@ -13,6 +13,9 @@ keywords = ["bot", "github", "linter"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[lib]
+doctest = false
+
 [dependencies]
 jsonwebtoken.workspace = true
 serde_json.workspace = true

crates/squawk_ide/Cargo.toml

@@ -11,6 +11,9 @@ edition.workspace = true
 license.workspace = true
 rust-version.workspace = true
 
+[lib]
+doctest = false
+
 [dependencies]
 squawk-syntax.workspace = true
 squawk-linter.workspace = true

crates/squawk_ide/src/binder.rs

@@ -96,6 +96,7 @@ fn bind_stmt(b: &mut Binder, stmt: ast::Stmt) {
             bind_create_tablespace(b, create_tablespace)
         }
         ast::Stmt::CreateDatabase(create_database) => bind_create_database(b, create_database),
+        ast::Stmt::CreateServer(create_server) => bind_create_server(b, create_server),
         ast::Stmt::Set(set) => bind_set(b, set),
         _ => {}
     }
@@ -430,6 +431,25 @@ fn bind_create_database(b: &mut Binder, create_database: ast::CreateDatabase) {
     b.scopes[root].insert(database_name, database_id);
 }
 
+fn bind_create_server(b: &mut Binder, create_server: ast::CreateServer) {
+    let Some(name) = create_server.name() else {
+        return;
+    };
+
+    let server_name = Name::from_node(&name);
+    let name_ptr = SyntaxNodePtr::new(name.syntax());
+
+    let server_id = b.symbols.alloc(Symbol {
+        kind: SymbolKind::Server,
+        ptr: name_ptr,
+        schema: Schema::new("pg_foreign_server"),
+        params: None,
+    });
+
+    let root = b.root_scope();
+    b.scopes[root].insert(server_name, server_id);
+}
+
 fn item_name(path: &ast::Path) -> Option<Name> {
     let segment = path.segment()?;
 

crates/squawk_ide/src/classify.rs

@@ -12,6 +12,10 @@ pub(crate) enum NameRefClass {
     SequenceOwnedByColumn,
     Tablespace,
     DropDatabase,
+    DropServer,
+    AlterServer,
+    CreateServer,
+    ForeignTableServerName,
     ForeignKeyTable,
     ForeignKeyColumn,
     ForeignKeyLocalColumn,
@@ -209,6 +213,18 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
         if ast::DropDatabase::can_cast(ancestor.kind()) {
             return Some(NameRefClass::DropDatabase);
         }
+        if ast::DropServer::can_cast(ancestor.kind()) {
+            return Some(NameRefClass::DropServer);
+        }
+        if ast::AlterServer::can_cast(ancestor.kind()) {
+            return Some(NameRefClass::AlterServer);
+        }
+        if ast::CreateServer::can_cast(ancestor.kind()) {
+            return Some(NameRefClass::CreateServer);
+        }
+        if ast::ServerName::can_cast(ancestor.kind()) {
+            return Some(NameRefClass::ForeignTableServerName);
+        }
         if let Some(sequence_option) = ast::SequenceOption::cast(ancestor.clone())
             && sequence_option.owned_token().is_some()
             && sequence_option.by_token().is_some()
@@ -333,7 +349,7 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
             }
             return Some(NameRefClass::CreateIndex);
         }
-        if in_partition_item && ast::CreateTable::can_cast(ancestor.kind()) {
+        if in_partition_item && ast::CreateTableLike::can_cast(ancestor.kind()) {
             return Some(NameRefClass::PartitionByColumn);
         }
         if ast::PartitionOf::can_cast(ancestor.kind()) {
@@ -421,20 +437,16 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
 #[derive(Debug)]
 pub(crate) enum NameClass {
     ColumnDefinition {
-        create_table: ast::CreateTable,
-        column: ast::Column,
-    },
-    ColumnDefinitionForeignTable {
-        create_foreign_table: ast::CreateForeignTable,
+        create_table: ast::CreateTableLike,
         column: ast::Column,
     },
-    CreateTable(ast::CreateTable),
-    CreateForeignTable(ast::CreateForeignTable),
+    CreateTable(ast::CreateTableLike),
     WithTable(ast::WithTable),
     CreateIndex(ast::CreateIndex),
     CreateSequence(ast::CreateSequence),
     CreateTablespace(ast::CreateTablespace),
     CreateDatabase(ast::CreateDatabase),
+    CreateServer(ast::CreateServer),
     CreateType(ast::CreateType),
     CreateFunction(ast::CreateFunction),
     CreateAggregate(ast::CreateAggregate),
@@ -457,7 +469,7 @@ pub(crate) fn classify_name(name: &ast::Name) -> Option<NameClass> {
         if !has_column_list && ast::ColumnList::can_cast(ancestor.kind()) {
             has_column_list = true;
         }
-        if let Some(create_table) = ast::CreateTable::cast(ancestor.clone()) {
+        if let Some(create_table) = ast::CreateTableLike::cast(ancestor.clone()) {
             if let Some(column) = column_parent {
                 return Some(NameClass::ColumnDefinition {
                     create_table,
@@ -466,15 +478,6 @@ pub(crate) fn classify_name(name: &ast::Name) -> Option<NameClass> {
             }
             return Some(NameClass::CreateTable(create_table));
         }
-        if let Some(create_foreign_table) = ast::CreateForeignTable::cast(ancestor.clone()) {
-            if let Some(column) = column_parent {
-                return Some(NameClass::ColumnDefinitionForeignTable {
-                    create_foreign_table,
-                    column,
-                });
-            }
-            return Some(NameClass::CreateForeignTable(create_foreign_table));
-        }
         if let Some(create_index) = ast::CreateIndex::cast(ancestor.clone()) {
             return Some(NameClass::CreateIndex(create_index));
         }
@@ -487,6 +490,9 @@ pub(crate) fn classify_name(name: &ast::Name) -> Option<NameClass> {
         if let Some(create_database) = ast::CreateDatabase::cast(ancestor.clone()) {
             return Some(NameClass::CreateDatabase(create_database));
         }
+        if let Some(create_server) = ast::CreateServer::cast(ancestor.clone()) {
+            return Some(NameClass::CreateServer(create_server));
+        }
         if let Some(create_type) = ast::CreateType::cast(ancestor.clone()) {
             return Some(NameClass::CreateType(create_type));
         }

crates/squawk_ide/src/goto_definition.rs

@@ -416,6 +416,62 @@ create database my$0db;
         ");
     }
 
+    #[test]
+    fn goto_drop_server() {
+        assert_snapshot!(goto("
+create server myserver foreign data wrapper fdw;
+drop server my$0server;
+"), @r"
+          ╭▸ 
+        2 │ create server myserver foreign data wrapper fdw;
+          │               ──────── 2. destination
+        3 │ drop server myserver;
+          ╰╴             ─ 1. source
+        ");
+    }
+
+    #[test]
+    fn goto_drop_server_defined_after() {
+        assert_snapshot!(goto("
+drop server my$0server;
+create server myserver foreign data wrapper fdw;
+"), @r"
+          ╭▸ 
+        2 │ drop server myserver;
+          │              ─ 1. source
+        3 │ create server myserver foreign data wrapper fdw;
+          ╰╴              ──────── 2. destination
+        ");
+    }
+
+    #[test]
+    fn goto_alter_server() {
+        assert_snapshot!(goto("
+create server myserver foreign data wrapper fdw;
+alter server my$0server options (add foo 'bar');
+"), @r"
+          ╭▸ 
+        2 │ create server myserver foreign data wrapper fdw;
+          │               ──────── 2. destination
+        3 │ alter server myserver options (add foo 'bar');
+          ╰╴              ─ 1. source
+        ");
+    }
+
+    #[test]
+    fn goto_server_definition_returns_self() {
+        assert_snapshot!(goto("
+create server my$0server foreign data wrapper fdw;
+"), @r"
+          ╭▸ 
+        2 │ create server myserver foreign data wrapper fdw;
+          │               ┬┬──────
+          │               ││
+          │               │1. source
+          ╰╴              2. destination
+        ");
+    }
+
     #[test]
     fn goto_drop_sequence_with_schema() {
         assert_snapshot!(goto("
@@ -553,6 +609,51 @@ select a from ft$0;
         ");
     }
 
+    #[test]
+    fn goto_foreign_table_server_name() {
+        assert_snapshot!(goto("
+create server myserver foreign data wrapper fdw;
+create foreign table ft(a int)
+  server my$0server;
+"), @r"
+          ╭▸ 
+        2 │ create server myserver foreign data wrapper fdw;
+          │               ──────── 2. destination
+        3 │ create foreign table ft(a int)
+        4 │   server myserver;
+          ╰╴          ─ 1. source
+        ");
+    }
+
+    #[test]
+    fn goto_foreign_table_server_name_defined_after() {
+        assert_snapshot!(goto("
+create foreign table ft(a int)
+  server my$0server;
+create server myserver foreign data wrapper fdw;
+"), @r"
+          ╭▸ 
+        3 │   server myserver;
+          │           ─ 1. source
+        4 │ create server myserver foreign data wrapper fdw;
+          ╰╴              ──────── 2. destination
+        ");
+    }
+
+    #[test]
+    fn goto_user_mapping_server_name() {
+        assert_snapshot!(goto("
+create server myserver foreign data wrapper fdw;
+create user mapping for current_user server my$0server;
+"), @r"
+          ╭▸ 
+        2 │ create server myserver foreign data wrapper fdw;
+          │               ──────── 2. destination
+        3 │ create user mapping for current_user server myserver;
+          ╰╴                                             ─ 1. source
+        ");
+    }
+
     #[test]
     fn goto_foreign_key_references_table() {
         assert_snapshot!(goto("