Styjun

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(constvar 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?

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.

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;