Make sure new calls are also filtered by definedIn

src/Calls/NewCalls.php

@@ -88,10 +88,12 @@ public function processNode(Node $node, Scope $scope): array
 			}
 
 			foreach ($names as $name) {
+				$classRef = $type->getClassReflection();
+				$definedIn = $classRef ? $classRef->getFileName() : null;
 				$name .= self::CONSTRUCT;
 				$errors = array_merge(
 					$errors,
-					$this->disallowedCallsRuleErrors->get($node, $scope, $name, $type->getClassName() . self::CONSTRUCT, null, $this->disallowedCalls)
+					$this->disallowedCallsRuleErrors->get($node, $scope, $name, $type->getClassName() . self::CONSTRUCT, $definedIn, $this->disallowedCalls)
 				);
 			}
 		}

tests/Calls/MethodCallsDefinedInTest.php

@@ -59,11 +59,11 @@ public function testRule(): void
 				// expect this error message:
 				'Calling Waldo\Quux\Blade::andSorcery() is forbidden, because reasons [Waldo\Quux\Blade::andSorcery() matches *()]',
 				// on this line:
-				9,
+				10,
 			],
 			[
 				'Calling Waldo\Quux\Blade::server() is forbidden, because reasons [Waldo\Quux\Blade::server() matches *()]',
-				10,
+				11,
 			],
 		]);
 		// Based on the configuration above, no errors in this file:

tests/Calls/NewCallsDefinedInTest.php

@@ -0,0 +1,63 @@
+<?php
+declare(strict_types = 1);
+
+namespace Spaze\PHPStan\Rules\Disallowed\Calls;
+
+use PHPStan\File\FileHelper;
+use PHPStan\Rules\Rule;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\Testing\RuleTestCase;
+use Spaze\PHPStan\Rules\Disallowed\Allowed\Allowed;
+use Spaze\PHPStan\Rules\Disallowed\Allowed\AllowedPath;
+use Spaze\PHPStan\Rules\Disallowed\DisallowedCallFactory;
+use Spaze\PHPStan\Rules\Disallowed\File\FilePath;
+use Spaze\PHPStan\Rules\Disallowed\Formatter\Formatter;
+use Spaze\PHPStan\Rules\Disallowed\Identifier\Identifier;
+use Spaze\PHPStan\Rules\Disallowed\Normalizer\Normalizer;
+use Spaze\PHPStan\Rules\Disallowed\RuleErrors\DisallowedCallsRuleErrors;
+
+class NewCallsDefinedInTest extends RuleTestCase
+{
+
+	/**
+	 * @throws ShouldNotHappenException
+	 */
+	protected function getRule(): Rule
+	{
+		$normalizer = new Normalizer();
+		$formatter = new Formatter($normalizer);
+		$filePath = new FilePath(new FileHelper(__DIR__), __DIR__ . '/..');
+		$allowed = new Allowed($formatter, $normalizer, new AllowedPath($filePath));
+		return new NewCalls(
+			new DisallowedCallsRuleErrors($allowed, new Identifier(), $filePath),
+			new DisallowedCallFactory($formatter, $normalizer, $allowed),
+			[
+				[
+					'method' => '*',
+					'definedIn' => 'libs/Bl*',
+					'allowIn' => [
+						'src/disallowed-allow/*.php',
+						'src/*-allow/*.*',
+					],
+				],
+			]
+		);
+	}
+
+
+	public function testRule(): void
+	{
+		// Based on the configuration above, in this file:
+		$this->analyse([__DIR__ . '/../src/disallowed/methodCallsDefinedIn.php'], [
+			[
+				// expect this error message:
+				'Calling Waldo\Quux\Blade::__construct() is forbidden, because reasons [Waldo\Quux\Blade::__construct() matches *()]',
+				// on this line:
+				9,
+			],
+		]);
+		// Based on the configuration above, no errors in this file:
+		$this->analyse([__DIR__ . '/../src/disallowed-allow/methodCallsDefinedIn.php'], []);
+	}
+
+}

tests/libs/Option.php

@@ -7,6 +7,7 @@
 use EmptyIterator;
 use IteratorAggregate;
 use ArrayIterator;
+use Traversable;
 
 /**
  * @template T
@@ -62,7 +63,7 @@ public static function create()
 		return self::$instance;
 	}
 
-	public function getIterator()
+	public function getIterator(): Traversable
 	{
 		return new EmptyIterator();
 	}
@@ -104,7 +105,7 @@ public static function create($value)
 	}
 
 
-	public function getIterator()
+	public function getIterator(): Traversable
 	{
 		return new ArrayIterator([$this->value]);
 	}

tests/libs/TestException.php

@@ -0,0 +1,8 @@
+<?php
+declare(strict_types = 1);
+
+namespace Exceptions;
+
+class TestException extends \Exception
+{
+}

tests/src/disallowed/methodCallsDefinedIn.php

@@ -1,6 +1,7 @@
 <?php
 declare(strict_types = 1);
 
+use Exceptions\TestException;
 use Waldo\Foo\Bar;
 use Waldo\Quux\Blade;
 
@@ -16,3 +17,13 @@
 
 // allowed because it's a built-in function
 time();
+
+// allowed because it's a built-in class
+$exception = new Exception();
+$exception->getMessage();
+$exception->getPrevious();
+
+// allowed because it's defined elsewhere
+$testException = new TestException();
+$testException->getMessage();
+$testException->getPrevious();