🏛️ DevLog: Full Class Support - Object-Oriented Pascal to Modern C++23

[jarroddavis68]

Version: JetPascal 0.3.0+

🎉 What's New

JetPascal now supports complete Object Pascal class syntax with full inheritance chains, virtual methods, constructors, destructors, and the Self keyword - all transpiled to clean, modern C++23.

Write Pascal classes. Get native C++ performance.

💡 What This Means

You can now:

✅ Define classes with fields and methods
✅ Use single inheritance with unlimited depth
✅ Declare virtual and override methods
✅ Write constructors with inherited calls
✅ Implement destructors with automatic chaining
✅ Use Self keyword for explicit instance access
✅ Create objects with TClass.Create() syntax
✅ Free objects with .Free method

All transpiled to efficient C++23 with zero runtime overhead.

📝 What Class Support Looks Like

Here's a complete inheritance hierarchy:

unit UnitAdvancedClasses;

interface

type
  { TAnimal - Base class }
  TAnimal = class
  private
    FName: String;
    FAge: Integer;
  public
    constructor Create(const AName: String; const AAge: Integer);
    destructor Destroy; override;
    function GetName: String;
    procedure Speak; virtual;
    function Describe: String; virtual;
  end;

  { TDog - First level inheritance }
  TDog = class(TAnimal)
  private
    FBreed: String;
  public
    constructor Create(const AName: String; const AAge: Integer; const ABreed: String);
    destructor Destroy; override;
    procedure Speak; override;
    function Describe: String; override;
    procedure Fetch;
  end;

  { TServiceDog - Multi-level inheritance (grandchild) }
  TServiceDog = class(TDog)
  private
    FTask: String;
    FHoursWorked: Integer;
  public
    constructor Create(const AName: String; const AAge: Integer; 
                       const ABreed: String; const ATask: String);
    destructor Destroy; override;
    procedure Speak; override;
    function Describe: String; override;
    procedure PerformTask;
  end;

implementation

{ TAnimal }

constructor TAnimal.Create(const AName: String; const AAge: Integer);
begin
  FName := AName;
  FAge := AAge;
  WriteLn('[TAnimal.Create] Created animal: {}', FName);
end;

destructor TAnimal.Destroy;
begin
  WriteLn('[TAnimal.Destroy] Destroying animal: {}', FName);
  inherited;
end;

procedure TAnimal.Speak;
begin
  WriteLn('{} makes a generic animal sound.', FName);
end;

function TAnimal.Describe: String;
begin
  Result := 'Animal named ' + FName;
end;

{ TDog }

constructor TDog.Create(const AName: String; const AAge: Integer; const ABreed: String);
begin
  inherited Create(AName, AAge);
  FBreed := ABreed;
  WriteLn('[TDog.Create] Dog breed set to: {}', FBreed);
end;

destructor TDog.Destroy;
begin
  WriteLn('[TDog.Destroy] Destroying dog: {} the {}', Self.GetName, FBreed);
  inherited;
end;

procedure TDog.Speak;
begin
  WriteLn('{} the {} says: Woof! Woof!', Self.GetName, FBreed);
end;

function TDog.Describe: String;
begin
  Result := Self.GetName + ' is a ' + FBreed + ' dog';
end;

{ TServiceDog }

constructor TServiceDog.Create(const AName: String; const AAge: Integer; 
                                const ABreed: String; const ATask: String);
begin
  inherited Create(AName, AAge, ABreed);
  FTask := ATask;
  FHoursWorked := 0;
  WriteLn('[TServiceDog.Create] Service task: {}', FTask);
end;

destructor TServiceDog.Destroy;
begin
  WriteLn('[TServiceDog.Destroy] Service dog {} retiring after {} hours', 
          Self.GetName, FHoursWorked);
  inherited;
end;

procedure TServiceDog.Speak;
begin
  WriteLn('{} the service dog alerts: *Focused bark*', Self.GetName);
end;

function TServiceDog.Describe: String;
begin
  Result := Self.GetName + ' is a ' + Self.GetBreed + ' service dog trained for ' + FTask;
end;

end.

And here's what gets generated:

// Generated C++23 - Clean, efficient, idiomatic

