processing includes as proposed in maglnet#67

src/ComposerRequireChecker/ASTLocator/FileAST.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace ComposerRequireChecker\ASTLocator;
+
+use Traversable;
+
+class FileAST
+{
+ /**
+ * @var string
+ */
+ private $file;
+
+ /**
+ * @var Traversable
+ */
+ private $ast;
+
+ /**
+ * @param string $file
+ * @param Traversable|array|null $ast
+ *
+ */
+ public function __construct(string $file, $ast)
+ {
+ $this->file = $file;
+ $this->ast = $ast;
+ }
+
+ /**
+ * @return string
+ */
+ public function getFile()
+ {
+ return $this->file;
+ }
+
+ /**
+ * @return Traversable|array
+ */
+ public function getAst()
+ {
+ return $this->ast;
+ }
+}

src/ComposerRequireChecker/ASTLocator/LocateASTFromFiles.php

@@ -27,12 +27,12 @@ public function __construct(Parser $parser, ?ErrorHandler $errorHandler)
  /**
  * @param Traversable|string[] $files
  *
- * @return Traversable|array[] a series of AST roots, one for each given file
+ * @return Traversable|FileAST[] a series of AST roots, one for each given file
  */
  public function __invoke(Traversable $files): Traversable
  {
  foreach ($files as $file) {
- yield $this->parser->parse(file_get_contents($file), $this->errorHandler);
+ yield new FileAST($file, $this->parser->parse(file_get_contents($file), $this->errorHandler));
  }
  }
 }

src/ComposerRequireChecker/Cli/CheckCommand.php

@@ -67,12 +67,16 @@ protected function execute(InputInterface $input, OutputInterface $output): int
 
  $sourcesASTs = $this->getASTFromFilesLocator($input);
 
