Better support for interfaces (issue #67)

[konard]

Summary

This PR implements the four key improvements requested in issue #67:

✅ #pragma once support: #pragma once directives are now preserved while other pragma directives (like #pragma warning disable) are removed

✅ struct instead of class with public: support: Interfaces are now converted to structs instead of classes, providing better C++ semantics

✅ Virtual destructors: Virtual destructors with = default are automatically added to interface-derived structs to ensure proper cleanup

✅ Better template type arguments placement: Template declarations and class/struct definitions are now placed on separate lines for better readability (addresses issue #68)

Technical Implementation

1. #pragma once Support

• Modified the pragma removal regex to use negative lookahead: #pragma(?! once)
• This preserves #pragma once while removing other pragma directives

2. Interface to Struct Conversion

• Updated both simple and templated interface handling rules
• Simple interfaces: interface ITest → struct ITest
• Templated interfaces: interface ITest<T> → template <typename T>\nstruct ITest<T>

3. Virtual Destructors

• Added selective virtual destructor insertion for interface-derived structs
• Only applies to structs containing virtual methods (originally interfaces)
• Uses two-stage rule processing to ensure proper = default instead of = 0

4. Template Type Arguments Placement

• Separated template declarations from class/struct definitions
• template <typename T> class Foo → template <typename T>\nclass Foo

Test Coverage

Added comprehensive test cases covering:

• #pragma once preservation vs #pragma warning removal
• Simple interface to struct conversion with virtual destructors
• Templated interface to struct conversion with proper template placement
• Regular struct handling (no unwanted virtual destructors)
• Templated class and struct separation

All existing tests continue to pass, ensuring backward compatibility.

Example Transformations

Before:

#pragma once
interface ITest<T>
{
    void Method(T value);
}

After:

#pragma once
template <typename ...> struct ITest;
template <typename T>
struct ITest<T>
{
    public:
    virtual void Method(T value) = 0;
    virtual ~ITest() = default;
};

🤖 Generated with Claude Code

---

Resolves #67