class TAnimal : public jp::class_base {
private:
  jp::String FName;
  jp::Integer FAge;

public:
  TAnimal(const jp::String &AName, const jp::Integer &AAge);
  virtual ~TAnimal();
  jp::String GetName();
  virtual void Speak();
  virtual jp::String Describe();
};

class TDog : public TAnimal {
private:
  jp::String FBreed;

public:
  TDog(const jp::String &AName, const jp::Integer &AAge, const jp::String &ABreed);
  virtual ~TDog();
  void Speak() override;
  jp::String Describe() override;
  void Fetch();
};

class TServiceDog : public TDog {
private:
  jp::String FTask;
  jp::Integer FHoursWorked;

public:
  TServiceDog(const jp::String &AName, const jp::Integer &AAge,
              const jp::String &ABreed, const jp::String &ATask);
  virtual ~TServiceDog();
  void Speak() override;
  jp::String Describe() override;
  void PerformTask();
};

// Constructor with inherited call → C++ initializer list
TServiceDog::TServiceDog(const jp::String &AName, const jp::Integer &AAge,
                         const jp::String &ABreed, const jp::String &ATask)
    : TDog(AName, AAge, ABreed) {
  FTask = ATask;
  FHoursWorked = 0;
  jp::WriteLn("[TServiceDog.Create] Service task: {}", FTask);
}

// Self → this
jp::String TServiceDog::Describe() {
  jp::String Result{};
  Result = this->GetName() + " is a " + this->GetBreed() + 
           " service dog trained for " + FTask;
  return Result;
}

Notice:

• ✅ Clean inheritance: class TDog : public TAnimal
• ✅ Correct virtual/override ordering
• ✅ inherited Create() → C++ initializer list : TDog(...)
• ✅ Self.GetName → this->GetName()
• ✅ Virtual destructors for proper cleanup
• ✅ #line directives for source-level debugging

🔬 Real Features We've Implemented

1. Multi-Level Inheritance

The Magic: Unlimited inheritance depth with proper constructor chaining.

TAnimal           // Base class
  └── TDog        // First level
       └── TServiceDog  // Second level (grandchild)

Generated Output:

[TAnimal.Create] Created animal: Max
[TDog.Create] Dog breed set to: German Shepherd  
[TServiceDog.Create] Service task: Guide Dog

Each constructor in the chain runs in order. Parent first, then child.

Why It Matters: Build complex class hierarchies naturally. The transpiler handles all the C++ plumbing.

2. Virtual Methods & Polymorphism

Dynamic Dispatch: Override behavior in child classes.

// Base class
procedure TAnimal.Speak;
begin
  WriteLn('{} makes a generic animal sound.', FName);
end;

// Override in child
procedure TDog.Speak;
begin
  WriteLn('{} says: Woof! Woof!', Self.GetName);
end;

// Override in grandchild
procedure TServiceDog.Speak;
begin
  WriteLn('{} the service dog alerts: *Focused bark*', Self.GetName);
end;

Runtime Output:

Creating different animals and calling Speak():
Unknown makes a generic animal sound.
Rex the Labrador says: Woof! Woof!
Luna the service dog alerts: *Focused bark*
Mittens says: Meow!

Same method name, different behavior based on actual object type.

Why It Matters: True OOP polymorphism. Write generic code that works with any subclass.

3. The Self Keyword

Explicit Instance Access: Reference the current object.

function TDog.Describe: String;
begin
  Result := Self.GetName + ' is a ' + FBreed + ' dog';
end;

destructor TDog.Destroy;
begin
  WriteLn('[TDog.Destroy] Destroying dog: {} the {}', Self.GetName, FBreed);
  inherited;
end;

Generated C++:

jp::String TDog::Describe() {
  jp::String Result{};
  Result = this->GetName() + " is a " + FBreed + " dog";
  return Result;
}

TDog::~TDog() {
  jp::WriteLn("[TDog.Destroy] Destroying dog: {} the {}", this->GetName(), FBreed);
  // inherited
}

Self → this - Clean, idiomatic C++.

Why It Matters: Access methods from parent classes. Make intent explicit. Standard Pascal OOP.

4. Constructor Inheritance

