One option would be to treat the trivial case of ternary expressions directly in SimpleTypeInferer:
If $node->if ?? $node->cond and $node->else have the same type, then the ternary expression also has that type.
If the type is different, then we could return the union type. However this might possibly give us a less precise result than if we actually know the condition.

    public static function infer(
        \Psalm\Codebase $codebase,
        \Psalm\Internal\Provider\NodeDataProvider $nodes,
        PhpParser\Node\Expr $stmt,
        \Psalm\Aliases $aliases,
        \Psalm\FileSource $file_source = null,
        ?array $existing_class_constants = null,
        ?string $fq_classlike_name = null
    ): ?Type\Union {

      if ($stmt instanceof PhpParser\Node\Expr\Ternary) {
        $if = self::infer(
          $codebase,
          $nodes,
          $stmt->if ?? $stmt->cond,
          $aliases,
          $file_source,
          $existing_class_constants,
          $fq_classlike_name
        );
        $else = self::infer(
          $codebase,
          $nodes,
          $stmt->else,
          $aliases,
          $file_source,
          $existing_class_constants,
          $fq_classlike_name
        );
        if ($if && $else) {
          return new Type\Union([$if, $else]);
        }
        return null;
      }

I tried this and gave up for now, because:

In my own project, both branches $if and $else has type == null in most cases. Perhaps because I had constants involved.
In my local fork of psalm, I did not really understand how the test cases are structured, that is, where to find the "expected" value for type resolution.

Still, perhaps my code above is useful..

Class constant with ternary expression sometimes interpreted as 'mixed'. #6633

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions