Hacker News

Psalm 7 release: PHP security&static analysis software

68 points by danogentili ago | 34 comments

idoubtit |next [-]

For anyone not familiar with PHP, static analysis is pretty much required because the official PHP type system is minimal. The detailed types are added through phpdoc comments, and they also help IDEs to provide a sane completion. For instance, the plain "array" should be detailed with phpdoc:

    /**
     * @param array<string, MyRecord> $input
     * @return list<int>
     */
    function foo(array $input): array
    {
        foreach ($input as $string => $record) {
            // IDE knows $record is an instance of MyRecord

The static analysis will use both type systems, and it's the only way to check that phpdoc are consistent. Psalm has various levels of strictness, and even at a very lax level, it can help detect errors or code smells.

There are two major static analysis tools for PHP, Psalm and PHPstan, both written in PHP. The latter used to be much slower, but last time I tried it there was little difference (about 20 s for 100k lines + dependencies).

My guess is that a new contender, Mago, written in Rust, will probably soon replace those other tools. Its commands (analyze, lint) are already almost as complete as psalm/phpstan. Though the migration won't be easy because it does not have a notion of levels.

bel8 |root |parent [-]

PHP type system is lacking but I wouldn't call it minimal.

PHP even has union types, just like TypeScript.

The major issue is the lack of array types and it's 90% of the reason I see projects using extra linting tools.

[1] https://php.watch/versions/8.0/union-types

idoubtit |root |parent |next [-]

Maybe "minimal" was not the right word. I hope the context made clear that I meant the type system was lacking even for basic uses. Here are 3 common cases.

Some PHP functions (e.g. opening a file) return a `resource` type, but PHP has no official way to declare it. So the right way is to declare `mixed` as an official type (which means `any`) and fix that declaration with a phpdoc comment.

Phpdoc provides generics (named "templates", à la C++), e.g. `iterable<Something>` where `iterable` is an official PHP type (which is awfully imprecise without phpdoc).

Phpdoc has tuples and (associative) array shapes, e.g. `@return list{int, \Error}`.

In past PHP versions, the type system was worse because the internal types were ambiguous: types were implicitly nullable, i.e. `string` meant `null|string`. When PHP gradually added sum types, they fixed that ambiguity.

someothherguyy |root |parent [-]

> Phpdoc has tuples and (associative) array shapes, e.g. `@return list{int, \Error}`.

`list<Error>` a `list<T>` is `array<int<0, max>, T>` (some differences in phpstan vs psalm vs mago)

someothherguyy |root |parent |next |previous [-]

it has union and intersection types, but it is nothing like typescript.

Timon3 |root |parent |next |previous [-]

> PHP type system is lacking but I wouldn't call it minimal.

PHP still doesn't have generics, right? IMO any type system without higher-order types is definitely on the minimal side.

eithed |root |parent [-]

Natively: no. Via tools like phpstan and psalm: yes, per OP. Link to relevant docs: https://psalm.dev/docs/annotating_code/templated_annotations... or https://phpstan.org/blog/generics-by-examples

One can declare:

  final class Door {}

  /**
   * @template T
   */
  final class Box
  {
      /** @param T $value */
      public function __construct(private mixed $value) {}

      /** @return T */
      public function get(): mixed
      {
          return $this->value;
      }
  }

  final class DoorInspector
  {
      /** @param Box<Door> $box */
      public function __construct(private Box $box) {}

      public function inspect(): void
      {
          $this->box->get()->open(); // analyser knows this is a Door
      }
  }

  new DoorInspector(new Box(new Door()));   // OK
  new DoorInspector(new Box('not a door')); // error: Box<string> given

You can even bind a template by a generic type with "of":

  final class Door {}

  /**
   * @template T
   */
  class Box
  {
      /** @param T $value */
      public function __construct(private mixed $value) {}

      /** @return T */
      public function get(): mixed
      {
          return $this->value;
      }
  }

  /** @extends Box<Door> */
  final class DoorBox extends Box {}

  /**
   * @template T
   * @template F of Box<T>
   */
  final class Shelf
  {
      /** @param F $box */
      public function __construct(private Box $box) {}

      /** @return F */
      public function box(): Box
      {
          return $this->box;
      }

      /** @return T */
      public function item(): mixed
      {
          return $this->box->get();
      }
  }

  $shelf = new Shelf(new DoorBox(new Door()));
  $shelf->box();  // DoorBox
  $shelf->item(); // Door

someothherguyy |root |parent [-]

yeah, it is a real pain in the ass. imagine if php 8 accepted the RFC for generics

wesammikhail |root |parent |previous [-]

That's exactly it but PHP Core refuses to address the typed array issue in wait for a consensus on Generics even though those two things serve different audiences.

I haven't actually run into a single issue with PHP's type system in the last few years. Literally the only thing that remains is typed arrays but that seems to be ways off due to fragmentation in how the core devs want it handled.

hparadiz |root |parent [-]

With how good PHPDoc and Phan are these days I don't really think about it anymore. You can sort of have typed array by implementing Iterator, Countable, ArrayAccess, and optionally Indexing but I assume you mean defining types of array values.

anthk |next |previous [-]

Thou shall use the Rust rewrite of PHP.

hiccuphippo |root |parent |next [-]

Why not skip the php and write rust directly?

Y-bar |root |parent |previous [-]

”Rewrite in Rust” fanboys are more annoying than crypto bros. How is such a feat even possible?

scronkfinkle |root |parent |next [-]

I dunno,unlike the crypto/NFT era, Rust rewrites have demonstrated measured performance and memory savings gains. Some grimace when they see "written in Rust" as a tagline but my immediate thought tends to land more on the "thank God this isn't an electron app" side of things

Y-bar |root |parent [-]

Operative word is “fanboys”, I have mostly no qualms of actual rewrites to that language. It’s the fanboys who insist upon injecting themselves and their opinions everywhere with net negative impact.

RunSet |root |parent |next |previous [-]

Google funding, I suspect. One day they will turn off the tap and the mantra will be silenced.

"Strange; seems like all I hear about these days are projects funded by the world's largest advertising corporation."

wesammikhail |root |parent |previous [-]

inb4 "Rewrite bitcoin in Rust" comments stars pouring in

origini |previous [-]

Ah boy o boy, PHP was the first lanuage I teached myself but man it still needs PHPDoc comment on return types?

Come on PHP has so many shitty things, but even something basic like this is still not in the lanuage itself?

pkkm |root |parent |next [-]

PHP does have return type annotations. The reason the PHPDoc comments are needed here is that it lacks generics. Unfortunately, adding generics has proven problematic, but I still hope that we'll see them in the next few years.

monster_truck |root |parent |next |previous [-]

It's had return type declarations since 7. There's even intersection and literal types now. You could have typed this into google and it would have told you

origini |root |parent |next [-]

I did and it told me that it doesn't support typed arrays.

bakugo |root |parent |previous [-]

Type declarations are still quite limited, though. For example, you can declare that a function returns an array or a string, but not an array of strings.

lofaszvanitt |root |parent [-]

Use a class if you need them.

bakugo |root |parent [-]

How does that solve the problem? You can't declare an array of strings inside a class, either.

eithed |root |parent |next [-]

You can annotate the method as `@return array<array-key,string>` or even `@return list<string>` (array of strings = indexed via anything that can be used as a key in PHP vs list of strings = indexed via incrementing integers, starting from 0). I guess the OP suggestion was to use Arrayable / Iterable interfaces, which would work as well, but would require more effort (= yes, declare a class)

lofaszvanitt |root |parent |previous [-]

Do some research :D.

origini |root |parent [-]

Just to be clear, you suggest to wrap a typed array into its own class? is that the suggestion you think of?

Because if yes, thats just ugly and a hack/workaround.

Y-bar |root |parent |next |previous [-]

TFA even shows examples of native return types. How could you not see that?

origini |root |parent [-]

The page itself shows plenty of examples were this is not true.

Including generic type arrays which is not supported.

throw1234567891 |root |parent |next |previous [-]

"Taught", not "teached".

spiderfarmer |root |parent |previous [-]

"Cool! A PHP article on HN, let's rehash some of my comments that got lots of upvotes 11 years ago!"

origini |root |parent [-]

Yepp, especially because not much changed and other languages did quite a lot. Strong contrast don't you think?

wesammikhail |root |parent [-]

Hmmm not much changed you say... Lets take a look at https://wiki.php.net/rfc

ooh wait, you couldn't be more wrong. Pikachuface.png

origini |root |parent [-]

Core issues have not been fixed.

You remember when HHVM / hack came out from Facebook? Besides the fact that it was quite a dick move from Facebook to bring it out and then stop supporting it, it pushed PHP to take performance temporarily serious and there was so much air in it.

But the standard library is still inconsistent as hell, type system is still garbage especially mixxing strict and non strict.

The concurrency implementation? Has to be fixed again by frameworks.

And yeah i mean the critisism of my original comment stands as well and thats just an eye sore.