Major Bug fixes and Internal Performance Improvements

.github/workflows/ci.yml

@@ -12,6 +12,26 @@ permissions:
   contents: read
 
 jobs:
+  security:
+    name: Security Audit
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: '8.4'
+          coverage: none
+
+      - name: Install Dependencies
+        uses: ramsey/composer-install@v3
+
+      - name: Run Security Audit (Composer Audit)
+        run: composer audit
+
   style:
     name: Check Code Style
     runs-on: ubuntu-latest

composer.json

@@ -30,6 +30,7 @@
         "nikic/php-parser": "^5.3"
     },
     "require-dev": {
+        "roave/security-advisories": "dev-latest",
         "laravel/pint": "^1.10",
         "pestphp/pest": "^2.0 || ^3.0 || ^4.0",
         "phpstan/phpstan": "^2.1",
@@ -90,4 +91,4 @@
             "phpstan/extension-installer": true
         }
     }
-}
+}

src/Internal/Ast/ContractVisitor.php

@@ -13,6 +13,7 @@
 use PHPStan\PhpDocParser\Parser\TokenIterator;
 use TypePHP\Internal\Docblock\DocblockExtractor;
 use TypePHP\Internal\Docblock\DocblockNormalizer;
+use TypePHP\Internal\Docblock\DocblockParser;
 use TypePHP\Internal\Util\Config;
 
 /**
@@ -140,9 +141,15 @@ public function enterNode(Node $node): ?array
         }
 
         if ($node instanceof Node\Stmt\Expression) {
+            $node->expr->setAttribute('typephp_is_standalone', true);
+
             return $this->handleExpression($node);
         }
 
+        if ($node instanceof Node\Expr\ArrowFunction) {
+            $node->expr->setAttribute('typephp_is_standalone', true);
+        }
+
         if ($node instanceof Node\Stmt\Foreach_) {
             $doc = $node->getDocComment();
             if ($doc !== null && str_contains($doc->getText(), '@var')) {
@@ -177,6 +184,17 @@ public function leaveNode(Node $node): ?Node
             }
         }
 
+        if ($node instanceof Node\Expr\PreInc || $node instanceof Node\Expr\PostInc || $node instanceof Node\Expr\PreDec || $node instanceof Node\Expr\PostDec) {
+            if (($node instanceof Node\Expr\PostInc || $node instanceof Node\Expr\PostDec) && $node->getAttribute('typephp_is_standalone') !== true) {
+                return null;
+            }
+
+            $replacement = $this->handleIncDec($node);
+            if ($replacement !== null) {
+                return $replacement;
+            }
+        }
+
         if ($node instanceof Node\Expr\PreInc || $node instanceof Node\Expr\PostInc || $node instanceof Node\Expr\PreDec || $node instanceof Node\Expr\PostDec) {
             $replacement = $this->handleIncDec($node);
             if ($replacement !== null) {
@@ -216,10 +234,14 @@ public function leaveNode(Node $node): ?Node
 
     private function markWriteContext(Node $node): void
     {
+        while ($node instanceof Node\Expr\ArrayDimFetch || $node instanceof Node\Expr\PropertyFetch) {
+            $node->setAttribute('typephp_write_context', true);
+            $node = $node->var;
+        }
+
         $node->setAttribute('typephp_write_context', true);
-        if ($node instanceof Node\Expr\ArrayDimFetch || $node instanceof Node\Expr\PropertyFetch) {
-            $this->markWriteContext($node->var);
-        } elseif ($node instanceof Node\Expr\Array_ || $node instanceof Node\Expr\List_) {
+
+        if ($node instanceof Node\Expr\Array_ || $node instanceof Node\Expr\List_) {
             foreach ($node->items as $item) {
                 if ($item !== null) {
                     $this->markWriteContext($item->value);
@@ -237,6 +259,35 @@ private function processClassPropertyDefaults(Node\Stmt\Class_ $node): void
         $defaultProps = [];
         $hasConstructor = false;
 
+        $classTemplates = [];
+        $nodeDoc = $node->getDocComment();
+        if ($nodeDoc !== null && (str_contains($nodeDoc->getText(), '@template') || str_contains($nodeDoc->getText(), '@phpstan-template') || str_contains($nodeDoc->getText(), '@psalm-template'))) {
+            try {
+                $phpDocNode = DocblockExtractor::parseDocString($nodeDoc->getText());
+                $classTemplates = DocblockExtractor::extractTemplates($phpDocNode);
+            } catch (\Throwable) {
+            }
+        }
+
+        if ($node->name !== null) {
+            $className = $this->resolveQualifiedName($node->name);
+            if ($className !== null) {
+                try {
+                    $loadedTemplates = DocblockParser::parseClassTemplates($className);
+                    $classTemplates = [...$classTemplates, ...$loadedTemplates];
+                } catch (\Throwable) {
+                }
+            }
+        }
+
+        if ($node->extends !== null) {
+            try {
+                $parentTemplates = DocblockParser::parseClassTemplates($node->extends->toString());
+                $classTemplates = [...$classTemplates, ...$parentTemplates];
+            } catch (\Throwable) {
+            }
+        }
+
         foreach ($node->stmts as $stmt) {
             if ($stmt instanceof Node\Stmt\ClassMethod && strtolower($stmt->name->toString()) === '__construct') {
                 $hasConstructor = true;
@@ -247,6 +298,22 @@ private function processClassPropertyDefaults(Node\Stmt\Class_ $node): void
 
                 $doc = $stmt->getDocComment();
                 if ($doc !== null && str_contains($doc->getText(), '@var') && ! str_contains($doc->getText(), '@typephp-ignore')) {
+                    if ($classTemplates !== []) {
+                        $varTag = DocblockExtractor::extractVarTagFromDoc($doc->getText());
+                        if ($varTag !== null) {
+                            try {
+                                [$typeParser, $lexer] = DocblockExtractor::getTypeParserComponents();
+                                $tokens = new TokenIterator($lexer->tokenize(DocblockNormalizer::normalize($varTag[0])));
+                                $propTypeNode = $typeParser->parse($tokens);
+
+                                if (DocblockParser::typeReferencesTemplate($propTypeNode, $classTemplates)) {
+                                    continue;
+                                }
+                            } catch (\Throwable) {
+                            }
+                        }
+                    }
+
                     foreach ($stmt->props as $p) {
                         $isExplicitNull = $p->default instanceof Node\Expr\ConstFetch && strtolower($p->default->name->toString()) === 'null';
                         if ($p->default !== null && ! $isExplicitNull) {
@@ -265,19 +332,12 @@ private function processClassPropertyDefaults(Node\Stmt\Class_ $node): void
         }
 
         if (! $hasConstructor) {
-            $ctorStmts = [];
-            if ($node->extends !== null) {
-                $ctorStmts[] = new Node\Stmt\If_(
-                    new Node\Expr\FuncCall(new Node\Name('method_exists'), [
-                        new Node\Arg(new Node\Expr\ClassConstFetch(new Node\Name('parent'), 'class')),
-                        new Node\Arg(new Node\Scalar\String_('__construct')),
-                    ]),
-                    ['stmts' => [
-                        new Node\Stmt\Expression(new Node\Expr\StaticCall(new Node\Name('parent'), '__construct', [new Node\Arg(new Node\Expr\Variable('_typephp_ctor_args'), false, true)])),
-                    ]]
-                );
+            if ($node->extends !== null || $node->isAbstract()) {
+                return;
             }
 
+            $ctorStmts = [];
+
             foreach ($defaultProps as $dp) {
                 $checkCall = NodeBuilder::createPropertyCheckCall(
                     new Node\Expr\PropertyFetch(new Node\Expr\Variable('this'), $dp['name']),
@@ -291,7 +351,7 @@ private function processClassPropertyDefaults(Node\Stmt\Class_ $node): void
 
             $ctor = new Node\Stmt\ClassMethod('__construct', [
                 'flags' => Node\Stmt\Class_::MODIFIER_PUBLIC,
-                'params' => [new Node\Param(new Node\Expr\Variable('_typephp_ctor_args'), null, null, false, true)],
+                'params' => [],
                 'stmts' => $ctorStmts,
             ]);
             $ctor->setAttribute('typephp_injected', true);

src/Internal/Ast/FunctionContractInjector.php

@@ -557,6 +557,10 @@ private static function isIterableCandidate(Node\Param $param, string $docText):
      */
     private static function typeMatchesName(Node\Identifier|Node\Name|Node\ComplexType|null $type, array $targetNames): bool
     {
+        while ($type instanceof Node\NullableType) {
+            $type = $type->type;
+        }
+
         if ($type instanceof Node\Identifier) {
             return isset($targetNames[strtolower($type->name)]);
         }
@@ -757,13 +761,54 @@ public function enterNode(Node $n): int|Node|null
                     );
                 }
 
