https://issues.dlang.org/show_bug.cgi?id=24025
Issue ID: 24025
Summary: Expressions contained in parentheses should not be
assumed to be C casts
Product: D
Version: D2
Hardware: All
OS: All
Status: NEW
Keywords: diagnostic, rejects-valid
Severity: normal
Priority: P1
Component: dmd
Assignee: nob...@puremagic.com
Reporter: schvei...@gmail.com
```d
void bar(int x) {}
void main()
{
(&bar)(5); // ok
auto foo = &bar;
(foo = foo)(5); // ok
(*foo)(5) // ok
(foo)(5); // error C style cast not allowed
(bar)(5); // error C style cast not allowed
}
```
The error should not occur. `foo` and `bar` are not types, so this is not a
C-style cast.
According to the grammar, `PostfixExpression` covers function calls. Its
grammar is:
```
PostfixExpression:
PrimaryExpression
PostfixExpression . Identifier
PostfixExpression . TemplateInstance
PostfixExpression . NewExpression
PostfixExpression ++
PostfixExpression --
PostfixExpression ( ArgumentListopt )
TypeCtorsopt BasicType ( ArgumentListopt )
IndexExpression
SliceExpression
```
`PrimaryExpression` can be `( Expression )`, which gets all the way back to a
`( PostfixExpression )`, so this should be valid grammar.
Indeed, the fact that making it look less like a C cast negates the warning, as
the other lines in the function show.
C style casts should only be diagnosed when the expression in the parentheses
is a type, not just any expression that *might* be a type. Therefore, the error
should be deferred to semantic.
This came up when I ported some code from C that looked like:
```c
(obj->fnptr)(args);
```
--