- $definedVendorSymbols = (new LocateDefinedSymbolsFromASTRoots())->__invoke($sourcesASTs(
+ list($definedVendorSymbols, $additionalFiles) = (new LocateDefinedSymbolsFromASTRoots())->__invoke($sourcesASTs(
  (new ComposeGenerators())->__invoke(
  $getPackageSourceFiles($composerJson),
  (new LocateComposerPackageDirectDependenciesSourceFiles())->__invoke($composerJson)
  )
  ));
+ while ($additionalFiles && count($additionalFiles)) {
+ list($vendorSymbols, $additionalFiles) = (new LocateDefinedSymbolsFromASTRoots())->__invoke($sourcesASTs($additionalFiles));
+ $definedVendorSymbols = array_unique(array_merge($vendorSymbols, $definedVendorSymbols));
+ }
 
  $definedExtensionSymbols = (new LocateDefinedSymbolsFromExtensions())->__invoke(
  (new DefinedExtensionsResolver())->__invoke($composerJson, $options->getPhpCoreExtensions())

src/ComposerRequireChecker/DefinedSymbolsLocator/LocateDefinedSymbolsFromASTRoots.php

@@ -2,7 +2,9 @@
 
 namespace ComposerRequireChecker\DefinedSymbolsLocator;
 
+use ArrayIterator;
 use ComposerRequireChecker\NodeVisitor\DefinedSymbolCollector;
+use ComposerRequireChecker\NodeVisitor\IncludeCollector;
 use PhpParser\NodeTraverser;
 use PhpParser\NodeVisitor\NameResolver;
 use Traversable;
@@ -21,15 +23,17 @@ public function __invoke(Traversable $ASTs): array
 
  $traverser->addVisitor(new NameResolver());
  $traverser->addVisitor($collector = new DefinedSymbolCollector());
+ $traverser->addVisitor($includes = new IncludeCollector());
 
  $astSymbols = [];
+ $additionalFiles = [];
 
  foreach ($ASTs as $astRoot) {
- $traverser->traverse($astRoot);
-
+ $traverser->traverse($astRoot->getAst());
  $astSymbols[] = $collector->getDefinedSymbols();
+ $additionalFiles = array_merge($additionalFiles, $includes->getIncluded($astRoot->getFile()));
  }
 
- return array_values(array_unique(array_merge([], ...$astSymbols)));
+ return [array_values(array_unique(array_merge([], ...$astSymbols))), new ArrayIterator($additionalFiles)];
  }
 }

src/ComposerRequireChecker/NodeVisitor/IncludeCollector.php

@@ -0,0 +1,129 @@
+<?php
+
+namespace ComposerRequireChecker\NodeVisitor;
+
+use FilesystemIterator;
+use InvalidArgumentException;
+use PhpParser\Node;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\BinaryOp\Concat;
+use PhpParser\Node\Expr\ConstFetch;
+use PhpParser\Node\Expr\Include_;
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Scalar\MagicConst\Dir;
+use PhpParser\Node\Scalar\MagicConst\File;
+use PhpParser\Node\Scalar\String_;
+use PhpParser\NodeVisitorAbstract;
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
+
+final class IncludeCollector extends NodeVisitorAbstract
+{
+ /**
+ * @var Expr[]
+ */
+ private $included = [];
+
+ /**
+ * {@inheritDoc}
+ */
+ public function beforeTraverse(array $nodes)
+ {
+ $this->included = [];
+ return parent::beforeTraverse($nodes);
+ }
+
+ /**
+ * @param string $file
+ * @return string[]
+ */
+ public function getIncluded(string $file): array
+ {
+ $included = [];
+ foreach ($this->included as $exp) {
+ try {
+ $this->computePath($included, $this->processIncludePath($exp, $file), $file);
+ } catch(InvalidArgumentException $x) {
+ var_dump($x->getMessage());
+ }
+ }
+ return $included;
+ }
+
+ /**
+ * @param array $included
+ * @param string $path
+ * @param string $self
+ * @return void
+ */
+ private function computePath(array &$included, string $path, string $self)
+ {
+ if (!preg_match('#^([A-Z]:)?/#i', str_replace('\\', '/', $path))) {
+ $path = dirname($self).'/'.$path;
+ }
+ if (false === strpos($path, '{var}')) {
+ $included[] = $path;
+ return;
+ }
+ $parts = explode('{var}', $path);
+ $regex = [];
+ foreach($parts as $part) {
+ $regex[] = preg_quote(str_replace('\\', '/', $part), '/');
+ }
+ $regex = '/^'.implode('.+', $regex).'$/';
+ $self = str_replace('\\', '/', $self);
+ foreach (new RecursiveIteratorIterator(
+ new RecursiveDirectoryIterator(
+ $parts[0],
+ FilesystemIterator::CURRENT_AS_PATHNAME | FilesystemIterator::SKIP_DOTS
+ )
+ ) as $file) {
+ $rfile = str_replace('\\', '/', $file);
+ if ($rfile !== $self && preg_match('/\\.php$/i', $rfile) && preg_match($regex, $rfile)) {
+ $included[] = $file;
+ }
+ }
+ }
+
+ /**
+ * @param string|Exp $exp
+ * @param string $file
+ * @return string
+ * @throws InvalidArgumentException
+ */
+ private function processIncludePath($exp, string $file): string
+ {
+ if (is_string($exp)) {
+ return $exp;
+ }
+ if ($exp instanceof Concat) {
+ return $this->processIncludePath($exp->left, $file).$this->processIncludePath($exp->right, $file);
+ }
+ if ($exp instanceof Dir) {
+ return dirname($file);
+ }
+ if ($exp instanceof File) {
+ return $file;
+ }
+ if ($exp instanceof ConstFetch && $exp->name === 'DIRECTORY_SEPARATOR') {
+ return DIRECTORY_SEPARATOR;
+ }
+ if ($exp instanceof String_) {
+ return $exp->value;
+ }
+ if ($exp instanceof Variable || $exp instanceof ConstFetch) {
+ return '{var}';
+ }
+ throw new InvalidArgumentException('can\'t yet handle '.$exp->getType());
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function enterNode(Node $node)
+ {
+ if ($node instanceof Include_) {
+ $this->included[] = $node->expr;
+ }
+ }
+}

src/ComposerRequireChecker/UsedSymbolsLocator/LocateUsedSymbolsFromASTRoots.php

@@ -25,7 +25,7 @@ public function __invoke(Traversable $ASTs): array
  $astSymbols = [];
 
  foreach ($ASTs as $astRoot) {
- $traverser->traverse($astRoot);
+ $traverser->traverse($astRoot->getAst());
 
  $astSymbols[] = $collector->getCollectedSymbols();
  }