Rename the "Renumber variables" refactoring to "Increment numbered variables" and add a corresponding "Decrement numbered variables" refactoring

Author: pmoura

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## [0.76.0]
 
+* Rename the "Renumber variables" refactoring to "Increment numbered variables" and add a corresponding "Decrement numbered variables" refactoring
 * Update the "Wrap file contents as an object" refactoring to insert the object opening directive after any comments at the beginning of the file
 * Update the "Open parent file" command to show a message if no parent file is found
 
@@ -10,7 +11,8 @@
 * Add support for renaming variables within the scope of a predicate clause, grammar rule, or directive
 * Add support for renaming parameter variables within the scope of an entity
 * Add "Extract predicate/non-terminal" refactoring support for selected code in predicate clauses and grammar rules
-* Add "Renumber variables" refactoring support for variables ending with numbers within the scope of a predicate clause or grammar rule
+* Add "Increment numbered variables" refactoring support for variables ending with numbers within the scope of a predicate clause or grammar rule
+* Add "Decrement numbered variables" refactoring support for variables ending with numbers within the scope of a predicate clause or grammar rule
 * Add "Unify with new variable" refactoring support for selected terms in predicate rules and grammar rules
 * Add "Inline variable" refactoring support for replacing variable unification goals in predicate rules and grammar rules
 * Add "Wrap file contents as an object" refactoring support for converting plain Prolog files to Logtalk objects

README.md

@@ -329,18 +329,18 @@ Several refactoring operations are supported. Users should commit their work bef
 
 When a refactoring results in changes to multiple files, use the "Save All" command to save all modified files so that a single "Make - Reload" command can be used to reload the modified code. Note that this command can be called automatically when saving files using the `logtalk.make.onSave` setting.
 
-#### Renumber variables
+#### Increment and decrement numbered variables
 
-A "Renumber variables" refactoring operation is available when the user right-clicks on a variable ending with a number in a predicate rule or in a grammar rule and uses the "Refactor" context menu item or the "Refactor" command palette item. The refactoring renumbers all variables with the same prefix and a number equal or greater than the selected variable number in the rule to consecutive numbers. The selected variable can be anywhere in the rule (e.g., in the head, in the body, or in a comment).
+The "Increment numbered variables" and "Decrement numbered variables" refactoring operations are available when the user right-clicks on a variable ending with a number in a predicate rule or in a grammar rule and uses the "Refactor" context menu items or the "Refactor" command palette items. These refactorings increment or decrement all variables with the same prefix and a number equal or greater than the selected variable number in the rule. The selected variable can be anywhere in the rule (e.g., in the head, in the body, or in a comment).
 
-#### Variable inlining
+#### Variable inlining and variable introduction
 
 An "Inline variable" refactoring operation is available when the user selects a unification goal in a rule body and uses the "Refactor" context menu item or the "Refactor" command palette item. The refactoring replaces all occurrences of the variable in the rule with its unified term. The unification goal should be the only goal in the line.
 
-#### Code extraction
-
 A "Unify with new variable" refactoring operation is available when the user selects a complete term in a predicate rule or in a grammar rule (e.g., a head argument) and uses the "Refactor" context menu item or the "Refactor" command palette item. The refactoring asks the user for the name of the new variable, replaces the selected term with the new variable, and adds a unification goal to the rule body (after the rule head when the term is a head argument, before the line of the selected term otherwise).
 
+#### Code extraction
+
 A "Replace magic number with predicate call" refactoring operation is available when the user selects a number in a rule body and uses the "Refactor" context menu item or the "Refactor" command palette item. The user is asked to enter the name of the predicate to be created and its scope. The predicate is created with the number as its single argument and added to the entity. The selected number is replaced with a variable derived from the predicate name and the rule body is updated with a call to the new predicate inserted after the clause head (note that when compiling the code in optimal mode, the call to the new predicate is inlined).
 
 An "Extract predicate/non-terminal" refactoring operation is available when the user selects one ot more lines of code with complete goals in a predicate rule or in a grammar rule and uses the "Refactor" context menu item or the "Refactor" command palette item. The refactoring asks the user for the name of the new predicate (or non-terminal) and adds it after all clauses of the current predicate (or non-terminal). The selected code is replaced with a call to the new predicate (or non-terminal).
@@ -352,12 +352,13 @@ Four other code extraction refactoring operations are supported when the user se
 - "Extract to Logtalk entity" (the user is asked to select the target entity)
 - "Extract to new Logtalk entity" (the user is asked to select the entity type, entity name, file name, and file location)
 - "Extract to new Logtalk file" (the user is asked to select the file name and file location)
-- "Replace with include/1 directive" (the user is asked to select the file name and file location)
 
-#### Resolve include/1 directive
+#### Resolving and introducing include/1 directives
 
 When the user selects a region of code that contains an `include/1` directive, the "Refactor" context menu item or the "Refactor" command palette item provides a "Replace include/1 directive with file contents" action. The included file is resolved if it's a relative or absolute path, with or without a common Logtalk or Prolog extension. The included file contents are indented to match the indentation of the `include/1` directive.
 
