sarj-python-lint 1.108.52__tar.gz → 1.109.0__tar.gz

{sarj_python_lint-1.108.52 → sarj_python_lint-1.109.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.108.52
+Version: 1.109.0
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://code-standards.sarj.ai/rules/python/
 Project-URL: Documentation, https://code-standards.sarj.ai/rules/python/

{sarj_python_lint-1.108.52 → sarj_python_lint-1.109.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.108.52"
+version = "1.109.0"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]

{sarj_python_lint-1.108.52 → sarj_python_lint-1.109.0}/src/sarj_python_lint/__main__.py

@@ -222,15 +222,18 @@ def check_source(
 ) -> list[Diagnostic]:
     from sarj_python_lint._file_context import PythonFileContext  # ruff: ignore[import-outside-top-level] -- source checks own native AST context construction.
 
-    context = PythonFileContext(p, source, session)
+    return check_context(rules, PythonFileContext(p, source, session))
+
+
+def check_context(rules: list[Rule], context: PythonFileContext) -> list[Diagnostic]:
     if rules and context.tree is None:
-        msg = f"selected Python source could not be parsed: {p}"
+        msg = f"selected Python source could not be parsed: {context.path}"
         raise ValueError(msg)
     source_lines = context.source_lines
     raw = [diagnostic for rule in rules for diagnostic in rule.check_context(context)]
     return deduplicate_diagnostics(
         [diagnostic for diagnostic in raw if not is_suppressed(source_lines, diagnostic.line, diagnostic.code)],
-        source=source,
+        source=context.source,
         context=context,
     )
 

{sarj_python_lint-1.108.52 → sarj_python_lint-1.109.0}/src/sarj_python_lint/_autofix.py

@@ -26,7 +26,7 @@ from sarj_python_lint._autofix_exhaustiveness import ExhaustivenessFixes
 from sarj_python_lint._autofix_parameters import ParameterFixes
 from sarj_python_lint._autofix_repeated import RepeatedLiteralFixes
 from sarj_python_lint._autofix_security import fixes as security_fixes
-from sarj_python_lint._autofix_sql_projection import fixes as sql_projection_fixes
+from sarj_python_lint._autofix_sql_projection import alias_fixes as sql_alias_fixes, fixes as sql_projection_fixes
 from sarj_python_lint._autofix_tests import fixes as testing_fixes
 from sarj_python_lint._file_context import PythonFileContext
 from sarj_python_lint._fixes import apply_fixes as apply_native_fixes
@@ -41,6 +41,7 @@ from sarj_python_lint.rules import (
 from sarj_python_lint.rules._ast_index import object_list
 from sarj_python_lint.rules._closed_helpers import dynamic_namespace
 from sarj_python_lint.rules._resource_provenance import ResourceProvenance
+from sarj_python_lint.rules.prefer_match_type_dispatch import body_terminates
 
 
 if TYPE_CHECKING:
@@ -81,6 +82,7 @@ _WALRUS_CODES = frozenset({"SARJ081", "SARJ432"})
 _JWT_POSITIONAL_PREFIX_ARGUMENTS = 3
 _STREAM_MIN_BODY_LENGTH = 3
 _CONSTANT_TRUE_DEPTH_LIMIT = 32
+_INERT_DEFAULT_NODE_LIMIT: Final = 128
 # Bound accepted revisions; each rule still owns its work and replacement size.
 _MAX_FIX_PASSES: Final = 256
 _PURE_STRING_TRANSFORMS: Final[dict[str, str]] = {
@@ -125,6 +127,9 @@ class _Source:
         self.export_locations = frozenset(
             (diagnostic.line, diagnostic.col) for diagnostic in diagnostics if diagnostic.code == "SARJ098"
         )
+        self.test_comment_locations = frozenset(
+            (diagnostic.line, diagnostic.col) for diagnostic in diagnostics if diagnostic.code == "SARJ551"
+        )
 
     @cached_property
     def enums(self) -> EnumFixes:
@@ -140,7 +145,7 @@ class _Source:
 
     @cached_property
     def commentary(self) -> CommentFixes:
-        return CommentFixes(self.context)
+        return CommentFixes(self.context, test_comment_locations=self.test_comment_locations)
 
     @cached_property
     def declared_contracts(self) -> DeclaredContractFixes:
@@ -460,6 +465,10 @@ def _sql_projection_fix(source: _Source, diagnostic: Diagnostic) -> list[TextEdi
     return sql_projection_fixes(source.context, diagnostic)
 
 
+def _sql_alias_fix(source: _Source, diagnostic: Diagnostic) -> list[TextEdit]:
+    return sql_alias_fixes(source.context, diagnostic)
+
+
 def _alias_fix(source: _Source, diagnostic: Diagnostic) -> list[TextEdit]:
     if not diagnostic.fixes:
         return source.aliases.fixes(diagnostic)
@@ -767,9 +776,15 @@ def _dispatch_fix(source: _Source, diagnostic: Diagnostic) -> list[TextEdit]:
     if diagnostic.code == "SARJ080" and diagnostic.severity is not Severity.ERROR:
         return []
     for root in source.context.nodes(ast.If):
-        if not _at(root, diagnostic) or source.comments_between(root.lineno, _last_line(root)):
+        if not _at(root, diagnostic):
             continue
-        matched = _dispatch_match(root, source.context, type_dispatch=diagnostic.code == "SARJ080")
+        type_dispatch = diagnostic.code == "SARJ080"
+        roots = _dispatch_roots(root, source.context) if type_dispatch else [root]
+        if source.comments_between(root.lineno, _last_line(roots[-1])) or (
+            len(roots) > 1 and any(source.full_statement(branch) is None for branch in roots)
+        ):
+            continue
+        matched = _dispatch_match(roots, source.context, type_dispatch=type_dispatch)
         if matched is None or not isinstance(matched.subject, ast.Name):
             continue
         if not _dispatch_parameter(root, matched.subject, source):
@@ -777,15 +792,41 @@ def _dispatch_fix(source: _Source, diagnostic: Diagnostic) -> list[TextEdit]:
         rendered = ast.unparse(matched)
         indent = source.lines[root.lineno - 1][: root.col_offset]
         newline = "\r\n" if "\r\n" in source.text else "\n"
-        return [source.replace(root, (newline + indent).join(rendered.splitlines()))]
+        return [
+            TextEdit(
+                source.span(root).start, source.span(roots[-1]).end, (newline + indent).join(rendered.splitlines())
+            )
+        ]
     return []
 
 
-def _dispatch_match(root: ast.If, context: PythonFileContext, *, type_dispatch: bool) -> ast.Match | None:
+def _dispatch_roots(root: ast.If, context: PythonFileContext) -> list[ast.If]:
+    if root.orelse:
+        return [root]
+    parent = context.parents.get(root)
+    for field in ("body", "orelse", "finalbody"):
+        value: object = getattr(  # sarj-noqa: SARJ557 -- Inspect optional statement-list fields across heterogeneous AST node types.
+            parent, field, None
+        )
+        if not object_list(value) or root not in value:
+            continue
+        branches: list[ast.If] = []
+        for statement in value[value.index(root) :]:
+            if isinstance(statement, ast.If) and statement.orelse:
+                return [root]
+            if not isinstance(statement, ast.If) or not body_terminates(statement.body):
+                break
+            branches.append(statement)
+        return branches or [root]
+    return [root]
+
+
+def _dispatch_match(roots: Sequence[ast.If], context: PythonFileContext, *, type_dispatch: bool) -> ast.Match | None:
     cases: list[ast.match_case] = []
-    branch = root
+    pending = list(reversed(roots))
     subject: ast.Name | None = None
-    while True:
+    while pending:
+        branch = pending.pop()
         if type_dispatch and _type_parameter_reference(branch.test, context):
             return None
         pattern = _dispatch_pattern(branch.test, type_dispatch=type_dispatch)
@@ -794,11 +835,12 @@ def _dispatch_match(root: ast.If, context: PythonFileContext, *, type_dispatch:
         subject = pattern[0]
         cases.append(ast.match_case(pattern=pattern[1], guard=None, body=branch.body))
         if len(branch.orelse) == 1 and isinstance(branch.orelse[0], ast.If):
-            branch = branch.orelse[0]
-            continue
-        if branch.orelse:
+            pending.append(branch.orelse[0])
+        elif branch.orelse:
             cases.append(ast.match_case(pattern=ast.MatchAs(), guard=None, body=branch.orelse))
-        return ast.Match(subject=subject, cases=cases)
+    if subject is None or (type_dispatch and len(cases) == 1):
+        return None
+    return ast.Match(subject=subject, cases=cases)
 
 
 def _dispatch_pattern(test: ast.expr, *, type_dispatch: bool) -> tuple[ast.Name, ast.pattern] | None:
@@ -1233,32 +1275,79 @@ def _literal_collection_element(element: ast.expr, names: frozenset[str]) -> boo
     return isinstance(element, ast.Constant) or (isinstance(element, ast.Name) and element.id in names)
 
 
-def _inert_definition(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+def _inert_definition(node: ast.FunctionDef | ast.AsyncFunctionDef, *, postponed_annotations: bool) -> bool:
     args = node.args
     if node.decorator_list or node.type_params:
         return False
     return not (
-        args.defaults
-        or any(value is not None for value in args.kw_defaults)
-        or node.returns is not None
-        or any(
-            argument.annotation is not None
-            for argument in (*args.posonlyargs, *args.args, *args.kwonlyargs, args.vararg, args.kwarg)
-            if argument is not None
+        any(not _inert_default(value) for value in args.defaults)
+        or any(value is not None and not _inert_default(value) for value in args.kw_defaults)
+        or (
+            not postponed_annotations
+            and (
+                not _inert_annotation(node.returns)
+                or any(
+                    not _inert_annotation(argument.annotation)
+                    for argument in (*args.posonlyargs, *args.args, *args.kwonlyargs, args.vararg, args.kwarg)
+                    if argument is not None
+                )
+            )
         )
     )
 
 
+def _inert_default(value: ast.expr) -> bool:
+    if isinstance(value, ast.Constant):
+        return True
+    pending: list[tuple[ast.expr, bool]] = [(value, False)]
+    remaining = _INERT_DEFAULT_NODE_LIMIT
+    while pending:
+        if not remaining:
+            return False
+        expression, numeric_required = pending.pop()
+        remaining -= 1
+        match expression:
+            case ast.Constant(value=literal):
+                literal_type = type(literal)
+                if (
+                    numeric_required
+                    and literal_type is not int
+                    and literal_type is not float
+                    and literal_type is not complex
+                ):
+                    return False
+                continue
+            case ast.Tuple(elts=elements) if not numeric_required:
+                children: Sequence[ast.expr] = elements
+                child_numeric_required = False
+            case ast.UnaryOp(op=ast.UAdd() | ast.USub(), operand=operand):
+                children = (operand,)
+                child_numeric_required = True
+            case _:
+                return False
+        if len(children) + len(pending) > remaining:
+            return False
+        pending.extend((child, child_numeric_required) for child in children)
+    return True
+
+
+def _inert_annotation(annotation: ast.expr | None) -> bool:
+    return annotation is None or (
+        isinstance(annotation, ast.Constant) and (annotation.value is None or isinstance(annotation.value, str))
+    )
+
+
 def _stepdown_fix(source: _Source, diagnostic: Diagnostic) -> list[TextEdit]:
     tree = source.context.tree
     if tree is None:
         return []
+    postponed_annotations = _postponed_module_annotations(tree) or bool(source.context.nodes(ast.TemplateStr))
     for index, helper in enumerate(tree.body):
         if not isinstance(helper, (ast.FunctionDef, ast.AsyncFunctionDef)) or not _at(helper, diagnostic):
             continue
-        if not _inert_definition(helper):
+        if not _inert_definition(helper, postponed_annotations=postponed_annotations):
             continue
-        caller = _inert_stepdown_caller(helper, tree.body[index + 1 :])
+        caller = _inert_stepdown_caller(helper, tree.body[index + 1 :], postponed_annotations=postponed_annotations)
         if caller is None or _stepdown_comments(helper, caller, source):
             continue
         span = source.full_statement(helper)
@@ -1270,20 +1359,37 @@ def _stepdown_fix(source: _Source, diagnostic: Diagnostic) -> list[TextEdit]:
     return []
 
 
+def _postponed_module_annotations(tree: ast.Module) -> bool:
+    for index, statement in enumerate(tree.body):
+        if (
+            index == 0
+            and isinstance(statement, ast.Expr)
+            and isinstance(statement.value, ast.Constant)
+            and isinstance(statement.value.value, str)
+        ):
+            continue
+        if not isinstance(statement, ast.ImportFrom) or statement.module != "__future__" or statement.level != 0:
+            return False
+        if any(alias.name == "annotations" for alias in statement.names):
+            return True
+    return False
+
+
 def _inert_stepdown_caller(
-    helper: ast.FunctionDef | ast.AsyncFunctionDef, later: list[ast.stmt]
+    helper: ast.FunctionDef | ast.AsyncFunctionDef, later: list[ast.stmt], *, postponed_annotations: bool
 ) -> ast.FunctionDef | ast.AsyncFunctionDef | None:
     callers = [
         node
         for node in later
         if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and _calls_function(node, helper.name)
     ]
-    if len(callers) != 1 or not _inert_definition(callers[0]):
+    if len(callers) != 1 or not _inert_definition(callers[0], postponed_annotations=postponed_annotations):
         return None
     caller = callers[0]
     for node in later:
         if node.lineno <= caller.lineno and (
-            not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) or not _inert_definition(node)
+            not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+            or not _inert_definition(node, postponed_annotations=postponed_annotations)
         ):
             return None
     return caller
@@ -1322,6 +1428,7 @@ def _parameter_fix(source: _Source, diagnostic: Diagnostic) -> list[TextEdit]:
 
 _BUILDERS: Final[dict[str, Callable[[_Source, Diagnostic], list[TextEdit]]]] = {
     "SARJ021": _sql_projection_fix,
+    "SARJ543": _sql_alias_fix,
     "SARJ002": _literal_loop_fix,
     "SARJ006": _enum_fix,
     "SARJ011": _security_fix,
@@ -1332,7 +1439,7 @@ _BUILDERS: Final[dict[str, Callable[[_Source, Diagnostic], list[TextEdit]]]] = {
     "SARJ024": _repeated_fix,
     "SARJ032": _exhaustiveness_fix,
     "SARJ046": _xfail_fix,
-    **dict.fromkeys({"SARJ049", "SARJ051", "SARJ054", "SARJ434"}, _commentary_fix),
+    **dict.fromkeys({"SARJ049", "SARJ051", "SARJ054", "SARJ434", "SARJ551"}, _commentary_fix),
     "SARJ067": _mock_fix,
     "SARJ068": _fstring_fix,
     "SARJ070": _pattern_fix,
@@ -1378,7 +1485,7 @@ class _FixPass:
 
 
 def fix_source(path: Path, source: str, *, rule_ids: Sequence[str] | None = None) -> str:
-    from sarj_python_lint.__main__ import check_source  # ruff: ignore[import-outside-top-level] -- the CLI imports this entry point lazily.
+    from sarj_python_lint.__main__ import check_context  # ruff: ignore[import-outside-top-level] -- the CLI imports this entry point lazily.
 
     selected = list(REGISTRY) if rule_ids is None else list(rule_ids)
     rules = [REGISTRY[rule_id]() for rule_id in selected if REGISTRY[rule_id].code in _BUILDERS]
@@ -1394,16 +1501,13 @@ def fix_source(path: Path, source: str, *, rule_ids: Sequence[str] | None = None
     while (fingerprint := sha256(current.encode("utf-8")).digest()) not in seen:
         seen.add(fingerprint)
         context = PythonFileContext(path, current)
-        diagnostics = check_source(rules, path, current)
+        diagnostics = check_context(rules, context)
         candidates = _candidate_edits(context, diagnostics)
         if not candidates:
             return current
         # Batch independent candidates; overlapping candidates get fresh offsets on the next pass.
         selected_pass = _coherent_edits(candidates)
-        updated = apply_edits(current, selected_pass.edits)
-        compile(  # sarj-noqa: SARJ557 -- Compile proposed fixes to reject invalid scopes without executing them.
-            updated, str(path), "exec", dont_inherit=True
-        )
+        updated = _apply_validated_edits(path, current, selected_pass.edits)
         if updated == current:
             return current
         if passes == _MAX_FIX_PASSES:
@@ -1414,6 +1518,23 @@ def fix_source(path: Path, source: str, *, rule_ids: Sequence[str] | None = None
     raise _convergence_error(path, reason="source cycle", passes=passes, codes=applied_codes)
 
 
+def _apply_validated_edits(path: Path, current: str, edits: Sequence[TextEdit]) -> str:
+    updated = apply_edits(current, edits)
+    try:
+        compile(  # sarj-noqa: SARJ557 -- Compile proposed fixes to reject invalid scopes without executing them.
+            updated, str(path), "exec", dont_inherit=True
+        )
+    except SyntaxError:
+        try:
+            compile(  # sarj-noqa: SARJ557 -- Distinguish pre-existing invalid scope from a broken generated fix without executing input.
+                current, str(path), "exec", dont_inherit=True
+            )
+        except SyntaxError:
+            return current
+        raise
+    return updated
+
+
 def _convergence_error(
     path: Path, *, reason: Literal["pass budget exhausted", "source cycle"], passes: int, codes: set[str]
 ) -> ValueError:
@@ -1423,6 +1544,8 @@ def _convergence_error(
 
 
 def _candidate_edits(context: PythonFileContext, diagnostics: Sequence[Diagnostic]) -> list[_FixCandidate]:
+    if not diagnostics:
+        return []
     view = _Source(context, diagnostics)
     return [
         _FixCandidate(diagnostic.code, tuple(edits))

{sarj_python_lint-1.108.52 → sarj_python_lint-1.109.0}/src/sarj_python_lint/_autofix_comments.py

@@ -24,13 +24,18 @@ _UNUSED_API_DIRECTIVE = re.compile(
     r"#\s*ruff:\s*(?:noqa\s*:\s*TID251|file-ignore\s*\[\s*(?:TID251|banned-api)\s*\])\s*\Z",
     re.IGNORECASE,
 )
-_MIN_PARAGRAPH_LINES = 4
 
 
 @final
 class CommentFixes:
-    def __init__(self, context: PythonFileContext) -> None:
+    def __init__(
+        self,
+        context: PythonFileContext,
+        *,
+        test_comment_locations: frozenset[tuple[int, int]] = frozenset(),
+    ) -> None:
         self.context = context
+        self.test_comment_locations = test_comment_locations
         self.lines = StringIO(context.source, newline="").readlines()
         self.starts = [0]
         for line in self.lines:
@@ -57,8 +62,12 @@ class CommentFixes:
         if diagnostic.code == "SARJ054" and self._unused_api_directive(token):
             return [self._remove(token)]
         if diagnostic.code == "SARJ434" and diagnostic.severity is Severity.ERROR:
-            paragraph = self._restates_accumulation(token)
+            paragraph = self._restates_narration(token)
             return [self._remove(comment) for comment in paragraph]
+        if diagnostic.code == "SARJ551":
+            paragraph = self._restates_narration(token)
+            if all((comment.start[0], comment.start[1] + 1) in self.test_comment_locations for comment in paragraph):
+                return [self._remove(comment) for comment in paragraph]
         return []
 
     def _unused_api_directive(self, comment: tokenize.TokenInfo) -> bool:
@@ -114,18 +123,14 @@ class CommentFixes:
             case _:
                 return False
 
-    def _restates_accumulation(self, first: tokenize.TokenInfo) -> list[tokenize.TokenInfo]:
+    def _restates_narration(self, first: tokenize.TokenInfo) -> list[tokenize.TokenInfo]:
         group = self.prose_groups.get((first.start[0], first.start[1] + 1))
         if group is None:
             return []
         if self.narration is None:
             self.narration = CommentNarration(self.context)
         matched = self.narration.match(group)
-        if (
-            matched is not None
-            and matched.kind == "accumulation"
-            and len(matched.comment_lines) >= _MIN_PARAGRAPH_LINES
-        ):
+        if matched is not None:
             return [self.comments[line] for line in matched.comment_lines]
         return []
 

sarj_python_lint-1.109.0/src/sarj_python_lint/_autofix_sql_projection.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from io import StringIO
+import re
+from typing import TYPE_CHECKING
+
+from sarj_rule_contracts import TextEdit, apply_edits
+from sqlglot import exp, parse_one
+from sqlglot.errors import ParseError, TokenError
+
+from sarj_python_lint._closed_sql_literal import (
+    has_comments as _has_comments,
+    literal_query as _literal_query,
+    owned_literal as _owned_literal,
+)
+from sarj_python_lint.rules._ast_index import object_list
+from sarj_python_lint.rules._store_sql import sql_child, sql_children
+from sarj_python_lint.rules.no_redundant_sql_alias import identifier_key
+
+
+if TYPE_CHECKING:
+    import ast
+
+    from sarj_python_lint._file_context import PythonFileContext
+    from sarj_python_lint.rule_base import Diagnostic
+
+
+_QUERY = re.compile(
+    r"[ \t]*SELECT[ \t]+(?P<star>\*)[ \t]+FROM[ \t]+"
+    r"\([ \t]*VALUES[ \t]+\([ \t]*(?P<values>[0-9]{1,9}(?:[ \t]*,[ \t]*[0-9]{1,9}){0,7})"
+    r'[ \t]*\)[ \t]*\)[ \t]+AS[ \t]+(?P<alias>"[A-Za-z_][A-Za-z0-9_]{0,62}")[ \t]*'
+    r'\([ \t]*(?P<labels>"[A-Za-z_][A-Za-z0-9_]{0,62}"'
+    r'(?:[ \t]*,[ \t]*"[A-Za-z_][A-Za-z0-9_]{0,62}"){0,7})[ \t]*\)'
+    r"[ \t]*;?[ \t]*\Z",
+    re.IGNORECASE | re.ASCII,
+)
+_QUERY_LIMIT = 2048
+_SQL_IDENTIFIER = r'(?:"[A-Za-z_][A-Za-z0-9_]{0,62}"|[A-Za-z_][A-Za-z0-9_]{0,62})'
+_INTEGER_LITERAL = re.compile(r"[0-9]{1,9}\Z", re.ASCII)
+_VALUES_ROW = r"\([ \t]*[0-9]{1,9}(?:[ \t]*,[ \t]*[0-9]{1,9}){0,7}[ \t]*\)"
+_VALUES_BOUND = 8
+_SELF_ALIAS_COLUMN = re.compile(
+    rf"(?P<column>{_SQL_IDENTIFIER}\.{_SQL_IDENTIFIER})(?P<alias>[ \t]+AS[ \t]+{_SQL_IDENTIFIER})?",
+    re.IGNORECASE | re.ASCII,
+)
+_SELF_ALIAS_QUERY = re.compile(
+    rf"[ \t]*SELECT[ \t]+(?P<columns>{_SELF_ALIAS_COLUMN.pattern}"
+    rf"(?:[ \t]*,[ \t]*{_SQL_IDENTIFIER}\.{_SQL_IDENTIFIER}(?:[ \t]+AS[ \t]+{_SQL_IDENTIFIER})?){{0,7}})"
+    r"[ \t]+FROM[ \t]+\([ \t]*VALUES[ \t]+"
+    rf"{_VALUES_ROW}(?:[ \t]*,[ \t]*{_VALUES_ROW}){{0,7}}[ \t]*\)"
+    rf"[ \t]+AS[ \t]+{_SQL_IDENTIFIER}[ \t]*\([ \t]*"
+    rf"{_SQL_IDENTIFIER}(?:[ \t]*,[ \t]*{_SQL_IDENTIFIER}){{0,7}}[ \t]*\)[ \t]*;?[ \t]*\Z",
+    re.IGNORECASE | re.ASCII,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class _Projection:
+    offset: int
+    replacement: str
+
+
+def fixes(context: PythonFileContext, diagnostic: Diagnostic) -> list[TextEdit]:
+    tree = context.tree
+    if tree is None or context.generated or _has_comments(context.source):
+        return []
+    literal = _owned_literal(tree)
+    if literal is None or (literal.lineno, literal.col_offset + 1) != (diagnostic.line, diagnostic.col):
+        return []
+    query = _literal_query(context.source, literal)
+    projection = _projection(query) if query is not None else None
+    if projection is None:
+        return []
+    start = _literal_offset(context.source, literal) + projection.offset
+    return [TextEdit(start, start + 1, projection.replacement)]
+
+
+def alias_fixes(context: PythonFileContext, diagnostic: Diagnostic) -> list[TextEdit]:
+    tree = context.tree
+    if tree is None or context.generated or _has_comments(context.source):
+        return []
+    literal = _owned_literal(tree)
+    if literal is None or (literal.lineno, literal.col_offset + 1) != (diagnostic.line, diagnostic.col):
+        return []
+    query = _literal_query(context.source, literal)
+    if query is None:
+        return []
+    start = _literal_offset(context.source, literal)
+    return [TextEdit(start + edit.start, start + edit.end, edit.replacement) for edit in _alias_edits(query)]
+
+
+def _literal_offset(source: str, literal: ast.Constant) -> int:
+    lines = StringIO(source, newline="").readlines()
+    prefix = lines[literal.lineno - 1].encode("utf-8")[: literal.col_offset].decode("utf-8")
+    return sum(map(len, lines[: literal.lineno - 1])) + len(prefix) + 1
+
+
+def _alias_edits(query: str) -> list[TextEdit]:
+    if len(query) > _QUERY_LIMIT or (matched := _SELF_ALIAS_QUERY.fullmatch(query)) is None:
+        return []
+    offset = matched.start("columns")
+    edits = [
+        TextEdit(offset + part.start("alias"), offset + part.end("alias"), "")
+        for part in _SELF_ALIAS_COLUMN.finditer(matched["columns"])
+        if part.group("alias") is not None
+    ]
+    if not edits:
+        return []
+    candidate = apply_edits(query, edits)
+    return edits if _alias_delta(query, candidate) else []
+
+
+def _alias_delta(original: str, candidate: str) -> bool:
+    try:
+        before = parse_one(original, read="postgres")
+        after = parse_one(candidate, read="postgres")
+    except ParseError, TokenError:
+        return False
+    if not isinstance(before, exp.Select) or not isinstance(after, exp.Select):
+        return False
+    columns = _self_alias_columns(before)
+    if columns is None:
+        return False
+    expected = before.copy()
+    expected.set("expressions", [part.copy() for part in columns])
+    return expected == after
+
+
+def _self_alias_columns(statement: exp.Select) -> list[exp.Column] | None:
+    from_clause = sql_child(statement, "from_")
+    relation = sql_child(from_clause, "this") if isinstance(from_clause, exp.From) else None
+    alias = sql_child(relation, "alias") if isinstance(relation, exp.Values) else None
+    if not isinstance(alias, exp.TableAlias):
+        return None
+    qualifier = identifier_key(sql_child(alias, "this"))
+    labels = [identifier_key(part) for part in sql_children(alias, "columns")]
+    if (
+        qualifier is None
+        or None in labels
+        or len(set(labels)) != len(labels)
+        or not isinstance(relation, exp.Values)
+        or not _literal_rows(relation, len(labels))
+    ):
+        return None
+    columns: list[exp.Column] = []
+    for expression in sql_children(statement, "expressions"):
+        column = _self_alias_column(expression)
+        if (
+            column is None
+            or identifier_key(sql_child(column, "table")) != qualifier
+            or identifier_key(sql_child(column, "this")) not in labels
+        ):
+            return None
+        columns.append(column)
+    return columns
+
+
+def _literal_rows(relation: exp.Values, width: int) -> bool:
+    rows = sql_children(relation, "expressions")
+    return (
+        1 <= width <= _VALUES_BOUND
+        and 1 <= len(rows) <= _VALUES_BOUND
+        and all(isinstance(row, exp.Tuple) and _literal_row(row, width) for row in rows)
+    )
+
+
+def _literal_row(row: exp.Tuple, width: int) -> bool:
+    values = sql_children(row, "expressions")
+    return len(values) == width and all(
+        isinstance(value, exp.Literal) and not value.is_string and _INTEGER_LITERAL.fullmatch(value.name) is not None
+        for value in values
+    )
+
+
+def _self_alias_column(expression: exp.Expr) -> exp.Column | None:
+    if isinstance(expression, exp.Column):
+        return expression
+    column = sql_child(expression, "this") if isinstance(expression, exp.Alias) else None
+    if not isinstance(column, exp.Column):
+        return None
+    original = identifier_key(sql_child(column, "this"))
+    return column if original is not None and original == identifier_key(sql_child(expression, "alias")) else None
+
+
+def _projection(query: str) -> _Projection | None:
+    if len(query) > _QUERY_LIMIT or (matched := _QUERY.fullmatch(query)) is None:
+        return None
+    labels = [part.strip() for part in matched["labels"].split(",")]
+    if len(labels) != len(matched["values"].split(",")) or len(set(labels)) != len(labels):
+        return None
+    replacement = ", ".join(f"{matched['alias']}.{label}" for label in labels)
+    candidate = query[: matched.start("star")] + replacement + query[matched.end("star") :]
+    if not _projection_delta(query, candidate):
+        return None
+    return _Projection(offset=matched.start("star"), replacement=replacement)
+
+
+def _projection_delta(original: str, candidate: str) -> bool:
+    try:
+        before = parse_one(original, read="postgres")
+        after = parse_one(candidate, read="postgres")
+    except ParseError, TokenError:
+        return False
+    if not isinstance(before, exp.Select) or not isinstance(after, exp.Select) or before.expressions != [exp.Star()]:
+        return False
+    columns = _projection_columns(after.expressions)
+    if columns is None:
+        return False
+    expected = before.copy()
+    expected.set("expressions", [part.copy() for part in columns])
+    return expected == after
+
+
+def _projection_columns(value: object) -> list[exp.Column] | None:
+    if not object_list(value):
+        return None
+    columns: list[exp.Column] = []
+    for part in value:
+        if not isinstance(part, exp.Column):
+            return None
+        columns.append(part)
+    return columns