PHP: Shouldn't a call to an undefined function trigger an error in the editor?

[negora]

Hi:

I've created a PHP project from scratch, in NetBeans 26. I'm editing a single PHP file (a very simple one), and I was wondering if a call to an undefined function shouldn't trigger an error in the editor (or a warning at least). For example, consider this piece of code:

<?php
foo ();

I understand that foo() may or may not exist in the global space but, Doesn't Netbeans scan the whole project to discover which declarations are made in each space?

Thank you.

[matthiasblaesing]

You assume, that NetBeans "knows" about your runtime environment, but that is not the case. You can install extensions outside your project and these can make global function available to your code. So there is a high risk to cause false positives for such warnings.

[negora]

@matthiasblaesing Good point. To be honest, I didn't know the constructions with __call and __callStatic. However, I still believe that a warning would make more good than harm. For example, in my examples I'm calling a field/method from the class itself (I'm using $this; self for static members). This is a class that I myself am declaring, so I (and the IDE) know for sure that such field/method doesn't exist. Why would I want to call an undefined member, on purpose, from the inside of the class? Even if the class were inheriting from another one, the IDE would know the type of the parent class (present in the extends) and could also know if the member exists or not.

In addition to all this, and in contrast to the 5 series, PHP added type declarations (a game-changer for static analysis) and even it deprecated dynamic property declarations (present in your example), except for cases where we explicitly need dynamic objects. So, with the current state of PHP (and adding Composer to the mix), Isn't it more probable that a reference to an undefined member is a mistake and not made on purpose?

[matthiasblaesing]

This could be implemented as an optional feature. but that needs someone to do it. Before any work is done I strongly suggest to coordinate with @junichi11 and @tmysik to see if such work will have the chance to be merged.

[tmysik]

Thanks for your question.

PHP is a dynamic language, so it is always difficult to detect these situations (PHP is more like JavaScript than Java, in this particular case). The best you can do here is - to create an issue and assign it to @junichi11. We can evaluate, but please, keep in mind that it can easily happen that such a detection could have a big negative impact on the performance of the IDE (just an example situation that can happen). So, once such an issue is created, we can discuss it there. Please be sure that if it can be implemented in some reasonable way, there is a good chance that it will be done (BTW, patches are more than welcome, of coure 😁).

[haidubogdan]

Technically, it should be possible as all the function declarations are indexed. So you could have a configurable hint layer implemented which would use the indexed data + scope context and display a warn information if a function doesn't have a declaration.
Yet, indeed it can have some impact on performance and it would be prone to bugs (especially on Windows OS which seems to have slower file scan speed :P ).

[junichi11]

As Tomas wrote, there may be a performance problem. There may be other special cases, such as Matthias's example. (e.g. on frameworks)
So, I don't suppose this is easy...

[negora]

Thank you all for your answers. They're very clarifying.

I must admit that discovering type declarations in PHP has changed my mind with regard to this potential hint (and others). I agree that, without types in the function parameters and returns, this hint would be useless once you crossed the boundary of a function. But explicit types allow a much more stricter analysis.

There would still be corner cases, of course. For example, if you don't use namespaces and declare 2 classes with the same name in your code base (in 2 different files). Wherever you instantiate any of these classes and call one of its methods, the analyzer will have to decide between:

• Either consider any method of that instance as existing (too lax).
• Or consider any method of that instance as non-existing (too strict).
• Or generate something like an intersection type in memory and consider methods of both classes as existing.

If I'm not mistaken, the PHP plugin of IntelliJ and the Intelephense plugin of Visual Studio Code have chosen the 3rd route.

I wish I had a deep knowledge about language analysis and, specially, the Netbeans internals (to help with this). But my knowledge is limited to Java back-end apps only :-/ .