+The "Replace with include/1 directive" refactoring operation is available when the user selects a region of code and uses the "Refactor" context menu item or the "Refactor" command palette item. The user is asked to select the new file name and file location. The selected code is extracted to the new file and the selection is replaced with an `include/1` directive.
+
 #### Symbol renaming
 
 Entity, predicate, non-terminal, and variable rename support is available:

src/extension.ts

@@ -584,9 +584,17 @@ export async function activate(context: ExtensionContext) {
   );
 
   context.subscriptions.push(
-    commands.registerCommand('logtalk.refactor.renumberVariables', async (document, selection) => {
+    commands.registerCommand('logtalk.refactor.incrementNumberedVariables', async (document, selection) => {
       if (refactorProvider) {
-        await refactorProvider.renumberVariables(document, selection);
+        await refactorProvider.incrementNumberedVariables(document, selection);
+      }
+    })
+  );
+
+  context.subscriptions.push(
+    commands.registerCommand('logtalk.refactor.decrementNumberedVariables', async (document, selection) => {
+      if (refactorProvider) {
+        await refactorProvider.decrementNumberedVariables(document, selection);
       }
     })
   );

src/features/refactorProvider.ts

@@ -505,19 +505,30 @@ export class LogtalkRefactorProvider implements CodeActionProvider {
       }
     }
 
-    // Renumber variables - works with cursor position (empty or non-empty selection)
+    // Increment/Decrement numbered variables - works with cursor position (empty or non-empty selection)
     const variableAtCursor = this.getNumberedVariableAtPosition(document, selection.active);
     if (variableAtCursor && !this.isSelectionInDirective(document, selection)) {
-      const renumberVariablesAction = new CodeAction(
-        "Renumber variables",
+      const incrementVariablesAction = new CodeAction(
+        "Increment numbered variables",
         CodeActionKind.RefactorRewrite
       );
-      renumberVariablesAction.command = {
-        command: "logtalk.refactor.renumberVariables",
-        title: "Renumber variables",
+      incrementVariablesAction.command = {
+        command: "logtalk.refactor.incrementNumberedVariables",
+        title: "Increment numbered variables",
         arguments: [document, selection]
       };
-      actions.push(renumberVariablesAction);
+      actions.push(incrementVariablesAction);
+
+      const decrementVariablesAction = new CodeAction(
+        "Decrement numbered variables",
+        CodeActionKind.RefactorRewrite
+      );
+      decrementVariablesAction.command = {
+        command: "logtalk.refactor.decrementNumberedVariables",
+        title: "Decrement numbered variables",
+        arguments: [document, selection]
+      };
+      actions.push(decrementVariablesAction);
     }
 
     // Sort files by dependencies - for logtalk_load/1-2 predicates with list of atoms
@@ -2984,10 +2995,10 @@ export class LogtalkRefactorProvider implements CodeActionProvider {
   }
 
   /**
-   * Renumber variables in a rule
-   * Finds all variables with the same prefix ending with numbers and renumbers them
+   * Increment numbered variables in a rule
+   * Finds all variables with the same prefix ending with numbers and increments them
    */
-  public async renumberVariables(document: TextDocument, selection: Selection): Promise<void> {
+  public async incrementNumberedVariables(document: TextDocument, selection: Selection): Promise<void> {
     try {
       // Try to get variable at cursor position first
       let variableInfo = this.getNumberedVariableAtPosition(document, selection.active);
@@ -3042,7 +3053,7 @@ export class LogtalkRefactorProvider implements CodeActionProvider {
       // Sort numbers in descending order to avoid conflicts when renaming
       const sortedNumbers = Array.from(numberedVariables.keys()).sort((a, b) => b - a);
 
-      // Renumber variables starting from the selected one
+      // Increment variables starting from the selected one
       for (const num of sortedNumbers) {
         if (num >= selectedNumber) {
           const oldVarName = numberedVariables.get(num)!;
@@ -3070,13 +3081,117 @@ export class LogtalkRefactorProvider implements CodeActionProvider {
       const success = await workspace.applyEdit(edit);
       if (success) {
         const count = sortedNumbers.filter(n => n >= selectedNumber).length;
-        window.showInformationMessage(`Renumbered ${count} variable${count !== 1 ? 's' : ''}.`);
+        window.showInformationMessage(`Incremented ${count} variable${count !== 1 ? 's' : ''}.`);
+      } else {
+        window.showErrorMessage("Failed to increment variables.");
+      }
+    } catch (error) {
+      this.logger.error(`Error in incrementNumberedVariables: ${error}`);
+      window.showErrorMessage(`Error incrementing variables: ${error.message}`);
+    }
+  }
+
+  /**
+   * Decrement numbered variables in a rule
+   * Finds all variables with the same prefix ending with numbers and decrements them
+   */
+  public async decrementNumberedVariables(document: TextDocument, selection: Selection): Promise<void> {
+    try {
+      // Try to get variable at cursor position first
+      let variableInfo = this.getNumberedVariableAtPosition(document, selection.active);
+
+      // If no variable at cursor, try parsing the selection
+      if (!variableInfo && !selection.isEmpty) {
+        const selectedText = document.getText(selection).trim();
+        const parsed = this.parseNumberedVariable(selectedText);
+        if (parsed) {
+          variableInfo = {
+            ...parsed,
+            range: selection
+          };
+        }
+      }
+
+      if (!variableInfo) {
+        window.showErrorMessage("Cursor is not on a variable ending with a number.");
+        return;
+      }
+
+      const { prefix, number: selectedNumber } = variableInfo;
+
+      // Find the complete rule range
+      const ruleRange = this.findCompleteRuleRange(document, selection.start.line);
+      if (!ruleRange) {
+        window.showErrorMessage("Could not find the complete rule.");
+        return;
+      }
+
+      // Get the rule text
+      const ruleText = document.getText(ruleRange);
+
+      // Find all variables with the same prefix ending with numbers
+      const variableRegex = new RegExp(`\\b${prefix}(\\d+)\\b`, 'g');
+
+      // Collect all unique numbered variables with this prefix
+      const numberedVariables = new Map<number, string>(); // number -> variable name
+      let match: RegExpExecArray | null;
+      while ((match = variableRegex.exec(ruleText)) !== null) {
+        const num = parseInt(match[1], 10);
+        const varName = `${prefix}${num}`;
+        numberedVariables.set(num, varName);
+      }
+
+      // Check if decrementing would result in a number less than 0
+      const minNumber = Math.min(...Array.from(numberedVariables.keys()).filter(n => n >= selectedNumber));
+      if (minNumber - 1 < 0) {
+        window.showErrorMessage("Cannot decrement: would result in negative variable number.");
+        return;
+      }
+
+      // Calculate the decrement amount (how much to subtract from each number)
+      const decrement = 1;
+
+      // Create workspace edit
+      const edit = new WorkspaceEdit();
+
+      // Sort numbers in ascending order to avoid conflicts when renaming
+      const sortedNumbers = Array.from(numberedVariables.keys()).sort((a, b) => a - b);
+
+      // Decrement variables starting from the selected one
+      for (const num of sortedNumbers) {
+        if (num >= selectedNumber) {
+          const oldVarName = numberedVariables.get(num)!;
+          const newNum = num - decrement;
+          const newVarName = `${prefix}${newNum}`;
+
+          // Find and replace all occurrences of this variable in the rule
+          for (let lineNum = ruleRange.start.line; lineNum <= ruleRange.end.line; lineNum++) {
+            const lineText = document.lineAt(lineNum).text;
+            const lineMatches = [...lineText.matchAll(new RegExp(`\\b${oldVarName}\\b`, 'g'))];
+
+            for (const lineMatch of lineMatches) {
+              const startChar = lineMatch.index!;
+              const endChar = startChar + oldVarName.length;
+              const replaceRange = new Range(
+                new Position(lineNum, startChar),
+                new Position(lineNum, endChar)
+              );
+              edit.replace(document.uri, replaceRange, newVarName);
+            }
+          }
+        }
+      }
+
+      const success = await workspace.applyEdit(edit);
+      if (success) {
+        const count = sortedNumbers.filter(n => n >= selectedNumber).length;
+        window.showInformationMessage(`Decremented ${count} variable${count !== 1 ? 's' : ''}.`);
       } else {
-        window.showErrorMessage("Failed to renumber variables.");
+        window.showErrorMessage("Failed to decrement variables.");
       }
     } catch (error) {
-      this.logger.error(`Error in renumberVariables: ${error}`);
-      window.showErrorMessage(`Error renumbering variables: ${error.message}`);
+      this.logger.error(`Error in decrementNumberedVariables: ${error}`);
+      window.showErrorMessage(`Error decrementing variables: ${error.message}`);
     }
   }
 

tests/test_renumber_variables.lgt …crement_decrement_numbered_variables.lgttests/test_renumber_variables.lgt renamed to tests/test_increment_decrement_numbered_variables.lgt tests/test_renumber_variables.lgt renamed to tests/test_increment_decrement_numbered_variables.lgt

@@ -1,10 +1,10 @@
-:- object(test_renumber_variables).
+:- object(test_increment_decrement_numbered_variables).
 
   :- info([
     version is 1:0:0,
     author is 'Paulo Moura',
     date is 2025-11-15,
-    comment is 'Test cases for the "Renumber variables" refactoring.'
+    comment is 'Test cases for the "Increment numbered variables" and "Decrement numbered variables" refactorings.'
   ]).
 
   :- public(example1/2).