The Magic: inherited Create() becomes C++ initializer lists.

constructor TServiceDog.Create(const AName: String; const AAge: Integer; 
                               const ABreed: String; const ATask: String);
begin
  inherited Create(AName, AAge, ABreed);  // Call parent constructor
  FTask := ATask;
  FHoursWorked := 0;
end;

Generated C++:

TServiceDog::TServiceDog(const jp::String &AName, const jp::Integer &AAge,
                         const jp::String &ABreed, const jp::String &ATask)
    : TDog(AName, AAge, ABreed) {  // Initializer list!
  FTask = ATask;
  FHoursWorked = 0;
}

The transpiler:

1. Detects inherited Create(args) as the first statement
2. Extracts the parent class name from the class definition
3. Generates proper C++ initializer list syntax
4. Removes the inherited call from the body

Why It Matters: Correct C++ initialization order. Parent constructed before child fields accessed. Efficient code generation.

5. Destructor Chaining

Automatic Cleanup: Destructors run in reverse order.

destructor TServiceDog.Destroy;
begin
  WriteLn('[TServiceDog.Destroy] Service dog retiring...');
  inherited;  // Call parent destructor
end;

Runtime Output:

[TServiceDog.Destroy] Service dog Charlie retiring after 100 hours of service
[TDog.Destroy] Destroying dog: Charlie the Beagle
[TAnimal.Destroy] Destroying animal: Charlie

Child destructor runs first, then parent, then grandparent.

Why It Matters: Resources freed in correct order. No leaks. Proper cleanup semantics.

6. Object Creation & Destruction

Pascal Syntax, C++ Smart Pointers:

var
  GDog: TDog;
begin
  GDog := TDog.Create('Buddy', 3, 'Golden Retriever');
  GDog.Speak;
  GDog.Fetch;
  GDog.Free;
end.

Generated C++:

jp::Ref<TDog> GDog;

int main() {
  GDog = jp::create<TDog>("Buddy", 3, "Golden Retriever");
  GDog->Speak();
  GDog->Fetch();
  GDog.reset();
  return 0;
}

Mapping:

• TClass.Create(args) → jp::create<TClass>(args)
• obj.Method() → obj->Method()
• obj.Free → obj.reset()

Why It Matters: Automatic memory management via smart pointers. No manual delete. No leaks.

7. If-Then-Else Without Begin-End

Natural Pascal Syntax:

if FIndoor then
  WriteLn('{} is an indoor cat', AName)
else
  WriteLn('{} is an outdoor cat', AName);

Generated C++:

jp::if_stmt(FIndoor)
    .then([&] {
      jp::WriteLn("{} is an indoor cat", AName);
    })
    .else_([&] {
      jp::WriteLn("{} is an outdoor cat", AName);
    });

Single statements without begin-end work perfectly.

Why It Matters: Write natural Pascal. No forced verbosity. Clean transpilation.

8. String Escaping

Embedded Quotes Handled:

WriteLn('Counter "{}" initialized to {} with step {}', FName, FValue, FStep);

Generated C++:

jp::WriteLn("Counter \"{}\" initialized to {} with step {}", FName, FValue, FStep);

Pascal single-quoted strings with embedded " → properly escaped C++ strings.

Why It Matters: Format strings work. No manual escaping. Just write Pascal.

💻 Complete Test Output

Here's the full test suite output proving everything works:

===============================================================================
JetPascal Class Support - Comprehensive Test Suite
===============================================================================

=== TEST 1: Basic Classes (UnitClasses) ===

--- TPoint ---
Point at (3, 4)
Distance from origin: 5.00
Moved to (6, 8), Distance: 10.00

--- TPerson ---
Hello, my name is Alice and I am 25 years old.
Happy birthday Alice! You are now 26.

--- TEmployee (inherits TPerson) ---
Hello, my name is Bob and I work as a Engineer.
Job: Engineer, Salary: $85000.00
Bob received a 15% raise. New salary: $97750.00

=== TEST 2: Inheritance Chain - TAnimal (Base) ===

[TAnimal.Create] Created animal: Generic
Name: Generic, Age: 5
Description: Animal named Generic
Generic makes a generic animal sound.
Generic is sleeping... Zzz...
[TAnimal.Destroy] Destroying animal: Generic