+                if ($n instanceof Node\Stmt\Return_) {
+                    if ($n->getAttribute('typephp_var_wrapped') === true || $n->getAttribute('typephp_generator_return_wrapped') === true) {
+                        return null;
+                    }
+                    $n->setAttribute('typephp_generator_return_wrapped', true);
+
+                    $exprToWrap = $n->expr ?? new Node\Expr\ConstFetch(new Node\Name('null'));
+                    $checkCall = new Node\Expr\FuncCall(
+                        new Node\Name\FullyQualified('TypePHP\Internal\RuntimeTypeChecker::checkGeneratorReturn'),
+                        [
+                            new Node\Arg(new Node\Scalar\MagicConst\Method()),
+                            new Node\Arg($exprToWrap),
+                            new Node\Arg($this->thisArg),
+                        ]
+                    );
+
+                    $n->expr = FunctionContractInjector::buildTernaryReturnExpr($checkCall, $n->getStartLine());
+
+                    return $n;
+                }
+
                 return null;
             }
         });
 
         /** @var array<Node\Stmt> $newStmts */
         $newStmts = $traverser->traverse($stmts);
 
+        $lastStmt = end($newStmts);
+        if (! $lastStmt instanceof Node\Stmt\Return_ && ! ($lastStmt instanceof Node\Stmt\Expression && $lastStmt->expr instanceof Node\Expr\Throw_)) {
+            $checkCall = new Node\Expr\FuncCall(
+                new Node\Name\FullyQualified('TypePHP\Internal\RuntimeTypeChecker::checkGeneratorReturn'),
+                [
+                    new Node\Arg(new Node\Scalar\MagicConst\Method()),
+                    new Node\Arg(new Node\Expr\ConstFetch(new Node\Name('null'))),
+                    new Node\Arg($thisArg),
+                ]
+            );
+
+            $fallbackLine = $lastStmt instanceof Node\Stmt ? $lastStmt->getStartLine() : null;
+            $ternaryExpr = self::buildTernaryReturnExpr($checkCall, $fallbackLine);
+
+            $retStmt = new Node\Stmt\Return_($ternaryExpr);
+            $retStmt->setAttribute('typephp_injected', true);
+            $retStmt->setAttribute('typephp_generator_return_wrapped', true);
+            $newStmts[] = $retStmt;
+        }
+
         return $newStmts;
     }
 

