Merge branch 'main' into copilot/add-problem-matcher-vscode

Author: ntotten

CHANGELOG.md

@@ -14,6 +14,8 @@ All notable changes to the "prettier-vscode" extension will be documented in thi
 - Fixed parser detection fallback when using plugins with Prettier v3
 - Added new Prettier v3 options: `objectWrap`, `experimentalOperatorPosition`
 - Added support for TypeScript config files (`.prettierrc.ts`, `.prettierrc.cts`, `.prettierrc.mts`, `prettier.config.ts`, etc.) introduced in Prettier 3.5.0 - Thanks to [@dr2009](https://github.com/dr2009)
+- Added `source.fixAll.prettier` code action for use with `editor.codeActionsOnSave` to run Prettier before other formatters like ESLint (#1277)
+- Fixed issue where unnecessary TextEdits were applied when document was already formatted, which could cause spurious changes or cursor positioning issues (#3232)
 
 ## [11.0.0]
 

README.md

@@ -256,6 +256,31 @@ The problem matchers will parse Prettier's output and display:
 - Syntax errors with file, line, column, and error message
 - Warnings for files that need formatting
 
+### Using Code Actions on Save
+
+You can use VS Code's `editor.codeActionsOnSave` to run Prettier before other formatters like ESLint. This is useful when you want to format with Prettier first and then apply ESLint fixes.
+
+```jsonc
+// .vscode/settings.json
+{
+  "editor.codeActionsOnSave": {
+    "source.fixAll.prettier": "explicit",
+  },
+}
+```
+
+You can also combine Prettier with ESLint:
+
+```jsonc
+// .vscode/settings.json
+{
+  "editor.codeActionsOnSave": {
+    "source.fixAll.prettier": "explicit",
+    "source.fixAll.eslint": "explicit",
+  },
+}
+```
+
 ## Workspace Trust
 
 This extension utilizes VS Code [Workspace Trust](https://code.visualstudio.com/docs/editor/workspace-trust) features. When this extension is run on an untrusted workspace, it will only use the built in version of prettier. No plugins, local, or global modules will be supported. Additionally, certain settings are also restricted - see each setting for details.

src/ModuleResolverNode.ts

@@ -402,12 +402,33 @@ export class ModuleResolver implements ModuleResolverInterface {
       return "error";
     }
 
+    // Log what config file was found (if any)
+    if (configPath) {
+      this.loggingService.logInfo(`Using config file at ${configPath}`);
+    }
+
+    // Log if editorconfig will be considered
+    if (vscodeConfig.useEditorConfig) {
+      this.loggingService.logInfo(
+        "EditorConfig support is enabled, checking for .editorconfig files",
+      );
+    }
+
     let resolvedConfig: PrettierOptions | null;
     try {
+      const customConfigPath = vscodeConfig.configPath
+        ? getWorkspaceRelativePath(fileName, vscodeConfig.configPath)
+        : undefined;
+      
+      // Log if a custom config path is specified in VS Code settings
+      if (customConfigPath) {
+        this.loggingService.logInfo(
+          `Using custom config path from settings: ${customConfigPath}`,
+        );
+      }
+
       const resolveConfigOptions: PrettierResolveConfigOptions = {
-        config: vscodeConfig.configPath
-          ? getWorkspaceRelativePath(fileName, vscodeConfig.configPath)
-          : configPath,
+        config: customConfigPath ?? configPath,
         editorconfig: vscodeConfig.useEditorConfig,
       };
       resolvedConfig = await prettierInstance.resolveConfig(
@@ -419,6 +440,24 @@ export class ModuleResolver implements ModuleResolverInterface {
       return "error";
     }
 
+    // Log what configuration was resolved
+    if (resolvedConfig) {
+      this.loggingService.logInfo("Resolved config:", resolvedConfig);
+    }
+
+    // Determine config source for better user feedback
+    if (!configPath && resolvedConfig && vscodeConfig.useEditorConfig) {
+      // Config was resolved but no Prettier config file was found
+      // This means settings came from .editorconfig
+      this.loggingService.logInfo(
+        "No Prettier config file found, but settings were loaded from .editorconfig",
+      );
+    } else if (!configPath && !resolvedConfig) {
+      this.loggingService.logInfo(
+        "No local configuration (i.e. .prettierrc or .editorconfig) detected, will fall back to VS Code configuration",
+      );
+    }
+
     if (!vscodeConfig.requireConfig) {
       return resolvedConfig;
     }

src/PrettierCodeActionProvider.ts

@@ -0,0 +1,57 @@
+import {
+  CancellationToken,
+  CodeAction,
+  CodeActionContext,
+  CodeActionKind,
+  CodeActionProvider,
+  Range,
+  TextDocument,
+  TextEdit,
+  WorkspaceEdit,
+} from "vscode";
+import { ExtensionFormattingOptions } from "./types.js";
+
+/**
+ * Provides code actions for formatting with Prettier.
+ * This enables using Prettier with codeActionsOnSave.
+ */
+export class PrettierCodeActionProvider implements CodeActionProvider {
+  public static readonly providedCodeActionKinds = [
+    CodeActionKind.SourceFixAll.append("prettier"),
+  ];
+
+  constructor(
+    private provideEdits: (
+      document: TextDocument,
+      options: ExtensionFormattingOptions,
+    ) => Promise<TextEdit[]>,
+  ) {}
+
+  public async provideCodeActions(
+    document: TextDocument,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    range: Range,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    context: CodeActionContext,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    token: CancellationToken,
+  ): Promise<CodeAction[]> {
+    const edits = await this.provideEdits(document, {
+      force: false,
+    });
+
+    if (edits.length === 0) {
+      return [];
+    }
+
+    const action = new CodeAction(
+      "Format with Prettier",
+      CodeActionKind.SourceFixAll.append("prettier"),
+    );
+    const workspaceEdit = new WorkspaceEdit();
+    workspaceEdit.set(document.uri, edits);
+    action.edit = workspaceEdit;
+
+    return [action];
+  }
+}

src/PrettierEditService.ts

@@ -16,6 +16,7 @@ import { getParserFromLanguageId } from "./utils/get-parser-from-language.js";
 import { LoggingService } from "./LoggingService.js";
 import { RESTART_TO_ENABLE } from "./message.js";
 import { PrettierEditProvider } from "./PrettierEditProvider.js";
+import { PrettierCodeActionProvider } from "./PrettierCodeActionProvider.js";
 import { FormatterStatus, StatusBar } from "./StatusBar.js";
 import {
   ExtensionFormattingOptions,
@@ -132,6 +133,7 @@ const PRETTIER_CONFIG_FILES = [
 export default class PrettierEditService implements Disposable {
   private formatterHandler: undefined | Disposable;
   private rangeFormatterHandler: undefined | Disposable;
+  private codeActionHandler: undefined | Disposable;
   private registeredWorkspaces = new Set<string>();
 
   private allLanguages: string[] = [];
@@ -202,7 +204,14 @@ export default class PrettierEditService implements Disposable {
       );
 
       const edits = await this.provideEdits(editor.document, { force: true });
-      if (edits.length !== 1) {
+      if (edits.length === 0) {
+        this.loggingService.logInfo("Document is already formatted.");
+        return;
+      }
+      if (edits.length > 1) {
+        this.loggingService.logWarning(
+          `Unexpected multiple edits (${edits.length}), expected 0 or 1`,
+        );
         return;
       }
 
@@ -311,8 +320,10 @@ export default class PrettierEditService implements Disposable {
     this.moduleResolver.dispose();
     this.formatterHandler?.dispose();
     this.rangeFormatterHandler?.dispose();
+    this.codeActionHandler?.dispose();
     this.formatterHandler = undefined;
     this.rangeFormatterHandler = undefined;
+    this.codeActionHandler = undefined;
   };
 
   private registerDocumentFormatEditorProviders({
@@ -321,6 +332,9 @@ export default class PrettierEditService implements Disposable {
   }: ISelectors) {
     this.dispose();
     const editProvider = new PrettierEditProvider(this.provideEdits);
+    const codeActionProvider = new PrettierCodeActionProvider(
+      this.provideEdits,
+    );
     this.rangeFormatterHandler =
       languages.registerDocumentRangeFormattingEditProvider(
         rangeLanguageSelector,
@@ -330,6 +344,14 @@ export default class PrettierEditService implements Disposable {
       languageSelector,
       editProvider,
     );
+    this.codeActionHandler = languages.registerCodeActionsProvider(
+      languageSelector,
+      codeActionProvider,
+      {
+        providedCodeActionKinds:
+          PrettierCodeActionProvider.providedCodeActionKinds,
+      },
+    );
   }
 
   /**
@@ -446,11 +468,27 @@ export default class PrettierEditService implements Disposable {
     const duration = new Date().getTime() - startTime;
     this.loggingService.logInfo(`Formatting completed in ${duration}ms.`);
     const edit = this.minimalEdit(document, result);
+    if (!edit) {
+      // Document is already formatted, no changes needed
+      this.loggingService.logDebug(
+        "Document is already formatted, no changes needed.",
+      );
+      return [];
+    }
     return [edit];
   };
 
-  private minimalEdit(document: TextDocument, string1: string) {
+  private minimalEdit(
+    document: TextDocument,
+    string1: string,
+  ): TextEdit | null {
     const string0 = document.getText();
+
+    // Quick check: if strings are identical, no edit needed
+    if (string0 === string1) {
+      return null;
+    }
+
     // length of common prefix
     let i = 0;
     while (
@@ -661,8 +699,8 @@ export default class PrettierEditService implements Disposable {
 
     this.loggingService.logInfo(
       fallbackToVSCodeConfig
-        ? "No local configuration (i.e. .prettierrc or .editorconfig) detected, falling back to VS Code configuration"
-        : "Detected local configuration (i.e. .prettierrc or .editorconfig), VS Code configuration will not be used",
+        ? "Using VS Code configuration"
+        : "Using local configuration (VS Code configuration will not be used)",
     );
 
     let rangeFormattingOptions: RangeFormattingOptions | undefined;

src/test/suite/codeAction.test.ts

@@ -0,0 +1,82 @@
+import * as assert from "assert";
+import * as vscode from "vscode";
+import { ensureExtensionActivated } from "./testUtils.js";
+
+describe("Test Prettier Code Actions", () => {
+  const unformattedCode = `const  x   =  {  a: 1, b: 2  }`;
+
+  before(async () => {
+    await ensureExtensionActivated();
+  });
+
+  it("provides source.fixAll.prettier code action", async () => {
+    const doc = await vscode.workspace.openTextDocument({
+      content: unformattedCode,
+      language: "javascript",
+    });
+    await vscode.window.showTextDocument(doc);
+
+    // Get code actions for the document
+    const codeActions = await vscode.commands.executeCommand<
+      vscode.CodeAction[]
+    >(
+      "vscode.executeCodeActionProvider",
+      doc.uri,
+      new vscode.Range(0, 0, doc.lineCount, 0),
+    );
+
+    // Find the Prettier code action
+    const prettierAction = codeActions?.find(
+      (action) => action.kind?.value === "source.fixAll.prettier",
+    );
+
+    assert.ok(prettierAction, "Prettier code action should be available");
+    assert.equal(
+      prettierAction?.title,
+      "Format with Prettier",
+      "Code action should have correct title",
+    );
+  });
+
+  it("formats document using code action", async () => {
+    const doc = await vscode.workspace.openTextDocument({
+      content: unformattedCode,
+      language: "javascript",
+    });
+    await vscode.window.showTextDocument(doc);
+
+    // Get code actions for the document
+    const codeActions = await vscode.commands.executeCommand<
+      vscode.CodeAction[]
+    >(
+      "vscode.executeCodeActionProvider",
+      doc.uri,
+      new vscode.Range(0, 0, doc.lineCount, 0),
+    );
+
+    // Find and apply the Prettier code action
+    const prettierAction = codeActions?.find(
+      (action) => action.kind?.value === "source.fixAll.prettier",
+    );
+
+    assert.ok(prettierAction, "Prettier code action should be available");
+
+    // Apply the code action
+    if (prettierAction?.edit) {
+      await vscode.workspace.applyEdit(prettierAction.edit);
+    }
+
+    const formattedText = doc.getText();
+
+    // Verify the document was formatted correctly
+    // Normalize line endings for cross-platform compatibility
+    const normalizedFormatted = formattedText.replace(/\r\n/g, "\n");
+    const expectedNormalized = `const x = { a: 1, b: 2 };\n`;
+
+    assert.equal(
+      normalizedFormatted,
+      expectedNormalized,
+      "Document should be formatted correctly after applying code action",
+    );
+  });
+});