=== TEST 3: First Level Inheritance - TDog ===

[TAnimal.Create] Created animal: Buddy
[TDog.Create] Dog breed set to: Golden Retriever
Name: Buddy, Age: 3, Breed: Golden Retriever
Description: Buddy is a Golden Retriever dog
Buddy the Golden Retriever says: Woof! Woof!
Buddy is sleeping... Zzz...
Buddy fetches the ball!
[TDog.Destroy] Destroying dog: Buddy the Golden Retriever
[TAnimal.Destroy] Destroying animal: Buddy

=== TEST 4: Multi-Level Inheritance - TServiceDog ===

[TAnimal.Create] Created animal: Max
[TDog.Create] Dog breed set to: German Shepherd
[TServiceDog.Create] Service task: Guide Dog
Name: Max, Age: 4, Breed: German Shepherd
Task: Guide Dog
Description: Max is a German Shepherd service dog trained for Guide Dog
Max the service dog alerts: *Focused bark*
Max is performing task: Guide Dog
Max logged 5 hours. Total: 7 hours
Total hours worked: 7
Max fetches the ball!
Max is sleeping... Zzz...
[TServiceDog.Destroy] Service dog Max retiring after 7 hours of service
[TDog.Destroy] Destroying dog: Max the German Shepherd
[TAnimal.Destroy] Destroying animal: Max

=== TEST 5: Sibling Class - TCat ===

[TAnimal.Create] Created animal: Whiskers
[TCat.Create] Whiskers is an indoor cat
Name: Whiskers, Age: 2, Indoor: true
Description: Whiskers is an indoor cat
Whiskers says: Meow!
Whiskers scratches the furniture!
Whiskers is sleeping... Zzz...
[TCat.Destroy] Destroying cat: Whiskers
[TAnimal.Destroy] Destroying animal: Whiskers

=== TEST 6: Polymorphism Test ===

Creating different animals and calling Speak():
[TAnimal.Create] Created animal: Unknown
Unknown makes a generic animal sound.
[TAnimal.Destroy] Destroying animal: Unknown
[TAnimal.Create] Created animal: Rex
[TDog.Create] Dog breed set to: Labrador
Rex the Labrador says: Woof! Woof!
[TDog.Destroy] Destroying dog: Rex the Labrador
[TAnimal.Destroy] Destroying animal: Rex
[TAnimal.Create] Created animal: Luna
[TDog.Create] Dog breed set to: Border Collie
[TServiceDog.Create] Service task: Search and Rescue
Luna the service dog alerts: *Focused bark*
[TServiceDog.Destroy] Service dog Luna retiring after 0 hours of service
[TDog.Destroy] Destroying dog: Luna the Border Collie
[TAnimal.Destroy] Destroying animal: Luna
[TAnimal.Create] Created animal: Mittens
[TCat.Create] Mittens is an outdoor cat
Mittens says: Meow!
[TCat.Destroy] Destroying cat: Mittens
[TAnimal.Destroy] Destroying animal: Mittens

=== TEST 7: Self Keyword - TCounter ===

[TCounter.Create] Counter "MyCounter" initialized to 10 with step 5
Counter "MyCounter": Value=10, Step=5
Incrementing 3 times...
Counter "MyCounter": Value=25, Step=5
Decrementing once...
Counter "MyCounter": Value=20, Step=5
IncrementBy(100)...
Counter "MyCounter": Value=120, Step=5
AddAndReturn(50) = 170
Counter "MyCounter": Value=170, Step=5
Counter "MyCounter" reset to 0
Counter "MyCounter": Value=0, Step=5
[TCounter.Destroy] Counter "MyCounter" final value: 0

=== TEST 8: Complex Operations - TCalculator ===

[TCalculator.Create] Calculator ready
Calculating: ((10 + 5) * 3 - 15) / 2
Result: 10.0000
Result: 15.0000
Result: 45.0000
Result: 30.0000
Result: 15.0000

Testing memory...
Stored 15.0000 in memory
Calculator cleared
Result: 0.0000
Recalled 15.0000 from memory
Result: 15.0000

