The following code compiles both with :

procedure F(const A: array of ShortInt); begin end;
begin F(1); end.

I think this is a bug in FPC, but if not -- it should be documented here: http://freepascal.org/docs-html/ref/refsu59.html#x157-16700014.4.5

I am willing to file an issue one way or another.

AFAIK this is by intension (this was mentioned some weeks ago on one of the lists, I can't find it though...).

Regards,
Sven

Unfortunately Delphi (6) accepts this too. It took me some time at work to figure out why some code suddenly behaved weird. (I changed a integer argument to array of integer and assumed the compiler would help me to find the places where I still passed a single integer)

Marc

Marc Weustink wrote

Unfortunately Delphi (6) accepts this too. It took me some time at work to figure out why some code suddenly behaved weird. (I changed a integer argument to array of integer and assumed the compiler would help me to find the places where I still passed a single integer)

I suggest this "feature" to be disabled in objfpc mode then.

This would not be backwards compatible, thus the answer to this request is most likely: No.

Regards,
Sven

On the other hand, FPC has an established history of breaking backwards compatibility in favor of type cheking.
In my opinion this breakage is substantially more acceptable than some previous ones.

-----Original Message-----

Delphi XE does not accept constants either, but scalar variables. So the following compiles:

=== source begin ===

program openarrayscalar;
{$apptype console}
procedure Test(aArgs: array of LongInt);
var
  i: LongInt;
begin
  for i in aArgs do
    Writeln(i);
end;
var
  z: LongInt;
begin
  z := 42;
  Test(z);
  Readln;
end.

=== source end ===

The Delphi help also mentions this here:
http://docwiki.embarcadero.com/RADStudio/en/Parameters_%28Delphi%29#Open_Array_Parameters

=== qoute begin ===

Instead of an array, you can pass a variable of the open array parameter's base type. It will be treated as an array of length 1.

=== qoute end ===

Constant values and untyped constants can indeed not be used as argument for open array parameters, but typed constants can.

Regards,
Sven

-----Original Message-----

Given the above, I suggest to leave Delphi mode as is, and forbid scalar values in FPC mode.

Alexander Klenin wrote on Mon, 11 Jun 2012:

[passing single elements as open array parameters]

Given the above, I suggest to leave Delphi mode as is, and forbid scalar values in FPC mode.

We can probably add a modeswitch that you can use to explicitly disable this type conversion.

Jonas