diff --git a/docs/usage.md b/docs/usage.md
index 3e0f36f47..06e2e7dac 100644
--- a/docs/usage.md
+++ b/docs/usage.md
@@ -94,6 +94,12 @@ within the `Reflector`s. The library comes bundled with the following
  * `AggregateSourceLocator` - a combination of multiple `SourceLocator`s which
     are hunted through in the given order to locate the source.
 
+ * `FileIteratorSourceLocator` - iterates all files in a given iterator
+    containing `SplFileInfo` instances.
+
+ * `DirectoriesSourceLocator` - iterates over all `.php` files in a list of
+   directories, and all their descendants.
+
 A `SourceLocator` is a callable, which when invoked must be given an
 `Identifier` (which describes a class/function/etc.). The `SourceLocator`
 should be written so that it returns a `Reflection` object directly.
@@ -172,6 +178,39 @@ $reflector = new ClassReflector(new SingleFileSourceLocator('path/to/file.php'))
 $classes = $reflector->getAllClasses();
 ```
 
+### Fetch reflections of all the classes in a directory
+
+```php
+<?php
+
+$singleDirectorySourceLocator = new SingleDirectorySourceLocator(new \FilesystemIterator('path/to/directory'));
+$reflector = new ClassReflector($singleDirectorySourceLocator);
+$classes = $reflector->getAllClasses();
+```
+
+### Fetch reflections of all the classes in a directory (including sub directories)
+
+```php
+<?php
+
+$rdi = new \RecursiveDirectoryIterator('path/to/directory');
+$singleDirectorySourceLocator = new SingleDirectorySourceLocator(new \RecursiveIteratorIterator($rdi));
+$reflector = new ClassReflector($singleDirectorySourceLocator);
+$classes = $reflector->getAllClasses();
+```
+
+### Fetch reflections of all the classes in multiple directories (including sub directories)
+
+```php
+<?php
+
+$directoriesToScan = ['path/to/directory1', 'path/to/directory2'];
+$multipleDirectoriesSourceLocator = new MultipleDirectoriesAggregateSourceLocator($directoriesToScan);
+$reflector = new ClassReflector($multipleDirectoriesSourceLocator);
+$classes = $reflector->getAllClasses();
+```
+
+
 ## Reflecting Functions
 
 The `FunctionReflector` is used to create Better Reflection `ReflectionFunction`
diff --git a/src/SourceLocator/Exception/InvalidDirectory.php b/src/SourceLocator/Exception/InvalidDirectory.php
new file mode 100644
index 000000000..dc0fd6e85
--- /dev/null
+++ b/src/SourceLocator/Exception/InvalidDirectory.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace BetterReflection\SourceLocator\Exception;
+
+class InvalidDirectory extends \RuntimeException
+{
+    /**
+     * @param string $nonDirectory
+     *
+     * @return InvalidDirectory
+     */
+    public static function fromNonDirectory($nonDirectory)
+    {
+        if (! file_exists($nonDirectory)) {
+            return new self(sprintf('"%s" does not exists', $nonDirectory));
+        }
+
+        return new self(sprintf('"%s" must be a directory, not a file', $nonDirectory));
+    }
+
+    /**
+     * @param mixed $nonStringValue
+     *
+     * @return InvalidDirectory
+     */
+    public static function fromNonStringValue($nonStringValue)
+    {
+        return new self(sprintf(
+            'Expected string, %s given',
+            is_object($nonStringValue) ? get_class($nonStringValue) : gettype($nonStringValue)
+        ));
+    }
+}
diff --git a/src/SourceLocator/Exception/InvalidFileInfo.php b/src/SourceLocator/Exception/InvalidFileInfo.php
new file mode 100644
index 000000000..441abe3f3
--- /dev/null
+++ b/src/SourceLocator/Exception/InvalidFileInfo.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace BetterReflection\SourceLocator\Exception;
+
+class InvalidFileInfo extends \RuntimeException
+{
+    /**
+     * @param mixed $nonSplFileInfo
+     *
+     * @return InvalidFileInfo
+     */
+    public static function fromNonSplFileInfo($nonSplFileInfo)
+    {
+        return new self(sprintf(
+            'Expected an iterator of SplFileInfo instances, %s given instead',
+            is_object($nonSplFileInfo) ? get_class($nonSplFileInfo) : gettype($nonSplFileInfo)
+        ));
+    }
+}
diff --git a/src/SourceLocator/Type/DirectoriesSourceLocator.php b/src/SourceLocator/Type/DirectoriesSourceLocator.php
new file mode 100644
index 000000000..d508f8a86
--- /dev/null
+++ b/src/SourceLocator/Type/DirectoriesSourceLocator.php
@@ -0,0 +1,65 @@
+<?php
+
+namespace BetterReflection\SourceLocator\Type;
+
+use BetterReflection\Identifier\Identifier;
+use BetterReflection\Identifier\IdentifierType;
+use BetterReflection\Reflector\Reflector;
+use BetterReflection\SourceLocator\Exception\InvalidDirectory;
+use BetterReflection\SourceLocator\Exception\InvalidFileInfo;
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
+
+/**
+ * This source locator loads all php files in an entire directory or multiple directories.
+ */
+class DirectoriesSourceLocator implements SourceLocator
+{
+    /**
+     * @var AggregateSourceLocator
+     */
+    private $aggregateSourceLocator;
+
+    /**
+     * @param string[] $directories directories to scan
+     *
+     * @throws InvalidDirectory
+     * @throws InvalidFileInfo
+     */
+    public function __construct(array $directories)
+    {
+        $this->aggregateSourceLocator = new AggregateSourceLocator(array_values(array_map(
+            function ($directory) {
+                if (! is_string($directory)) {
+                    throw InvalidDirectory::fromNonStringValue($directory);
+                }
+
+                if (! is_dir($directory)) {
+                    throw InvalidDirectory::fromNonDirectory($directory);
+                }
+
+                return new FileIteratorSourceLocator(new RecursiveIteratorIterator(new RecursiveDirectoryIterator(
+                    $directory,
+                    RecursiveDirectoryIterator::SKIP_DOTS
+                )));
+            },
+            $directories
+        )));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function locateIdentifier(Reflector $reflector, Identifier $identifier)
+    {
+        return $this->aggregateSourceLocator->locateIdentifier($reflector, $identifier);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function locateIdentifiersByType(Reflector $reflector, IdentifierType $identifierType)
+    {
+        return $this->aggregateSourceLocator->locateIdentifiersByType($reflector, $identifierType);
+    }
+}
diff --git a/src/SourceLocator/Type/FileIteratorSourceLocator.php b/src/SourceLocator/Type/FileIteratorSourceLocator.php
new file mode 100644
index 000000000..63824a4e4
--- /dev/null
+++ b/src/SourceLocator/Type/FileIteratorSourceLocator.php
@@ -0,0 +1,74 @@
+<?php
+
+namespace BetterReflection\SourceLocator\Type;
+
+use BetterReflection\Identifier\Identifier;
+use BetterReflection\Identifier\IdentifierType;
+use BetterReflection\Reflector\Reflector;
+use BetterReflection\SourceLocator\Exception\InvalidFileInfo;
+
+/**
+ * This source locator loads all php files from \FileSystemIterator
+ */
+class FileIteratorSourceLocator implements SourceLocator
+{
+    /**
+     * @var AggregateSourceLocator|null
+     */
+    private $aggregateSourceLocator;
+
+    /**
+     * @var \Iterator|\SplFileInfo[]
+     */
+    private $fileSystemIterator;
+
+    /**
+     * @param \Iterator|\SplFileInfo[] $fileInfoIterator note: only \SplFileInfo allowed in this iterator
+     *
+     * @throws InvalidFileInfo In case of iterator not contains only SplFileInfo
+     */
+    public function __construct(\Iterator $fileInfoIterator)
+    {
+        foreach ($fileInfoIterator as $fileInfo) {
+            if (! $fileInfo instanceof \SplFileInfo) {
+                throw InvalidFileInfo::fromNonSplFileInfo($fileInfo);
+            }
+        }
+
+        $this->fileSystemIterator = $fileInfoIterator;
+    }
+
+    /**
+     * @return AggregateSourceLocator
+     */
+    private function getAggregatedSourceLocator()
+    {
+        return $this->aggregateSourceLocator ?
+            $this->aggregateSourceLocator : new AggregateSourceLocator(array_values(array_filter(array_map(
+                function (\SplFileInfo $item) {
+                    if (! ($item->isFile() && pathinfo($item->getRealPath(), \PATHINFO_EXTENSION) === 'php')) {
+                        return null;
+                    }
+
+                    return new SingleFileSourceLocator($item->getRealPath());
+                },
+                iterator_to_array($this->fileSystemIterator)
+            ))));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function locateIdentifier(Reflector $reflector, Identifier $identifier)
+    {
+        return $this->getAggregatedSourceLocator()->locateIdentifier($reflector, $identifier);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function locateIdentifiersByType(Reflector $reflector, IdentifierType $identifierType)
+    {
+        return $this->getAggregatedSourceLocator()->locateIdentifiersByType($reflector, $identifierType);
+    }
+}
diff --git a/test/unit/Assets/DirectoryScannerAssets/Bar/Empty.php b/test/unit/Assets/DirectoryScannerAssets/Bar/Empty.php
new file mode 100644
index 000000000..03622f520
--- /dev/null
+++ b/test/unit/Assets/DirectoryScannerAssets/Bar/Empty.php
@@ -0,0 +1,4 @@
+<?php
+/**
+ * test assets for DirectoryScanner
+ */
diff --git a/test/unit/Assets/DirectoryScannerAssets/Bar/FooBar.php b/test/unit/Assets/DirectoryScannerAssets/Bar/FooBar.php
new file mode 100644
index 000000000..21839d52d
--- /dev/null
+++ b/test/unit/Assets/DirectoryScannerAssets/Bar/FooBar.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace BetterReflectionTest\Assets\DirectoryScannerAssets\Bar;
+
+class FooBar
+{
+}
diff --git a/test/unit/Assets/DirectoryScannerAssets/Bar/FooBar.tmp b/test/unit/Assets/DirectoryScannerAssets/Bar/FooBar.tmp
new file mode 100644
index 000000000..8816bf088
--- /dev/null
+++ b/test/unit/Assets/DirectoryScannerAssets/Bar/FooBar.tmp
@@ -0,0 +1 @@
+test assets for DirectoryScanner
diff --git a/test/unit/Assets/DirectoryScannerAssets/Foo.php b/test/unit/Assets/DirectoryScannerAssets/Foo.php
new file mode 100644
index 000000000..3491d43cb
--- /dev/null
+++ b/test/unit/Assets/DirectoryScannerAssets/Foo.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace BetterReflectionTest\Assets\DirectoryScannerAssets;
+
+class Foo
+{
+}
diff --git a/test/unit/Assets/DirectoryScannerAssets/Foo.tmp b/test/unit/Assets/DirectoryScannerAssets/Foo.tmp
new file mode 100644
index 000000000..8816bf088
--- /dev/null
+++ b/test/unit/Assets/DirectoryScannerAssets/Foo.tmp
@@ -0,0 +1 @@
+test assets for DirectoryScanner
diff --git a/test/unit/Assets/DirectoryScannerAssetsFoo/Bar/Empty.php b/test/unit/Assets/DirectoryScannerAssetsFoo/Bar/Empty.php
new file mode 100644
index 000000000..03622f520
--- /dev/null
+++ b/test/unit/Assets/DirectoryScannerAssetsFoo/Bar/Empty.php
@@ -0,0 +1,4 @@
+<?php
+/**
+ * test assets for DirectoryScanner
+ */
diff --git a/test/unit/Assets/DirectoryScannerAssetsFoo/Bar/FooBar.php b/test/unit/Assets/DirectoryScannerAssetsFoo/Bar/FooBar.php
new file mode 100644
index 000000000..a93b4becd
--- /dev/null
+++ b/test/unit/Assets/DirectoryScannerAssetsFoo/Bar/FooBar.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace BetterReflectionTest\Assets\DirectoryScannerAssetsFoo\Bar;
+
+class FooBar
+{
+
+}
diff --git a/test/unit/Assets/DirectoryScannerAssetsFoo/Bar/FooBar.tmp b/test/unit/Assets/DirectoryScannerAssetsFoo/Bar/FooBar.tmp
new file mode 100644
index 000000000..8816bf088
--- /dev/null
+++ b/test/unit/Assets/DirectoryScannerAssetsFoo/Bar/FooBar.tmp
@@ -0,0 +1 @@
+test assets for DirectoryScanner
diff --git a/test/unit/Assets/DirectoryScannerAssetsFoo/Foo.php b/test/unit/Assets/DirectoryScannerAssetsFoo/Foo.php
new file mode 100644
index 000000000..70771532e
--- /dev/null
+++ b/test/unit/Assets/DirectoryScannerAssetsFoo/Foo.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace BetterReflectionTest\Assets\DirectoryScannerAssetsFoo;
+
+class Foo
+{
+
+}
diff --git a/test/unit/Assets/DirectoryScannerAssetsFoo/Foo.tmp b/test/unit/Assets/DirectoryScannerAssetsFoo/Foo.tmp
new file mode 100644
index 000000000..8816bf088
--- /dev/null
+++ b/test/unit/Assets/DirectoryScannerAssetsFoo/Foo.tmp
@@ -0,0 +1 @@
+test assets for DirectoryScanner
diff --git a/test/unit/SourceLocator/Exception/InvalidDirectoryTest.php b/test/unit/SourceLocator/Exception/InvalidDirectoryTest.php
new file mode 100644
index 000000000..26d65a69e
--- /dev/null
+++ b/test/unit/SourceLocator/Exception/InvalidDirectoryTest.php
@@ -0,0 +1,59 @@
+<?php
+
+namespace BetterReflectionTest\SourceLocator\Exception;
+
+use BetterReflection\SourceLocator\Exception\InvalidDirectory;
+
+/**
+ * @covers \BetterReflection\SourceLocator\Exception\InvalidDirectory
+ */
+class InvalidDirectoryTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @dataProvider nonStringValuesProvider
+     *
+     * @param string $expectedMessage
+     * @param mixed $value
+     *
+     * @return void
+     */
+    public function testFromNonStringValue($expectedMessage, $value)
+    {
+        $exception = InvalidDirectory::fromNonStringValue($value);
+
+        self::assertInstanceOf(InvalidDirectory::class, $exception);
+        self::assertSame($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * @return string[][]|mixed[][]
+     */
+    public function nonStringValuesProvider()
+    {
+        return [
+            ['Expected string, stdClass given', new \stdClass()],
+            ['Expected string, boolean given', true],
+            ['Expected string, NULL given', null],
+            ['Expected string, integer given', 100],
+            ['Expected string, double given', 100.35],
+            ['Expected string, array given', []],
+        ];
+    }
+
+    public function testFromNonDirectoryWithNonExistingPath()
+    {
+        $directory = uniqid(sys_get_temp_dir() . 'non-existing', true);
+        $exception = InvalidDirectory::fromNonDirectory($directory);
+
+        self::assertInstanceOf(InvalidDirectory::class, $exception);
+        self::assertSame(sprintf('"%s" does not exists', $directory), $exception->getMessage());
+    }
+
+    public function testFromNonDirectoryWithFile()
+    {
+        $exception = InvalidDirectory::fromNonDirectory(__FILE__);
+
+        self::assertInstanceOf(InvalidDirectory::class, $exception);
+        self::assertSame(sprintf('"%s" must be a directory, not a file', __FILE__), $exception->getMessage());
+    }
+}
diff --git a/test/unit/SourceLocator/Exception/InvalidFileInfoTest.php b/test/unit/SourceLocator/Exception/InvalidFileInfoTest.php
new file mode 100644
index 000000000..db1265f78
--- /dev/null
+++ b/test/unit/SourceLocator/Exception/InvalidFileInfoTest.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace BetterReflectionTest\SourceLocator\Exception;
+
+use BetterReflection\SourceLocator\Exception\InvalidFileInfo;
+
+/**
+ * @covers \BetterReflection\SourceLocator\Exception\InvalidFileInfo
+ */
+class InvalidFileInfoTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @dataProvider nonSplFileInfoProvider
+     *
+     * @param string $expectedMessage
+     * @param mixed  $value
+     *
+     * @return void
+     */
+    public function testFromNonSplFileInfo($expectedMessage, $value)
+    {
+        $exception = InvalidFileInfo::fromNonSplFileInfo($value);
+
+        self::assertInstanceOf(InvalidFileInfo::class, $exception);
+        self::assertSame($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * @return string[][]|mixed[][]
+     */
+    public function nonSplFileInfoProvider()
+    {
+        return [
+            ['Expected an iterator of SplFileInfo instances, stdClass given instead', new \stdClass()],
+            ['Expected an iterator of SplFileInfo instances, boolean given instead', true],
+            ['Expected an iterator of SplFileInfo instances, NULL given instead', null],
+            ['Expected an iterator of SplFileInfo instances, integer given instead', 100],
+            ['Expected an iterator of SplFileInfo instances, double given instead', 100.35],
+            ['Expected an iterator of SplFileInfo instances, array given instead', []],
+        ];
+    }
+}
diff --git a/test/unit/SourceLocator/Type/DirectoriesSourceLocatorTest.php b/test/unit/SourceLocator/Type/DirectoriesSourceLocatorTest.php
new file mode 100644
index 000000000..6bae739ea
--- /dev/null
+++ b/test/unit/SourceLocator/Type/DirectoriesSourceLocatorTest.php
@@ -0,0 +1,103 @@
+<?php
+
+namespace BetterReflectionTest\SourceLocator\Type;
+
+use BetterReflection\Identifier\Identifier;
+use BetterReflection\Identifier\IdentifierType;
+use BetterReflection\Reflection\ReflectionClass;
+use BetterReflection\Reflector\ClassReflector;
+use BetterReflection\SourceLocator\Exception\InvalidDirectory;
+use BetterReflection\SourceLocator\Type\DirectoriesSourceLocator;
+use BetterReflectionTest\Assets\DirectoryScannerAssets;
+use BetterReflectionTest\Assets\DirectoryScannerAssetsFoo;
+
+/**
+ * @covers \BetterReflection\SourceLocator\Type\DirectoriesSourceLocator
+ */
+class DirectoriesSourceLocatorTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var DirectoriesSourceLocator
+     */
+    private $sourceLocator;
+
+    public function setUp()
+    {
+        $this->sourceLocator = new DirectoriesSourceLocator([
+            __DIR__ . '/../../Assets/DirectoryScannerAssets',
+            __DIR__ . '/../../Assets/DirectoryScannerAssetsFoo',
+        ]);
+    }
+
+    public function testScanDirectoryClasses()
+    {
+        $classes = $this->sourceLocator->locateIdentifiersByType(
+            new ClassReflector($this->sourceLocator),
+            new IdentifierType(IdentifierType::IDENTIFIER_CLASS)
+        );
+
+        self::assertCount(4, $classes);
+
+        $classNames = array_map(
+            function (ReflectionClass $reflectionClass) {
+                return $reflectionClass->getName();
+            },
+            $classes
+        );
+
+        sort($classNames);
+
+        self::assertEquals(DirectoryScannerAssetsFoo\Bar\FooBar::class, $classNames[0]);
+        self::assertEquals(DirectoryScannerAssetsFoo\Foo::class, $classNames[1]);
+        self::assertEquals(DirectoryScannerAssets\Bar\FooBar::class, $classNames[2]);
+        self::assertEquals(DirectoryScannerAssets\Foo::class, $classNames[3]);
+    }
+
+    public function testLocateIdentifier()
+    {
+        $class = $this->sourceLocator->locateIdentifier(
+            new ClassReflector($this->sourceLocator),
+            new Identifier(
+                DirectoryScannerAssets\Bar\FooBar::class,
+                new IdentifierType(IdentifierType::IDENTIFIER_CLASS)
+            )
+        );
+
+        self::assertInstanceOf(ReflectionClass::class, $class);
+        self::assertSame(DirectoryScannerAssets\Bar\FooBar::class, $class->getName());
+    }
+
+    /**
+     * @dataProvider invalidDirectoriesProvider
+     *
+     * @param array $directories
+     */
+    public function testInvalidDirectory(array $directories)
+    {
+        $this->expectException(InvalidDirectory::class);
+
+        new DirectoriesSourceLocator($directories);
+    }
+
+    public function invalidDirectoriesProvider()
+    {
+        $validDir = __DIR__ . '/../../Assets/DirectoryScannerAssets';
+
+        return [
+            [[__DIR__ . '/' . uniqid('nonExisting', true)]],
+            [[__FILE__]],
+            [[1]],
+            [[1.23]],
+            [[true]],
+            [[new \stdClass()]],
+            [[null]],
+            [[$validDir, __DIR__ . '/' . uniqid('nonExisting', true)]],
+            [[$validDir, __FILE__]],
+            [[$validDir, 1]],
+            [[$validDir, 1.23]],
+            [[$validDir, true]],
+            [[$validDir, new \stdClass()]],
+            [[$validDir, null]],
+        ];
+    }
+}
diff --git a/test/unit/SourceLocator/Type/FileIteratorSourceLocatorTest.php b/test/unit/SourceLocator/Type/FileIteratorSourceLocatorTest.php
new file mode 100644
index 000000000..460e444d6
--- /dev/null
+++ b/test/unit/SourceLocator/Type/FileIteratorSourceLocatorTest.php
@@ -0,0 +1,72 @@
+<?php
+
+namespace BetterReflectionTest\SourceLocator\Type;
+
+use BetterReflection\Identifier\Identifier;
+use BetterReflection\Identifier\IdentifierType;
+use BetterReflection\Reflection\ReflectionClass;
+use BetterReflection\Reflector\ClassReflector;
+use BetterReflection\SourceLocator\Type\FileIteratorSourceLocator;
+use BetterReflectionTest\Assets\DirectoryScannerAssets;
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
+
+/**
+ * @covers \BetterReflection\SourceLocator\Type\FileIteratorSourceLocator
+ */
+class FileIteratorSourceLocatorTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var FileIteratorSourceLocator
+     */
+    private $sourceLocator;
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setUp()
+    {
+        $this->sourceLocator = new FileIteratorSourceLocator(
+            new RecursiveIteratorIterator(new RecursiveDirectoryIterator(
+                __DIR__ . '/../../Assets/DirectoryScannerAssets',
+                RecursiveDirectoryIterator::SKIP_DOTS
+            ))
+        );
+    }
+
+    public function testScanDirectoryClasses()
+    {
+        $classes = $this->sourceLocator->locateIdentifiersByType(
+            new ClassReflector($this->sourceLocator),
+            new IdentifierType(IdentifierType::IDENTIFIER_CLASS)
+        );
+
+        self::assertCount(2, $classes);
+
+        $classNames = array_map(
+            function (ReflectionClass $reflectionClass) {
+                return $reflectionClass->getName();
+            },
+            $classes
+        );
+
+        sort($classNames);
+
+        self::assertEquals(DirectoryScannerAssets\Bar\FooBar::class, $classNames[0]);
+        self::assertEquals(DirectoryScannerAssets\Foo::class, $classNames[1]);
+    }
+
+    public function testLocateIdentifier()
+    {
+        $class = $this->sourceLocator->locateIdentifier(
+            new ClassReflector($this->sourceLocator),
+            new Identifier(
+                DirectoryScannerAssets\Bar\FooBar::class,
+                new IdentifierType(IdentifierType::IDENTIFIER_CLASS)
+            )
+        );
+
+        self::assertInstanceOf(ReflectionClass::class, $class);
+        self::assertSame(DirectoryScannerAssets\Bar\FooBar::class, $class->getName());
+    }
+}