src/Internal/Checker/ConditionalChecker.php

@@ -38,12 +38,12 @@ final class ConditionalChecker
      */
     public static function containsConditional(TypeNode $node): bool
     {
-        if ($node instanceof ConditionalTypeNode || $node instanceof ConditionalTypeForParameterNode) {
-            return true;
+        while ($node instanceof NullableTypeNode || $node instanceof ArrayTypeNode) {
+            $node = $node->type;
         }
 
-        if ($node instanceof NullableTypeNode || $node instanceof ArrayTypeNode) {
-            return self::containsConditional($node->type);
+        if ($node instanceof ConditionalTypeNode || $node instanceof ConditionalTypeForParameterNode) {
+            return true;
         }
 
         if ($node instanceof GenericTypeNode) {
@@ -145,10 +145,10 @@ public static function resolve(
 
         if ($typeNode instanceof GenericTypeNode) {
             $genericType = self::resolve($typeNode->type, $vars, $boundTemplates, $registry, $function);
-            $genericTypes = array_map(
-                fn ($t) => self::resolve($t, $vars, $boundTemplates, $registry, $function),
-                $typeNode->genericTypes
-            );
+            $genericTypes = [];
+            foreach ($typeNode->genericTypes as $gt) {
+                $genericTypes[] = self::resolve($gt, $vars, $boundTemplates, $registry, $function);
+            }
 
             return new GenericTypeNode(
                 $genericType instanceof IdentifierTypeNode ? $genericType : $typeNode->type,
@@ -158,17 +158,21 @@ public static function resolve(
         }
 
         if ($typeNode instanceof UnionTypeNode) {
-            return new UnionTypeNode(array_map(
-                fn ($t) => self::resolve($t, $vars, $boundTemplates, $registry, $function),
-                $typeNode->types
-            ));
+            $types = [];
+            foreach ($typeNode->types as $t) {
+                $types[] = self::resolve($t, $vars, $boundTemplates, $registry, $function);
+            }
+
+            return new UnionTypeNode($types);
         }
 
         if ($typeNode instanceof IntersectionTypeNode) {
-            return new IntersectionTypeNode(array_map(
-                fn ($t) => self::resolve($t, $vars, $boundTemplates, $registry, $function),
-                $typeNode->types
-            ));
+            $types = [];
+            foreach ($typeNode->types as $t) {
+                $types[] = self::resolve($t, $vars, $boundTemplates, $registry, $function);
+            }
+
+            return new IntersectionTypeNode($types);
         }
 
         if ($typeNode instanceof ArrayShapeNode) {
@@ -211,16 +215,16 @@ public static function resolve(
         }
 
         if ($typeNode instanceof CallableTypeNode) {
-            $parameters = array_map(
-                fn (CallableTypeParameterNode $param) => new CallableTypeParameterNode(
+            $parameters = [];
+            foreach ($typeNode->parameters as $param) {
+                $parameters[] = new CallableTypeParameterNode(
                     self::resolve($param->type, $vars, $boundTemplates, $registry, $function),
                     $param->isReference,
                     $param->isVariadic,
                     $param->parameterName,
                     $param->isOptional
-                ),
-                $typeNode->parameters
-            );
+                );
+            }
 
             $returnType = self::resolve($typeNode->returnType, $vars, $boundTemplates, $registry, $function);