Why I can't pass 'Child' class instance when switching parameter type from 'const' to 'var' in 'overloaded' method

Question

MCVE:

The following code does not compile with error when switching the parameter type from const to var or out in the overloaded method Train of the class TAnimalTrainer

but it compiles if non is specified.

[dcc32 Error] Project14.dpr(41): E2250 There is no overloaded version of 'Train' that can be called with these arguments

program Project14;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

type    
  TAnimal = class
  private
  FName: string;   
  end;

  TDog = class(TAnimal)
  public
    constructor Create(Name: string);
  end;

  TAnimalTrainer = record // class or record
  public
    procedure Train({const}var aA: TAnimal); overload; // class method or not
    procedure Train(const aName: string); overload;
  end;

{ TAnimalTrainer }

procedure TAnimalTrainer.Train(const aName: string);
var
  Dog: TDog;
begin
  Dog := nil;
  try
    Dog := TDog.Create(aName);  
    Train(Dog); // error here
  finally
    Dog.Free;
  end;
end;

procedure TAnimalTrainer.Train(var aA: TAnimal);
begin
  aA := nil;
end;

{ TDog }

constructor TDog.Create(Name: string);
begin
  FName := Name;
end;



begin
  try       
    { TODO -oUser -cConsole Main : Insert code here }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Found workarounds:

• Omit the var.
• Cast the local variable to TAnimal(Dog)
• stick with const.

Question: Is this a bug in the compiler?

Answer 1

Is this a bug in the compiler?

No it is not.

Although you have discovered this in the context of an overloaded method, the overloading is disguising the real problem. It will be much easier to understand the issue if we remove the overload.

So, to that end, consider this program:

type
  TAnimal = class
  end;

  TDog = class(TAnimal)
  end;

procedure GetAnimal(var AAnimal: TAnimal);
begin
  AAnimal := TAnimal.Create;
end;

var
  Dog: TDog;

begin
  GetAnimal(Dog);
end.

This fails to compile in the call to GetAnimal with this error:

[dcc32 Error]: E2033 Types of actual and formal var parameters must be identical

Why does the compiler reject this? Well, imagine if it accepted this. If it did so then when GetAnimal returned the Dog variable would refer to an object that was not a TDog.

To see this, change the body of the program to look like this:

GetAnimal(TAnimal(Dog));
Writeln(Dog.InheritsFrom(TDog));

When you do so, the program compiles, but the output is

FALSE

In the context of your program, the compiler is faced with some overloads. As we have seen in this example, the compiler cannot accept passing a TDog variable to a TAnimal var parameter, so it rejects that overload. It knows that it cannot pass a TDog variable to a string parameter, so that is rejected. At which point, there are no overloaded methods left, hence the error message.

Answer 2

Basic issue with non matching var parameters is the possibility that you end up with wrong type inside the calling variable.

You can trick the compiler to do that by using absolute keyword - that allows you to declare variables of different type that share same space - and simulate what would happen if compiler would allow you to use such construct.

Consider following example

uses
  System.SysUtils;

type
  TAnimal = class
  public
    procedure Run; virtual;
  end;

  TDog = class(TAnimal)
  public
    procedure Bark; virtual;
    procedure Fetch; virtual;
  end;

  TCat = class(TAnimal)
  public
    procedure Meow; virtual;
  end;

procedure TAnimal.Run;
begin
  Writeln('Run');
end;

procedure TDog.Bark;
begin
  Writeln('Bark');
end;

procedure TDog.Fetch;
begin
  Writeln('Fetch');
end;

procedure TCat.Meow;
begin
  Writeln('Meow');
end;

procedure Move(const aA: TAnimal);
begin
  aA.Run;
end;

procedure Train(var aA: TAnimal);
begin
  aA := TCat.Create;
end;

var
  Dog: TDog;
  Cat: TAnimal absolute Dog;
begin
  try
    // we cannot use Dog here, because compiler would refuse to compile such code
    // Cat is TAnimal and compiler allows to pass it
    // since Dog and Cat variables share same address space that is
    // equivalent of calling Train(Dog);
    Train(Cat); 

    Move(Cat);
    Dog.Bark;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

If you run above code you will get following output

Run
Meow

Dog and Cat variables share the same address space, so when you call Train(Cat) as the result you will get TCat instance that you can use either through Cat or Dog variable. Basically, you will end up with TCat instance inside TDog variable.

Clearly, when you call Dog.Bark, you should get Bark as output not Meow. Meow is the first method in TCat just like the Bark is the first method in TDog, and when resolving the Bark address through TCat virtual method table it will find Meow method instead. Since both methods have same signature everything is fine if you consider wrong output as being fine.

Now, if you try calling the Dog.Fetch, the application will crash with AV. There are no matching methods at corresponding address in TCat class and you are basically calling some uninitialized place in memory instead of proper method.

That explains why var or out parameter types must match the caller variable type.

As to why you can pass TDog or TCat as TAnimal const or value parameter. Both TDog and TCat inherit from TAnimal and whatewer you can do with TAnimal instance, both TDog and TCat support it. They can override particular behavior, so your cat can run differently than your dog, but whatever you do it is well defined. You cannot end up running some inexistent code.

procedure Move(const aA: TAnimal);
begin
  aA.Run;
  aA.Fetch; // this will fail to compile - there is no Fetch method in TAnimal class
end;

Of course, this does not prevent you to test for particular class and use type casts to call Fetch if TAnimal actually is a TDog.

procedure Move(const aA: TAnimal);
begin
  aA.Run;
  if aA is TDog then TDog(aA).Fetch;
end;

However, if you abuse typecasting and typecast without checking whether particular variable is actually a TDog instance, you will again trip into AV.

procedure Move(const aA: TAnimal);
begin
  aA.Run;
  TDog(aA).Fetch;
end;