Mandatory () on All Zero-Argument Calls 📣

[graemeg]

Hey everyone! We've just landed a language change that we're really excited about — and we think you will be too, once you see the reasoning.

Starting now, Blaise requires parentheses on every function, procedure, method, and constructor call — even when there are no arguments.

// ✅ The Blaise way
F := TFoo.Create();
Obj.Free();
WriteLn();
X := GetCurrentDir();

// ❌ No longer accepted
F := TFoo.Create;
Obj.Free;
WriteLn;
X := GetCurrentDir;

The @ (address-of) operator is the sole exception — @Obj.Method takes a method reference without invoking it, so no () is written.

Why? 🤔

If you've spent any time with traditional Pascal (Delphi or FPC), you've almost certainly been bitten by this:

X := Foo;

Is Foo a variable? A constant? A function call? You genuinely can't tell without looking up the declaration. The compiler figures it out from context, but you have to play detective every time you read the code.

We decided Blaise shouldn't make you guess.

1. Clarity for humans 👀

With mandatory (), the intent is obvious at the call site:

X := Foo;      // This is reading a variable — always
X := Foo();    // This is calling a function — always

No ambiguity. No mental lookup table. Code reviews get easier, onboarding gets faster, and bugs get more obvious. Your future self reading the code at 11pm will thank you.

2. Result vs recursion — no more guessing games 🔄

In traditional Pascal, a bare function name inside its own body reads the Result variable. To actually recurse, you need (). But without mandatory parentheses, this distinction is invisible at the call site:

function Factorial(N: Integer): Integer;
begin
  if N <= 1 then
    Factorial := 1            // Assigns to Result
  else
    Factorial := N * Factorial;  // 🐛 BUG! Reads uninitialised Result
                                 //    instead of recursing
end;

The fix is Factorial(N - 1) — but the compiler won't warn you when you forget the (). You just silently get garbage. With mandatory parentheses, the rule is consistent everywhere: Foo is always a read, Foo() is always a call. Inside a function body or outside, the same visual cue applies — no special cases to remember. 🧠

3. Grep-ability 🔍

Want to find every call site of GetCurrentDir? Just search for GetCurrentDir(. Done. In traditional Pascal you'd need full semantic analysis to distinguish X := GetCurrentDir (a call) from a hypothetical variable of the same name.

4. Simpler compiler internals 🏗️

This is the one most users won't care about — but it matters for the project's health.

The old approach required the compiler to synthesise invisible call nodes for bare zero-argument identifiers, threading IsNoArgFuncCall flags through the AST so every consumer (QBE codegen, native backend, semantic pass, debugger) could distinguish a call from a variable read. Every new backend or analysis pass that forgot to check the flag was a latent bug waiting to happen.

With mandatory (), the parser produces distinct node types: TMethodCallExpr for calls, TFieldAccessExpr for field reads. The distinction is structural, not flag-based. We were able to delete the entire IsNoArgFuncCall / NoArgFuncDecl machinery and simplify several codegen paths. Three latent codegen bugs were flushed out in the process — bugs that had been silently masked by the old implicit-call path from the start. 🐛

5. Procedure-type fields just work 🎯

An interesting edge case: if you have a class with a field of procedure type, the old syntax was genuinely ambiguous:

H.Handler;   // Call the procedure stored in the field? Or read the field value?

With mandatory (), there's no confusion:

G := H.Handler;    // Read the field value (a method pointer)
H.Handler();       // Invoke the procedure stored in the field

We added proper IsProcFieldCall support so that Obj.ProcField() dispatches through the stored code pointer — no workarounds needed.

We're in good company 🌍

Blaise isn't the first language to make this call (pun intended). Several modern languages require parentheses on all calls:

Language	Zero-arg call syntax	Notes
Go	foo()	Bare foo is always a function value, never a call
Rust	foo()	Bare foo is a function pointer / closure value
Swift	foo()	Bare foo is a method reference
Kotlin	foo()	Property access is bare; calls always need ()
C / C++	foo()	foo without () is a function pointer
Java	foo()	No bare-call syntax exists at all
Python	foo()	Bare foo is the function object itself
TypeScript	foo()	Bare foo is a function reference

The only widely-used languages that allow bare calls are the ones with property syntax (C#, Ruby, Scala) where the design intent is to make method calls look like field access. Pascal's implicit calls aren't a deliberate design feature — they're a historical artefact from a time when () was considered redundant noise. Modern language design has overwhelmingly settled on explicit () for calls, and we agree with the consensus.

Migration effort 📝

This was a mechanical change — Foo becomes Foo(), inherited Create becomes inherited Create(), and so on. For anyone maintaining Blaise code outside the main repo, a simple regex search for bare function/method calls should catch everything. The compiler will immediately report any you miss — no silent behaviour change.

Since Blaise is still in alpha with no stable public API, we skipped a deprecation period and went straight to enforcement. Better to rip the plaster off now than drag it out. 🩹

The numbers 📊

• ~500 call sites migrated across compiler, runtime, stdlib, and tests
• 89 files touched in the cleanup commit
• 2627 tests passing ✅
• FIXPOINT_OK — self-hosting verified ✅
• 3 latent codegen bugs flushed out and fixed along the way 🐛→🦋

As always, I'd love to hear your thoughts. If you have questions about the change or hit any issues, drop a comment below!

Happy coding! 🚀

---

Built with ❤ for the Pascal community.

[Alexey-T]

I agree. Good reasons in the post. Thanks. And it was interesting post.

[graemeg]

Thank you. 👍

[Alexey-T]

Graeme, next wish. I got it from 1 minute ago.

Drop the special Write syntax feature, ':' symbols to make result formatting. Write(n:9:4)

And Str has that symbols maybe. Or not. Idk.

[Alexey-T]

Graeme next idea.

If i have in atsynedit old method. Which needs now a additional param. I must in fpc, add that param to the end and check that old method calls not broken.

I wrote it badly.
Trying again. I want to support calls Nnn(aa:= 5, bb:= 6)
If method Nnn has first param bb, second param aa, and optional param cc.

[Schmitty2005]

Hmmmm... an idea for Blaise....

If it had record defaults available (FPC does not) 😀 :

Type
  Trec = record
    aa : integer;
    bb : double;
    cc : single = 1.23;
  end;

Then maybe

procedure nnn(AValue: Trec);
...

Followed with a call of :

Nnn(Trec.bb := 2.3, Trec. aa := 4); // cc would be default 1.23

Or just a call with

var
  recSet:Trec;
...
Nnn(recSet);
...

Just an idea.....