Testing division by zero...
Error: Division by zero!
[TCalculator.Destroy] Calculator shutting down. Final result: 15.0000

=== TEST 9: Destructor Chain Verification ===

Creating TServiceDog and freeing - watch destructor order:
[TAnimal.Create] Created animal: Charlie
[TDog.Create] Dog breed set to: Beagle
[TServiceDog.Create] Service task: Therapy Dog
Charlie logged 100 hours. Total: 100 hours
[TServiceDog.Destroy] Service dog Charlie retiring after 100 hours of service
[TDog.Destroy] Destroying dog: Charlie the Beagle
[TAnimal.Destroy] Destroying animal: Charlie

===============================================================================
All Class Tests Completed Successfully!
===============================================================================

9 test categories. 6 classes. Multi-level inheritance. Virtual methods. Self keyword. All working.

🎯 What Makes This Special

"Just Works" Philosophy

Add new classes. They automatically work with:

• Variable declarations
• Assignments
• Method calls
• Field access
• Type casts

No special handling required. Pascal class syntax maps directly to C++ class syntax.

Clean C++ Output

The generated code is:

• Readable (you can inspect it)
• Debuggable (#line directives map to Pascal source)
• Efficient (no runtime overhead)
• Idiomatic (follows C++ conventions)

Smart Pointer Memory Management

GDog := TDog.Create('Buddy', 3, 'Golden Retriever');
// ... use GDog ...
GDog.Free;

Uses jp::Ref<T> (smart pointers) under the hood. Memory automatically managed. No leaks possible.

Full Virtual Dispatch

Pascal virtual and override keywords work exactly as expected. Polymorphism is real - not simulated.

Source-Level Debugging

Thanks to #line directives, you can:

• Set breakpoints in Pascal source
• Step through Pascal code
• Inspect variables with Pascal names
• See Pascal call stacks

Even though it's running compiled C++.

🚦 Current Status

✅ Fully Working

• ✅ Class declarations with fields and methods
• ✅ Single inheritance (unlimited depth)
• ✅ Virtual methods with override
• ✅ Constructors with inherited calls
• ✅ Destructors with automatic chaining
• ✅ Self keyword → this
• ✅ TClass.Create() → jp::create()
• ✅ obj.Free → obj.reset()
• ✅ Private/public visibility
• ✅ If-then-else without begin-end
• ✅ String escaping for embedded quotes
• ✅ True/False → true/false
• ✅ Type casts: Double(x) → static_castjp::Double(x)

⚠️ Coming Soon

• ❌ Multiple inheritance (interfaces)
• ❌ Protected visibility
• ❌ Class variables (static fields)
• ❌ Class methods (static methods)
• ❌ Properties with getters/setters
• ❌ Abstract methods
• ❌ Operator overloading

These are planned features, not limitations. The core OOP foundation is solid.

🚀 Performance

JetPascal classes compile to native C++ classes. The performance characteristics are identical to hand-written C++:

• Zero overhead abstraction - virtual calls have standard vtable cost
• Inline optimization - small methods get inlined by LLVM
• Smart pointer efficiency - reference counting is minimal
• No garbage collection - deterministic destruction

📚 Summary

Pascal	C++ Generated
TDog = class(TAnimal)	class TDog : public TAnimal
procedure Speak; virtual;	virtual void Speak();
procedure Speak; override;	void Speak() override;
inherited Create(args)	: ParentClass(args) (initializer list)
Self.GetName	this->GetName()
TDog.Create(args)	jp::create<TDog>(args)
obj.Free	obj.reset()
destructor Destroy; override;	virtual ~TDog()

Write Pascal. Get C++. Ship native.

Happy Coding! 🏛️

JetPascal™ - Accelerate Your Code!

---

Technical Note: JetPascal's class support leverages C++23's powerful type system while maintaining Pascal's familiar syntax. The transpiler performs intelligent analysis to generate proper initializer lists, virtual method tables, and destructor chains. All objects are managed via jp::Ref<T> smart pointers (based on std::shared_ptr) ensuring automatic memory management without garbage collection overhead. The #line directive generation ensures that debugging, profiling, and error messages all reference the original Pascal source, not the generated C++.