Feature Request: Safe Delete

[dubspeed]

Safe Delete

Description

I would like to suggest the addition of a "Safe Delete" feature to the VSHaxe. The feature is often found in IntelliJ based IDEs. Here is what it does:

Proposed Functionality

The "Safe Delete" feature should:

• Analyze the selected Haxe element (class, method, field, or variable) before deletion.
• Identify all usages of the element throughout the project.
• Provide a preview of all locations where the element is used.
• Allow the user to review and confirm the deletion.
• Safely remove the element and all its usages across the project.

Examples

Example 1: Deleting a class

When attempting to delete a class, the feature should:

• Identify all imports of the class
• Locate all instances where the class is used (instantiation, type annotations, etc.)
• Remove the class file
• Remove all related imports and usages

// Class to be deleted
class OldFeature {
    public function doSomething() {
        // ...
    }
}

// In another file
import OldFeature;

class Main {
    public function new() {
        var feature = new OldFeature(); // This should be identified and removed
        feature.doSomething(); // This should also be removed
    }
}

Example 2: Deleting a method

When deleting a method, the feature should:

• Find all method calls across the project
• Offer to remove the method and all its invocations

class MyClass {
    public function deprecatedMethod() { // Method to be deleted
        // ...
    }

    public function anotherMethod() {
        deprecatedMethod(); // This call should be identified and removed
    }
}

// In another file
class AnotherClass {
    public function someFunction(instance:MyClass) {
        instance.deprecatedMethod(); // This should also be identified and removed
    }
}

Example 3: Deleting a field

When deleting a field, the feature should:

• Locate all references to the field
• Offer to remove the field and update all references

class MyClass {
    public var oldField:String; // Field to be deleted

    public function doSomething() {
        trace(oldField); // This should be identified and removed
    }
}

// In another file
class AnotherClass {
    public function process(instance:MyClass) {
        var value = instance.oldField; // This should be identified and removed
    }
}

Benefits

• Saves time by automatically identifying and removing all usages
• Helps developers keeping mental sanity when working on larger and older codebases
• Reduces the risk of introducing errors when removing unused code
• Helps to eliminate unused and dead code
• Trumps any "Search and Replace" operation, especially when generic terms (like "add", "remove" etc.) are used in multiple places and concepts.

Implementation Considerations

• The feature should integrate with the existing Haxe language server to accurately analyze code and identify usages.
• It should respect Haxe's conditional compilation flags and only remove code that is actually compiled.
• The preview functionality should clearly show the context of each usage to help developers make informed decisions.

We believe this feature would improve the development experience in Haxe and VSCode, and we would love to see it - or parts of it - being implemented. Thank you for considering this request!

[kLabz]

That sounds incredibly unsafe for something that has "safe" in its name :fearful:

[dubspeed]

Good point, allow me to highlight the "safety" aspect a bit better.

Imagine one wants to remove a function called add from FlxPoint in Flixel Library. The function might be called dozens of times, however, using a simple search in codebase for add gives hundreds of results, so no easy task.

So, using the "Safe Delete" would use the information gathered during compilation to only target all usages of add towards the FlxPoint, making the operation "safe" in the sense that the result will compile.

Deleting code in a larger codebase can be hard work when concepts (like add/remove, subscribe/unsubscribe) with namings that are typically used overlap in multiple instances. The tool would make the job much, much easier, and the user can be safe to be left with a compiling codebase.