Use Symbol in place of ImportedSymbol

This refactors the sniff to store symbol imports as instances of
`Symbol` rather than `ImportedSymbol`. `Symbol` is much more intelligent
and can keep track of the different parts of a symbol, rather than only
the imported alias. It can also identify full namespace paths even for
grouped imports.

More importantly, this marks each imported symbol as "used" directly as
soon as it is imported if it matches one of our ignored patterns. This
prevents issues where the pattern match would fail for symbols in an
import statement since `markSymbolUsed()` first tries to retrieve the
appropriate symbol from the records based on its top-level namespace.

That technique works fine for regular symbol use (eg: when looking to
see if `Foo\bar()` is imported, we need to look for a statement like
`use Lib\Classes\Foo`) but will fail for the symbol in the import
itself. In the latter case, if we mark it as "used" before it's stored
in the records, then we don't have to look it up at all.

Author: sirbrillig

ImportDetection/ImportedSymbol.php

@@ -3,7 +3,6 @@
 namespace ImportDetection\Sniffs\Imports;
 
 use ImportDetection\Symbol;
-use ImportDetection\ImportedSymbol;
 use ImportDetection\SniffHelpers;
 use ImportDetection\FileSymbolRecord;
 use PHP_CodeSniffer\Sniffs\Sniff;
@@ -22,13 +21,17 @@ public function process(File $phpcsFile, $stackPtr) {
 		$helper = new SniffHelpers();
 		$tokens = $phpcsFile->getTokens();
 		$token = $tokens[$stackPtr];
+		// Keep one set of symbol records per file
 		$this->symbolRecordsByFile[$phpcsFile->path] = $this->symbolRecordsByFile[$phpcsFile->path] ?? new FileSymbolRecord;
 		if ($token['type'] === 'T_WHITESPACE') {
 			$this->debug('found whitespace');
 			return $this->processEndOfFile($phpcsFile, $stackPtr);
 		}
 		if ($token['type'] === 'T_USE') {
 			$this->debug('found import');
+			if (in_array($helper->getImportType($phpcsFile, $stackPtr), ['function', 'const', 'class'])) {
+				$this->recordImportedSymbols($phpcsFile, $stackPtr);
+			}
 			return $this->processUse($phpcsFile, $stackPtr);
 		}
 		$symbol = $helper->getFullSymbol($phpcsFile, $stackPtr);
@@ -150,30 +153,37 @@ private function processUse(File $phpcsFile, $stackPtr) {
 		}
 	}
 
-	private function recordImportedSymbols(File $phpcsFile, int $stackPtr, array $importNames) {
-		foreach ($importNames as $symbol) {
-			$this->symbolRecordsByFile[$phpcsFile->path]->importedSymbolRecords[] = new ImportedSymbol($stackPtr, $symbol);
-		}
+	private function recordImportedSymbols(File $phpcsFile, int $stackPtr) {
+		$helper = new SniffHelpers();
+		$symbols = $helper->getImportedSymbolsFromImportStatement($phpcsFile, $stackPtr);
+		$this->debug('recording imported symbols: ' . implode(', ', array_map(function (Symbol $symbol): string {
+			return $symbol->getName();
+		}, $symbols)));
+		$symbols = array_map(function ($symbol) {
+			if ($this->isSymbolIgnored($symbol)) {
+				$this->debug('found ignored imported symbol: ' . $symbol->getName());
+				$symbol->markUsed();
+			}
+			return $symbol;
+		}, $symbols);
+		$this->symbolRecordsByFile[$phpcsFile->path]->addImportedSymbolRecords($symbols);
 	}
 
 	private function saveFunctionImport(File $phpcsFile, $stackPtr) {
 		$helper = new SniffHelpers();
 		$importNames = $helper->getImportNames($phpcsFile, $stackPtr);
-		$this->recordImportedSymbols($phpcsFile, $stackPtr, $importNames);
 		$this->symbolRecordsByFile[$phpcsFile->path]->addImportedFunctions($importNames);
 	}
 
 	private function saveConstImport(File $phpcsFile, $stackPtr) {
 		$helper = new SniffHelpers();
 		$importNames = $helper->getImportNames($phpcsFile, $stackPtr);
-		$this->recordImportedSymbols($phpcsFile, $stackPtr, $importNames);
 		$this->symbolRecordsByFile[$phpcsFile->path]->addImportedConsts($importNames);
 	}
 
 	private function saveClassImport(File $phpcsFile, $stackPtr) {
 		$helper = new SniffHelpers();
 		$importNames = $helper->getImportNames($phpcsFile, $stackPtr);
-		$this->recordImportedSymbols($phpcsFile, $stackPtr, $importNames);
 		$this->symbolRecordsByFile[$phpcsFile->path]->addImportedClasses($importNames);
 	}
 
@@ -228,16 +238,20 @@ private function isConstDefined(File $phpcsFile, string $functionName): bool {
 	}
 
 	private function markSymbolUsed(File $phpcsFile, Symbol $symbol) {
-		$record = $this->getSymbolRecord($phpcsFile, $symbol);
+		$record = $this->getRecordedImportedSymbolMatchingSymbol($phpcsFile, $symbol);
 		if (! $record) {
+			// Symbol records only exist for imported symbols, so if a used symbol
+			// has not been imported we don't need to mark anything.
+			$this->debug("ignoring marking symbol used since it was never imported: {$symbol->getName()}");
 			return;
 		}
 		$record->markUsed();
 	}
 
-	private function getSymbolRecord(File $phpcsFile, Symbol $symbol) {
+	private function getRecordedImportedSymbolMatchingSymbol(File $phpcsFile, Symbol $symbol) {
 		foreach ($this->symbolRecordsByFile[$phpcsFile->path]->importedSymbolRecords as $record) {
-			if ($record->getName() === $symbol->getTopLevelNamespace()) {
+			$this->debug("comparing symbol {$symbol->getTopLevelNamespace()} to alias {$record->getAlias()}");
+			if ($record->getAlias() === $symbol->getTopLevelNamespace()) {
 				return $record;
 			}
 		}
@@ -253,8 +267,9 @@ private function processEndOfFile(File $phpcsFile, int $stackPtr) {
 		// For each import, if the Symbol was not used, mark a warning
 		foreach ($this->symbolRecordsByFile[$phpcsFile->path]->importedSymbolRecords as $record) {
 			if (! $record->isUsed()) {
+				$this->debug("found unused symbol: {$record->getName()}");
 				$error = "Found unused symbol '{$record->getName()}'.";
-				$phpcsFile->addWarning($error, $record->getPtr(), 'Import');
+				$phpcsFile->addWarning($error, $record->getSymbolPosition(), 'Import');
 			}
 		}
 	}