fix autocomplete: qualified columns, self-join aliases, phantom suggestions, star context

- Filter column suggestions by qualifier in dot-references (t1. only shows t1 columns)
- Emit alias-qualified columns in self-joins (t1.amount, t2.amount) to avoid ambiguity
- Filter phantom suggestions from computeContentAssist
- Distinguish wildcard * (SELECT *) from multiplication * (price *) for expression scope
- Suppress function flooding in post-expression position (SELECT * FR -> only keywords)
- Suppress suggestions inside string literals and quoted identifiers (parser guard)
- Add comprehensive tests for all above scenarios

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: emrberk

src/autocomplete/content-assist.ts

@@ -70,6 +70,12 @@ export interface ContentAssistResult {
   isMidWord: boolean
   /** Any lexer errors */
   lexErrors: ILexingError[]
+  /**
+   * When the cursor is after a qualified reference (e.g., "t1." or "trades."),
+   * this contains the qualifier name (e.g., "t1" or "trades"). The provider
+   * should resolve this against tablesInScope aliases/names to filter columns.
+   */
+  qualifiedTableRef?: string
 }
 
 // =============================================================================
@@ -813,9 +819,11 @@ export function getContentAssist(
     }
   }
 
-  if (tablesInScope.length === 0) {
-    const inferred = inferTableFromQualifiedRef(tokens, isMidWord)
-    if (inferred) tablesInScope.push(inferred)
+  // Detect qualified reference context (e.g., "t1." or "trades.sym")
+  // and extract the qualifier name so the provider can filter columns.
+  const qualifiedRef = inferTableFromQualifiedRef(tokens, isMidWord)
+  if (tablesInScope.length === 0 && qualifiedRef) {
+    tablesInScope.push(qualifiedRef)
   }
 
   return {
@@ -825,6 +833,7 @@ export function getContentAssist(
     tokensBefore: tokens,
     isMidWord,
     lexErrors: lexResult.errors,
+    qualifiedTableRef: qualifiedRef?.table,
   }
 }
 

src/autocomplete/provider.ts

@@ -80,6 +80,7 @@ function getIdentifierSuggestionScope(
   lastTokenName?: string,
   prevTokenName?: string,
   rawLastTokenName?: string,
+  rawPrevTokenName?: string,
 ): {
   includeColumns: boolean
   includeTables: boolean
@@ -90,6 +91,20 @@ function getIdentifierSuggestionScope(
     return { includeColumns: false, includeTables: false }
   }
 
+  // Star (*) is context-dependent: it's a wildcard after SELECT/comma/LParen,
+  // but multiplication after an expression (identifier, number, rparen).
+  // "SELECT * |"      → wildcard, suppress columns (alias/keyword position)
+  // "SELECT price * |" → multiplication, suggest columns for RHS
+  if (rawLastTokenName === "Star") {
+    if (rawPrevTokenName && isExpressionEnd(rawPrevTokenName)) {
+      // Multiplication: previous token is an expression-end, so * is an operator.
+      // The user needs columns/functions for the right-hand side.
+      return { includeColumns: true, includeTables: true }
+    }
+    // Wildcard: no expression before *, e.g., SELECT *, t.*, or start of expression
+    return { includeColumns: false, includeTables: false }
+  }
+
   // After AS keyword: either subquery start (WITH name AS (|) or alias (SELECT x AS |).
   if (lastTokenName === "As") {
     // "WITH name AS (|" → LParen is raw last → subquery start, suggest tables
@@ -156,6 +171,7 @@ export function createAutocompleteProvider(
         cteColumns,
         tokensBefore,
         isMidWord,
+        qualifiedTableRef,
       } = getContentAssist(query, cursorOffset)
 
       // Merge CTE columns into the schema so getColumnsInScope() can find them
@@ -167,6 +183,43 @@ export function createAutocompleteProvider(
             }
           : normalizedSchema
 
+      // When mid-word, the last token in tokensBefore is a partial word
+      // the user is still typing. It may have been captured as a table name
+      // by extractTables (e.g., "FROM te" → {table: "te"}). Filter it out
+      // to prevent suggesting the incomplete text back to the user.
+      let effectiveTablesInScope = tablesInScope
+      if (isMidWord && tokensBefore.length > 0) {
+        const partialLower =
+          tokensBefore[tokensBefore.length - 1].image.toLowerCase()
+        const cteNameSet = new Set(Object.keys(cteColumns))
+        const schemaLower = new Set(
+          normalizedSchema.tables.map((t) => t.name.toLowerCase()),
+        )
+        effectiveTablesInScope = tablesInScope.filter((t) => {
+          const lower = t.table.toLowerCase()
+          return (
+            lower !== partialLower ||
+            cteNameSet.has(lower) ||
+            schemaLower.has(lower)
+          )
+        })
+      }
+
+      // When the cursor is in a qualified reference (e.g., "t1." or "trades."),
+      // resolve the qualifier against tablesInScope aliases/names and filter
+      // so only that table's columns are suggested.
+      if (qualifiedTableRef && effectiveTablesInScope.length > 1) {
+        const qualifierLower = qualifiedTableRef.toLowerCase()
+        const matched = effectiveTablesInScope.filter(
+          (t) =>
+            t.alias?.toLowerCase() === qualifierLower ||
+            t.table.toLowerCase() === qualifierLower,
+        )
+        if (matched.length > 0) {
+          effectiveTablesInScope = matched
+        }
+      }
+
       // If parser returned valid next tokens, use them
       if (nextTokenTypes.length > 0) {
         // When mid-word, the last token in tokensBefore is the partial word being typed.
@@ -181,15 +234,20 @@ export function createAutocompleteProvider(
           tokensForScope.length > 0
             ? tokensForScope[tokensForScope.length - 1]?.tokenType?.name
             : undefined
+        const rawPrevTokenName =
+          tokensForScope.length > 1
+            ? tokensForScope[tokensForScope.length - 2]?.tokenType?.name
+            : undefined
         const scope = getIdentifierSuggestionScope(
           lastTokenName,
           prevTokenName,
           rawLastTokenName,
+          rawPrevTokenName,
         )
         return buildSuggestions(
           nextTokenTypes,
           effectiveSchema,
-          tablesInScope,
+          effectiveTablesInScope,
           { ...scope, isMidWord },
         )
       }

src/autocomplete/suggestion-builder.ts

@@ -28,6 +28,7 @@ import type { TableRef } from "./content-assist"
  */
 interface ColumnWithTable extends ColumnInfo {
   tableName: string
+  tableAlias?: string
 }
 
 /**
@@ -48,6 +49,7 @@ function getColumnsInScope(
       columns.push({
         ...col,
         tableName: tableRef.table,
+        tableAlias: tableRef.alias,
       })
     }
   }
@@ -157,36 +159,86 @@ export function buildSuggestions(
       : []
 
     // Add columns with HIGH priority (they should appear first).
-    // Deduplicate by column name, collecting all table names per column.
+    // When a column name appears from multiple distinct aliased table refs
+    // (e.g., self-join: trades t1 JOIN trades t2), emit alias-qualified
+    // suggestions (e.g., "t1.amount", "t2.amount") to avoid ambiguity.
+    // Otherwise, emit a single bare column name.
     if (includeColumns) {
-      const columnMap = new Map<string, { type: string; tables: string[] }>()
+      // Group columns by name, collecting each source (alias/table + type).
+      const columnMap = new Map<
+        string,
+        {
+          sources: {
+            qualifier: string
+            type: string
+            hasAlias: boolean
+          }[]
+        }
+      >()
       for (const col of columnsInScope) {
+        const qualifier = col.tableAlias ?? col.tableName
         const existing = columnMap.get(col.name)
         if (existing) {
-          if (!existing.tables.includes(col.tableName)) {
-            existing.tables.push(col.tableName)
+          // Only add if this qualifier is new (avoid duplicates from same alias)
+          if (!existing.sources.some((s) => s.qualifier === qualifier)) {
+            existing.sources.push({
+              qualifier,
+              type: col.type,
+              hasAlias: !!col.tableAlias,
+            })
           }
         } else {
-          columnMap.set(col.name, { type: col.type, tables: [col.tableName] })
+          columnMap.set(col.name, {
+            sources: [
+              { qualifier, type: col.type, hasAlias: !!col.tableAlias },
+            ],
+          })
         }
       }
       for (const [colName, info] of columnMap) {
-        suggestions.unshift({
-          label: colName,
-          kind: SuggestionKind.Column,
-          insertText: colName,
-          detail: ` (${info.tables.sort().join(", ")})`,
-          description: info.tables.length > 1 ? "" : info.type,
-          priority: SuggestionPriority.High,
-        })
+        // Only qualify when there are multiple sources and at least one has
+        // an explicit alias. This covers self-joins (trades t1 JOIN trades t2)
+        // without qualifying columns from unrelated CTEs that happen to share
+        // column names.
+        const needsQualification =
+          info.sources.length > 1 && info.sources.some((s) => s.hasAlias)
+        if (needsQualification) {
+          // Ambiguous: emit one qualified suggestion per source
+          for (const source of info.sources) {
+            const qualified = `${source.qualifier}.${colName}`
+            suggestions.unshift({
+              label: qualified,
+              kind: SuggestionKind.Column,
+              insertText: qualified,
+              detail: ` (${source.qualifier})`,
+              description: source.type,
+              filterText: colName,
+              priority: SuggestionPriority.High,
+            })
+          }
+        } else {
+          // Unambiguous: emit bare column name
+          const source = info.sources[0]
+          suggestions.unshift({
+            label: colName,
+            kind: SuggestionKind.Column,
+            insertText: colName,
+            detail: ` (${source.qualifier})`,
+            description: source.type,
+            priority: SuggestionPriority.High,
+          })
+        }
       }
     }
 
     // Add functions when the user is mid-word (typing a prefix).
     // This avoids flooding the list with ~300 functions when the user
     // just typed "SELECT " with no prefix. Functions are valid in both
     // expression context (SELECT md5(...)) and table context (FROM long_sequence(...)).
-    if (isMidWord) {
+    // Skip functions in post-expression position (includeColumns=false,
+    // includeTables=false) — e.g., after "SELECT *" the user is typing a
+    // keyword (FROM) or alias, not a function call.
+    if (isMidWord && (includeColumns || includeTables)) {
       for (const fn of functions) {
         if (seenKeywords.has(fn.toUpperCase())) continue
         suggestions.push({