2016-06-06 02:25:16 +02:00
|
|
|
<?php
|
2016-07-26 00:37:44 +02:00
|
|
|
namespace Psalm;
|
2016-06-06 02:25:16 +02:00
|
|
|
|
2019-07-05 22:24:00 +02:00
|
|
|
use function array_pop;
|
|
|
|
use function array_search;
|
|
|
|
use function array_splice;
|
|
|
|
use function count;
|
|
|
|
use function explode;
|
|
|
|
use function file_put_contents;
|
|
|
|
use function get_class;
|
|
|
|
use function memory_get_peak_usage;
|
|
|
|
use function microtime;
|
|
|
|
use function number_format;
|
2018-11-06 03:57:36 +01:00
|
|
|
use Psalm\Internal\Analyzer\ProjectAnalyzer;
|
2017-03-13 23:06:56 +01:00
|
|
|
use Psalm\Issue\CodeIssue;
|
2019-08-18 20:27:50 +02:00
|
|
|
use Psalm\Issue\UnusedPsalmSuppress;
|
2019-06-09 18:37:28 +02:00
|
|
|
use Psalm\Report\CheckstyleReport;
|
|
|
|
use Psalm\Report\CompactReport;
|
|
|
|
use Psalm\Report\ConsoleReport;
|
|
|
|
use Psalm\Report\EmacsReport;
|
|
|
|
use Psalm\Report\JsonReport;
|
|
|
|
use Psalm\Report\JsonSummaryReport;
|
|
|
|
use Psalm\Report\PylintReport;
|
2019-06-18 03:17:09 +02:00
|
|
|
use Psalm\Report\SonarqubeReport;
|
2019-06-09 18:37:28 +02:00
|
|
|
use Psalm\Report\TextReport;
|
|
|
|
use Psalm\Report\XmlReport;
|
2019-06-26 22:52:29 +02:00
|
|
|
use function sha1;
|
2019-07-05 22:24:00 +02:00
|
|
|
use function str_repeat;
|
|
|
|
use function str_replace;
|
|
|
|
use function usort;
|
2016-08-13 20:20:46 +02:00
|
|
|
|
2016-06-26 21:18:40 +02:00
|
|
|
class IssueBuffer
|
2016-06-06 02:25:16 +02:00
|
|
|
{
|
2017-07-25 22:11:02 +02:00
|
|
|
/**
|
2018-02-20 00:16:09 +01:00
|
|
|
* @var array<int, array{severity: string, line_from: int, line_to: int, type: string, message: string,
|
|
|
|
* file_name: string, file_path: string, snippet: string, from: int, to: int,
|
2018-11-09 06:46:13 +01:00
|
|
|
* snippet_from: int, snippet_to: int, column_from: int, column_to: int, selected_text: string}>
|
2017-07-25 22:11:02 +02:00
|
|
|
*/
|
|
|
|
protected static $issues_data = [];
|
|
|
|
|
2016-12-08 04:38:57 +01:00
|
|
|
/**
|
|
|
|
* @var array<int, array>
|
|
|
|
*/
|
2017-07-25 22:11:02 +02:00
|
|
|
protected static $console_issues = [];
|
2016-12-08 04:38:57 +01:00
|
|
|
|
2016-11-02 07:29:00 +01:00
|
|
|
/**
|
2017-01-14 07:24:27 +01:00
|
|
|
* @var int
|
2016-11-02 07:29:00 +01:00
|
|
|
*/
|
2017-01-14 07:24:27 +01:00
|
|
|
protected static $error_count = 0;
|
2016-11-01 05:39:41 +01:00
|
|
|
|
2016-11-02 07:29:00 +01:00
|
|
|
/**
|
|
|
|
* @var array<string, bool>
|
|
|
|
*/
|
2016-10-19 00:55:53 +02:00
|
|
|
protected static $emitted = [];
|
2016-06-21 01:30:38 +02:00
|
|
|
|
2017-03-13 23:06:56 +01:00
|
|
|
/** @var int */
|
|
|
|
protected static $recording_level = 0;
|
|
|
|
|
|
|
|
/** @var array<int, array<int, CodeIssue>> */
|
|
|
|
protected static $recorded_issues = [];
|
|
|
|
|
2019-08-18 20:27:50 +02:00
|
|
|
/**
|
|
|
|
* @var array<string, array<int, int>>
|
|
|
|
*/
|
|
|
|
protected static $unused_suppressions = [];
|
|
|
|
|
2019-08-18 21:34:32 +02:00
|
|
|
/**
|
|
|
|
* @var array<string, array<int, bool>>
|
|
|
|
*/
|
2019-09-16 17:58:42 +02:00
|
|
|
protected static $used_suppressions = [];
|
2019-08-18 21:34:32 +02:00
|
|
|
|
2016-11-02 07:29:00 +01:00
|
|
|
/**
|
2017-03-13 23:06:56 +01:00
|
|
|
* @param CodeIssue $e
|
2019-06-16 15:12:32 +02:00
|
|
|
* @param string[] $suppressed_issues
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2016-11-02 07:29:00 +01:00
|
|
|
* @return bool
|
|
|
|
*/
|
2017-03-13 23:06:56 +01:00
|
|
|
public static function accepts(CodeIssue $e, array $suppressed_issues = [])
|
2019-04-17 17:12:18 +02:00
|
|
|
{
|
|
|
|
if (self::isSuppressed($e, $suppressed_issues)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return self::add($e);
|
|
|
|
}
|
|
|
|
|
2019-08-18 20:27:50 +02:00
|
|
|
public static function addUnusedSuppression(string $file_path, int $offset, string $issue_type) : void
|
|
|
|
{
|
2019-09-16 17:58:42 +02:00
|
|
|
if (isset(self::$used_suppressions[$file_path][$offset])) {
|
2019-08-18 21:34:32 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-08-18 20:27:50 +02:00
|
|
|
if (!isset(self::$unused_suppressions[$file_path])) {
|
|
|
|
self::$unused_suppressions[$file_path] = [];
|
|
|
|
}
|
|
|
|
|
|
|
|
self::$unused_suppressions[$file_path][$offset] = $offset + \strlen($issue_type) - 1;
|
|
|
|
}
|
|
|
|
|
2019-04-17 17:12:18 +02:00
|
|
|
/**
|
|
|
|
* @param CodeIssue $e
|
2019-06-16 15:12:32 +02:00
|
|
|
* @param string[] $suppressed_issues
|
2019-04-17 17:12:18 +02:00
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public static function isSuppressed(CodeIssue $e, array $suppressed_issues = []) : bool
|
2016-06-06 02:25:16 +02:00
|
|
|
{
|
2016-06-10 00:08:25 +02:00
|
|
|
$config = Config::getInstance();
|
|
|
|
|
2016-07-26 21:00:40 +02:00
|
|
|
$fqcn_parts = explode('\\', get_class($e));
|
|
|
|
$issue_type = array_pop($fqcn_parts);
|
2019-08-18 20:27:50 +02:00
|
|
|
$file_path = $e->getFilePath();
|
2016-07-22 19:29:46 +02:00
|
|
|
|
2019-08-18 20:27:50 +02:00
|
|
|
if (!$config->reportIssueInFile($issue_type, $file_path)) {
|
2019-04-17 17:12:18 +02:00
|
|
|
return true;
|
2016-06-10 00:08:25 +02:00
|
|
|
}
|
|
|
|
|
2019-08-18 18:25:48 +02:00
|
|
|
$suppressed_issue_position = array_search($issue_type, $suppressed_issues);
|
|
|
|
|
|
|
|
if ($suppressed_issue_position !== false) {
|
2019-08-18 21:34:32 +02:00
|
|
|
if (\is_int($suppressed_issue_position)) {
|
2019-09-16 17:58:42 +02:00
|
|
|
self::$used_suppressions[$file_path][$suppressed_issue_position] = true;
|
2019-08-18 21:34:32 +02:00
|
|
|
}
|
|
|
|
|
2019-08-18 18:25:48 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
$parent_issue_type = Config::getParentIssueType($issue_type);
|
|
|
|
|
|
|
|
if ($parent_issue_type) {
|
|
|
|
$suppressed_issue_position = array_search($parent_issue_type, $suppressed_issues);
|
|
|
|
|
|
|
|
if ($suppressed_issue_position !== false) {
|
2019-08-18 21:34:32 +02:00
|
|
|
if (\is_int($suppressed_issue_position)) {
|
2019-09-16 17:58:42 +02:00
|
|
|
self::$used_suppressions[$file_path][$suppressed_issue_position] = true;
|
2019-08-18 21:34:32 +02:00
|
|
|
}
|
|
|
|
|
2019-08-18 18:25:48 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$reporting_level = $config->getReportingLevelForIssue($e);
|
2018-03-21 03:36:03 +01:00
|
|
|
|
2019-05-03 23:12:20 +02:00
|
|
|
if ($reporting_level === Config::REPORT_SUPPRESS) {
|
2019-04-17 17:12:18 +02:00
|
|
|
return true;
|
2018-05-11 06:07:41 +02:00
|
|
|
}
|
|
|
|
|
2019-02-10 21:01:10 +01:00
|
|
|
if ($e->getLocation()->getLineNumber() === -1) {
|
2019-04-17 17:12:18 +02:00
|
|
|
return true;
|
2019-02-10 21:01:10 +01:00
|
|
|
}
|
2018-03-18 21:39:34 +01:00
|
|
|
|
2017-03-13 23:06:56 +01:00
|
|
|
if (self::$recording_level > 0) {
|
|
|
|
self::$recorded_issues[self::$recording_level][] = $e;
|
2017-05-25 04:07:49 +02:00
|
|
|
|
2019-04-17 17:12:18 +02:00
|
|
|
return true;
|
2017-03-13 23:06:56 +01:00
|
|
|
}
|
|
|
|
|
2019-04-17 17:12:18 +02:00
|
|
|
return false;
|
2016-06-27 19:22:16 +02:00
|
|
|
}
|
|
|
|
|
2016-11-02 07:29:00 +01:00
|
|
|
/**
|
2017-03-13 23:06:56 +01:00
|
|
|
* @param CodeIssue $e
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2016-11-02 07:29:00 +01:00
|
|
|
* @throws Exception\CodeException
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
|
|
|
* @return bool
|
2016-11-02 07:29:00 +01:00
|
|
|
*/
|
2017-03-13 23:06:56 +01:00
|
|
|
public static function add(CodeIssue $e)
|
2016-06-27 19:22:16 +02:00
|
|
|
{
|
|
|
|
$config = Config::getInstance();
|
|
|
|
|
2016-07-26 21:00:40 +02:00
|
|
|
$fqcn_parts = explode('\\', get_class($e));
|
|
|
|
$issue_type = array_pop($fqcn_parts);
|
2016-06-17 23:34:52 +02:00
|
|
|
|
2018-11-11 18:01:14 +01:00
|
|
|
$project_analyzer = ProjectAnalyzer::getInstance();
|
2018-01-06 01:49:27 +01:00
|
|
|
|
2018-11-11 18:01:14 +01:00
|
|
|
if (!$project_analyzer->show_issues) {
|
2018-01-06 01:49:27 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-10-09 20:26:32 +02:00
|
|
|
if ($project_analyzer->getCodebase()->taint && $issue_type !== 'TaintedInput') {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-05-03 23:12:20 +02:00
|
|
|
$reporting_level = $config->getReportingLevelForIssue($e);
|
2018-03-18 22:26:28 +01:00
|
|
|
|
2016-12-04 01:11:30 +01:00
|
|
|
if ($reporting_level === Config::REPORT_SUPPRESS) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-02-13 21:10:50 +01:00
|
|
|
$emitted_key = $issue_type . '-' . $e->getShortLocation() . ':' . $e->getLocation()->getColumn();
|
|
|
|
|
2016-12-04 01:11:30 +01:00
|
|
|
if ($reporting_level === Config::REPORT_INFO) {
|
2019-02-13 21:10:50 +01:00
|
|
|
if (!self::alreadyEmitted($emitted_key)) {
|
2017-07-25 22:11:02 +02:00
|
|
|
self::$issues_data[] = $e->toArray(Config::REPORT_INFO);
|
2016-12-04 01:11:30 +01:00
|
|
|
}
|
2017-05-25 04:07:49 +02:00
|
|
|
|
2016-12-04 01:11:30 +01:00
|
|
|
return false;
|
2016-06-10 20:47:44 +02:00
|
|
|
}
|
|
|
|
|
2016-06-27 04:40:57 +02:00
|
|
|
if ($config->throw_exception) {
|
2019-05-17 00:36:36 +02:00
|
|
|
\Psalm\Internal\Analyzer\FileAnalyzer::clearCache();
|
|
|
|
|
2019-02-27 22:00:44 +01:00
|
|
|
throw new Exception\CodeException(
|
2019-02-27 22:16:19 +01:00
|
|
|
$issue_type
|
2019-05-27 16:07:56 +02:00
|
|
|
. ' - ' . $e->getShortLocationWithPrevious()
|
2019-02-27 22:16:19 +01:00
|
|
|
. ':' . $e->getLocation()->getColumn()
|
|
|
|
. ' - ' . $e->getMessage()
|
2019-02-27 22:00:44 +01:00
|
|
|
);
|
2016-06-27 04:40:57 +02:00
|
|
|
}
|
|
|
|
|
2019-02-13 21:10:50 +01:00
|
|
|
if (!self::alreadyEmitted($emitted_key)) {
|
2018-09-26 00:37:24 +02:00
|
|
|
++self::$error_count;
|
2017-07-25 22:11:02 +02:00
|
|
|
self::$issues_data[] = $e->toArray(Config::REPORT_ERROR);
|
2016-10-19 00:55:53 +02:00
|
|
|
}
|
2016-06-17 01:02:29 +02:00
|
|
|
|
2016-08-08 20:36:18 +02:00
|
|
|
return true;
|
2016-06-06 02:25:16 +02:00
|
|
|
}
|
2016-06-21 01:30:38 +02:00
|
|
|
|
2016-12-08 04:38:57 +01:00
|
|
|
/**
|
2018-09-26 00:37:24 +02:00
|
|
|
* @return array<int, array{severity: string, line_from: int, line_to: int, type: string, message: string,
|
|
|
|
* file_name: string, file_path: string, snippet: string, from: int, to: int, snippet_from: int, snippet_to: int,
|
2018-11-09 06:46:13 +01:00
|
|
|
* column_from: int, column_to: int, selected_text: string}>
|
2016-12-08 04:38:57 +01:00
|
|
|
*/
|
2017-07-25 22:11:02 +02:00
|
|
|
public static function getIssuesData()
|
2016-12-08 04:38:57 +01:00
|
|
|
{
|
2017-07-25 22:11:02 +02:00
|
|
|
return self::$issues_data;
|
2016-12-08 04:38:57 +01:00
|
|
|
}
|
|
|
|
|
2019-08-18 20:27:50 +02:00
|
|
|
/**
|
|
|
|
* @return array<string, array<int, int>>
|
|
|
|
*/
|
|
|
|
public static function getUnusedSuppressions() : array
|
|
|
|
{
|
|
|
|
return self::$unused_suppressions;
|
|
|
|
}
|
|
|
|
|
2019-09-16 17:58:42 +02:00
|
|
|
/**
|
|
|
|
* @return array<string, array<int, bool>>
|
|
|
|
*/
|
|
|
|
public static function getUsedSuppressions() : array
|
|
|
|
{
|
|
|
|
return self::$used_suppressions;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param array<string, array<int, int>> $unused_suppressions
|
|
|
|
*/
|
2019-08-18 20:27:50 +02:00
|
|
|
public static function addUnusedSuppressions(array $unused_suppressions) : void
|
|
|
|
{
|
|
|
|
self::$unused_suppressions += $unused_suppressions;
|
|
|
|
}
|
|
|
|
|
2019-09-16 17:58:42 +02:00
|
|
|
/**
|
|
|
|
* @param array<string, array<int, bool>> $used_suppressions
|
|
|
|
*/
|
|
|
|
public static function addUsedSuppressions(array $used_suppressions) : void
|
|
|
|
{
|
|
|
|
foreach ($used_suppressions as $file => $offsets) {
|
|
|
|
if (!isset(self::$used_suppressions[$file])) {
|
|
|
|
self::$used_suppressions[$file] = $offsets;
|
|
|
|
} else {
|
|
|
|
self::$used_suppressions[$file] += $offsets;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-18 20:27:50 +02:00
|
|
|
public static function processUnusedSuppressions(\Psalm\Internal\Provider\FileProvider $file_provider) : void
|
|
|
|
{
|
|
|
|
$config = Config::getInstance();
|
|
|
|
|
|
|
|
foreach (self::$unused_suppressions as $file_path => $offsets) {
|
|
|
|
if (!$offsets) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
$file_contents = $file_provider->getContents($file_path);
|
|
|
|
|
|
|
|
foreach ($offsets as $start => $end) {
|
2019-09-16 17:58:42 +02:00
|
|
|
if (isset(self::$used_suppressions[$file_path][$start])) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-08-18 20:27:50 +02:00
|
|
|
self::add(
|
|
|
|
new UnusedPsalmSuppress(
|
|
|
|
'This suppression is never used',
|
|
|
|
new CodeLocation\Raw(
|
|
|
|
$file_contents,
|
|
|
|
$file_path,
|
|
|
|
$config->shortenFileName($file_path),
|
|
|
|
$start,
|
|
|
|
$end
|
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-26 00:37:24 +02:00
|
|
|
/**
|
|
|
|
* @return int
|
|
|
|
*/
|
|
|
|
public static function getErrorCount()
|
|
|
|
{
|
|
|
|
return self::$error_count;
|
|
|
|
}
|
|
|
|
|
2016-12-08 04:38:57 +01:00
|
|
|
/**
|
2018-03-17 23:05:50 +01:00
|
|
|
* @param array<int, array{severity: string, line_from: int, line_to: int, type: string, message: string,
|
2017-07-25 22:11:02 +02:00
|
|
|
* file_name: string, file_path: string, snippet: string, from: int, to: int, snippet_from: int,
|
2018-02-20 00:16:09 +01:00
|
|
|
* snippet_to: int, column_from: int, column_to: int}> $issues_data
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2017-07-25 22:11:02 +02:00
|
|
|
* @return void
|
2016-12-08 04:38:57 +01:00
|
|
|
*/
|
2017-07-25 22:11:02 +02:00
|
|
|
public static function addIssues(array $issues_data)
|
2016-12-08 04:38:57 +01:00
|
|
|
{
|
2018-11-01 18:22:38 +01:00
|
|
|
foreach ($issues_data as $issue) {
|
2019-02-13 21:10:50 +01:00
|
|
|
$emitted_key = $issue['type']
|
|
|
|
. '-' . $issue['file_name']
|
2018-11-01 22:03:08 +01:00
|
|
|
. ':' . $issue['line_from']
|
2019-02-13 21:10:50 +01:00
|
|
|
. ':' . $issue['column_from'];
|
2018-11-01 18:22:38 +01:00
|
|
|
|
2019-02-13 21:10:50 +01:00
|
|
|
if (!self::alreadyEmitted($emitted_key)) {
|
2018-11-01 18:22:38 +01:00
|
|
|
self::$issues_data[] = $issue;
|
|
|
|
}
|
|
|
|
}
|
2016-12-08 04:38:57 +01:00
|
|
|
}
|
|
|
|
|
2016-11-02 07:29:00 +01:00
|
|
|
/**
|
2018-11-11 18:01:14 +01:00
|
|
|
* @param ProjectAnalyzer $project_analyzer
|
2018-10-30 15:32:20 +01:00
|
|
|
* @param bool $is_full
|
|
|
|
* @param float $start_time
|
|
|
|
* @param bool $add_stats
|
2018-11-09 06:46:13 +01:00
|
|
|
* @param array<string,array<string,array{o:int, s:array<int, string>}>> $issue_baseline
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2016-11-02 07:29:00 +01:00
|
|
|
* @return void
|
|
|
|
*/
|
2018-01-31 23:09:09 +01:00
|
|
|
public static function finish(
|
2018-11-11 18:01:14 +01:00
|
|
|
ProjectAnalyzer $project_analyzer,
|
2018-10-30 15:32:20 +01:00
|
|
|
bool $is_full,
|
|
|
|
float $start_time,
|
|
|
|
bool $add_stats = false,
|
|
|
|
array $issue_baseline = []
|
2018-01-31 23:09:09 +01:00
|
|
|
) {
|
2019-06-09 18:37:28 +02:00
|
|
|
if (!$project_analyzer->stdout_report_options) {
|
|
|
|
throw new \UnexpectedValueException('Cannot finish without stdout report options');
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($project_analyzer->stdout_report_options->format === Report::TYPE_CONSOLE) {
|
2018-04-16 20:05:37 +02:00
|
|
|
echo "\n";
|
|
|
|
}
|
2018-03-18 23:27:10 +01:00
|
|
|
|
2018-11-11 18:19:53 +01:00
|
|
|
$codebase = $project_analyzer->getCodebase();
|
|
|
|
|
2018-03-18 23:04:50 +01:00
|
|
|
$error_count = 0;
|
2018-03-18 23:27:10 +01:00
|
|
|
$info_count = 0;
|
2017-07-25 22:11:02 +02:00
|
|
|
|
|
|
|
if (self::$issues_data) {
|
2017-12-10 17:22:36 +01:00
|
|
|
usort(
|
|
|
|
self::$issues_data,
|
2019-09-18 20:21:06 +02:00
|
|
|
/**
|
|
|
|
* @param array{file_path: string, line_from: int, column_from: int} $d1
|
|
|
|
* @param array{file_path: string, line_from: int, column_from: int} $d2
|
|
|
|
*/
|
2019-07-05 22:24:00 +02:00
|
|
|
function (array $d1, array $d2) : int {
|
2017-12-10 17:22:36 +01:00
|
|
|
if ($d1['file_path'] === $d2['file_path']) {
|
2018-02-20 00:16:09 +01:00
|
|
|
if ($d1['line_from'] === $d2['line_from']) {
|
|
|
|
if ($d1['column_from'] === $d2['column_from']) {
|
2017-12-10 17:22:36 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-02-20 00:16:09 +01:00
|
|
|
return $d1['column_from'] > $d2['column_from'] ? 1 : -1;
|
2017-12-10 17:22:36 +01:00
|
|
|
}
|
|
|
|
|
2018-02-20 00:16:09 +01:00
|
|
|
return $d1['line_from'] > $d2['line_from'] ? 1 : -1;
|
2017-12-10 17:22:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return $d1['file_path'] > $d2['file_path'] ? 1 : -1;
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2018-10-30 15:32:20 +01:00
|
|
|
if (!empty($issue_baseline)) {
|
|
|
|
// Set severity for issues in baseline to INFO
|
|
|
|
foreach (self::$issues_data as $key => $issue_data) {
|
|
|
|
$file = $issue_data['file_name'];
|
2019-01-10 06:10:09 +01:00
|
|
|
$file = str_replace('\\', '/', $file);
|
2018-10-30 15:32:20 +01:00
|
|
|
$type = $issue_data['type'];
|
|
|
|
|
2018-11-09 06:46:13 +01:00
|
|
|
if (isset($issue_baseline[$file][$type]) && $issue_baseline[$file][$type]['o'] > 0) {
|
|
|
|
if ($issue_baseline[$file][$type]['o'] === count($issue_baseline[$file][$type]['s'])) {
|
2019-07-05 22:24:00 +02:00
|
|
|
$position = array_search(
|
|
|
|
$issue_data['selected_text'],
|
|
|
|
$issue_baseline[$file][$type]['s'],
|
|
|
|
true
|
|
|
|
);
|
2018-11-09 06:46:13 +01:00
|
|
|
|
|
|
|
if ($position !== false) {
|
|
|
|
$issue_data['severity'] = Config::REPORT_INFO;
|
|
|
|
array_splice($issue_baseline[$file][$type]['s'], $position, 1);
|
|
|
|
$issue_baseline[$file][$type]['o'] = $issue_baseline[$file][$type]['o'] - 1;
|
|
|
|
}
|
|
|
|
} else {
|
2018-11-09 17:38:40 +01:00
|
|
|
$issue_baseline[$file][$type]['s'] = [];
|
2018-11-09 06:46:13 +01:00
|
|
|
$issue_data['severity'] = Config::REPORT_INFO;
|
|
|
|
$issue_baseline[$file][$type]['o'] = $issue_baseline[$file][$type]['o'] - 1;
|
|
|
|
}
|
2018-10-30 15:32:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
self::$issues_data[$key] = $issue_data;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-08 17:18:48 +02:00
|
|
|
foreach (self::$issues_data as $issue_data) {
|
|
|
|
if ($issue_data['severity'] === Config::REPORT_ERROR) {
|
2018-03-18 23:04:50 +01:00
|
|
|
++$error_count;
|
2018-03-18 23:27:10 +01:00
|
|
|
} else {
|
|
|
|
++$info_count;
|
2017-07-25 22:11:02 +02:00
|
|
|
}
|
2017-09-08 17:18:48 +02:00
|
|
|
}
|
2017-07-25 22:11:02 +02:00
|
|
|
|
2018-06-04 16:19:20 +02:00
|
|
|
echo self::getOutput(
|
2019-06-09 18:37:28 +02:00
|
|
|
$project_analyzer->stdout_report_options,
|
2019-05-11 00:07:13 +02:00
|
|
|
$codebase->analyzer->getTotalTypeCoverage($codebase)
|
2018-06-04 16:19:20 +02:00
|
|
|
);
|
2017-09-27 00:18:24 +02:00
|
|
|
}
|
2018-03-18 23:27:10 +01:00
|
|
|
|
2019-03-23 17:47:46 +01:00
|
|
|
$after_analysis_hooks = $codebase->config->after_analysis;
|
|
|
|
|
|
|
|
if ($after_analysis_hooks) {
|
|
|
|
$source_control_info = null;
|
|
|
|
$build_info = (new \Psalm\Internal\ExecutionEnvironment\BuildInfoCollector($_SERVER))->collect();
|
|
|
|
|
|
|
|
try {
|
|
|
|
$source_control_info = (new \Psalm\Internal\ExecutionEnvironment\GitInfoCollector())->collect();
|
|
|
|
} catch (\RuntimeException $e) {
|
|
|
|
// do nothing
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($after_analysis_hooks as $after_analysis_hook) {
|
|
|
|
$after_analysis_hook::afterAnalysis(
|
|
|
|
$codebase,
|
|
|
|
self::$issues_data,
|
|
|
|
$build_info,
|
|
|
|
$source_control_info
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-09 18:37:28 +02:00
|
|
|
foreach ($project_analyzer->generated_report_options as $report_options) {
|
|
|
|
if (!$report_options->output_path) {
|
|
|
|
throw new \UnexpectedValueException('Output path should not be null here');
|
|
|
|
}
|
|
|
|
|
2017-09-27 00:18:24 +02:00
|
|
|
file_put_contents(
|
2019-06-09 18:37:28 +02:00
|
|
|
$report_options->output_path,
|
2019-05-11 00:07:13 +02:00
|
|
|
self::getOutput(
|
2019-06-09 18:37:28 +02:00
|
|
|
$report_options,
|
2019-05-11 00:07:13 +02:00
|
|
|
$codebase->analyzer->getTotalTypeCoverage($codebase)
|
|
|
|
)
|
2017-09-27 00:18:24 +02:00
|
|
|
);
|
2017-07-25 22:11:02 +02:00
|
|
|
}
|
|
|
|
|
2019-06-09 18:37:28 +02:00
|
|
|
if ($project_analyzer->stdout_report_options->format === Report::TYPE_CONSOLE) {
|
2018-04-16 20:05:37 +02:00
|
|
|
echo str_repeat('-', 30) . "\n";
|
2018-03-18 23:04:50 +01:00
|
|
|
|
2018-04-16 20:05:37 +02:00
|
|
|
if ($error_count) {
|
2019-07-05 22:24:00 +02:00
|
|
|
echo($project_analyzer->stdout_report_options->use_color
|
2018-04-16 20:05:37 +02:00
|
|
|
? "\e[0;31m" . $error_count . " errors\e[0m"
|
|
|
|
: $error_count . ' errors'
|
|
|
|
) . ' found' . "\n";
|
|
|
|
} else {
|
|
|
|
echo 'No errors found!' . "\n";
|
|
|
|
}
|
2018-03-18 23:27:10 +01:00
|
|
|
|
2019-06-09 18:37:28 +02:00
|
|
|
if ($info_count && $project_analyzer->stdout_report_options->show_info) {
|
2018-04-16 20:05:37 +02:00
|
|
|
echo str_repeat('-', 30) . "\n";
|
2018-03-18 23:27:10 +01:00
|
|
|
|
2018-04-16 20:05:37 +02:00
|
|
|
echo $info_count . ' other issues found.' . "\n"
|
|
|
|
. 'You can hide them with ' .
|
2019-06-09 18:37:28 +02:00
|
|
|
($project_analyzer->stdout_report_options->use_color
|
2018-04-16 20:05:37 +02:00
|
|
|
? "\e[30;48;5;195m--show-info=false\e[0m"
|
|
|
|
: '--show-info=false') . "\n";
|
|
|
|
}
|
2018-03-18 23:27:10 +01:00
|
|
|
|
2018-04-16 20:05:37 +02:00
|
|
|
echo str_repeat('-', 30) . "\n" . "\n";
|
2018-03-18 23:04:50 +01:00
|
|
|
|
2018-04-16 20:05:37 +02:00
|
|
|
if ($start_time) {
|
2018-10-10 22:05:06 +02:00
|
|
|
echo 'Checks took ' . number_format(microtime(true) - $start_time, 2) . ' seconds';
|
2018-04-16 20:05:37 +02:00
|
|
|
echo ' and used ' . number_format(memory_get_peak_usage() / (1024 * 1024), 3) . 'MB of memory' . "\n";
|
2018-01-31 22:08:52 +01:00
|
|
|
|
2019-03-23 14:50:47 +01:00
|
|
|
$analysis_summary = $codebase->analyzer->getTypeInferenceSummary($codebase);
|
|
|
|
echo $analysis_summary . "\n";
|
2018-01-31 23:09:09 +01:00
|
|
|
|
2018-04-16 20:05:37 +02:00
|
|
|
if ($add_stats) {
|
|
|
|
echo '-----------------' . "\n";
|
2018-11-06 03:57:36 +01:00
|
|
|
echo $codebase->analyzer->getNonMixedStats();
|
2018-04-16 20:05:37 +02:00
|
|
|
echo "\n";
|
|
|
|
}
|
2018-01-31 22:08:52 +01:00
|
|
|
}
|
2016-12-15 01:24:16 +01:00
|
|
|
}
|
|
|
|
|
2018-03-18 23:04:50 +01:00
|
|
|
if ($error_count) {
|
2016-06-21 01:30:38 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2016-10-07 06:58:08 +02:00
|
|
|
|
2016-11-06 05:59:29 +01:00
|
|
|
if ($is_full && $start_time) {
|
2018-11-11 18:19:53 +01:00
|
|
|
$codebase->file_reference_provider->removeDeletedFilesFromReferences();
|
2018-09-28 22:18:45 +02:00
|
|
|
|
2018-11-11 18:19:53 +01:00
|
|
|
if ($codebase->statements_provider->parser_cache_provider) {
|
|
|
|
$codebase->statements_provider->parser_cache_provider->processSuccessfulRun($start_time);
|
2018-09-28 22:18:45 +02:00
|
|
|
}
|
2016-10-07 06:58:08 +02:00
|
|
|
}
|
2016-06-21 01:30:38 +02:00
|
|
|
}
|
2016-10-19 00:55:53 +02:00
|
|
|
|
2016-10-30 17:46:18 +01:00
|
|
|
/**
|
2019-05-11 00:07:13 +02:00
|
|
|
* @param array{int, int} $mixed_counts
|
2017-09-08 17:18:48 +02:00
|
|
|
*
|
|
|
|
* @return string
|
|
|
|
*/
|
2019-05-11 00:07:13 +02:00
|
|
|
public static function getOutput(
|
2019-06-09 18:37:28 +02:00
|
|
|
\Psalm\Report\ReportOptions $report_options,
|
2019-05-11 00:07:13 +02:00
|
|
|
array $mixed_counts = [0, 0]
|
|
|
|
) {
|
|
|
|
$total_expression_count = $mixed_counts[0] + $mixed_counts[1];
|
|
|
|
$mixed_expression_count = $mixed_counts[0];
|
|
|
|
|
2019-06-09 18:37:28 +02:00
|
|
|
switch ($report_options->format) {
|
|
|
|
case Report::TYPE_COMPACT:
|
|
|
|
$output = new CompactReport(self::$issues_data, $report_options);
|
2018-12-09 21:47:20 +01:00
|
|
|
break;
|
|
|
|
|
2019-06-09 18:37:28 +02:00
|
|
|
case Report::TYPE_EMACS:
|
|
|
|
$output = new EmacsReport(self::$issues_data, $report_options);
|
2018-12-09 21:47:20 +01:00
|
|
|
break;
|
|
|
|
|
2019-06-09 18:37:28 +02:00
|
|
|
case Report::TYPE_TEXT:
|
|
|
|
$output = new TextReport(self::$issues_data, $report_options);
|
2018-12-18 19:13:21 +01:00
|
|
|
break;
|
|
|
|
|
2019-06-09 18:37:28 +02:00
|
|
|
case Report::TYPE_JSON:
|
|
|
|
$output = new JsonReport(self::$issues_data, $report_options);
|
2018-12-09 21:47:20 +01:00
|
|
|
break;
|
|
|
|
|
2019-06-09 18:37:28 +02:00
|
|
|
case Report::TYPE_JSON_SUMMARY:
|
|
|
|
$output = new JsonSummaryReport(
|
2019-05-11 00:07:13 +02:00
|
|
|
self::$issues_data,
|
2019-06-09 18:37:28 +02:00
|
|
|
$report_options,
|
2019-05-11 00:07:13 +02:00
|
|
|
$mixed_expression_count,
|
|
|
|
$total_expression_count
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
|
2019-06-18 03:17:09 +02:00
|
|
|
case Report::TYPE_SONARQUBE:
|
|
|
|
$output = new SonarqubeReport(self::$issues_data, $report_options);
|
|
|
|
break;
|
|
|
|
|
2019-06-09 18:37:28 +02:00
|
|
|
case Report::TYPE_PYLINT:
|
|
|
|
$output = new PylintReport(self::$issues_data, $report_options);
|
2018-12-09 21:47:20 +01:00
|
|
|
break;
|
|
|
|
|
2019-06-09 18:37:28 +02:00
|
|
|
case Report::TYPE_CHECKSTYLE:
|
|
|
|
$output = new CheckstyleReport(self::$issues_data, $report_options);
|
2019-05-08 20:26:52 +02:00
|
|
|
break;
|
|
|
|
|
2019-06-09 18:37:28 +02:00
|
|
|
case Report::TYPE_XML:
|
|
|
|
$output = new XmlReport(self::$issues_data, $report_options);
|
2018-12-09 21:47:20 +01:00
|
|
|
break;
|
|
|
|
|
2019-06-09 18:37:28 +02:00
|
|
|
case Report::TYPE_CONSOLE:
|
|
|
|
$output = new ConsoleReport(self::$issues_data, $report_options);
|
2018-12-09 21:47:20 +01:00
|
|
|
break;
|
2017-09-08 17:18:48 +02:00
|
|
|
}
|
|
|
|
|
2018-12-09 21:47:20 +01:00
|
|
|
return $output->create();
|
2017-09-08 17:18:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-10-30 17:46:18 +01:00
|
|
|
* @param string $message
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
2016-10-30 17:46:18 +01:00
|
|
|
* @return bool
|
|
|
|
*/
|
2016-10-19 00:55:53 +02:00
|
|
|
protected static function alreadyEmitted($message)
|
|
|
|
{
|
|
|
|
$sham = sha1($message);
|
|
|
|
|
|
|
|
if (isset(self::$emitted[$sham])) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
self::$emitted[$sham] = true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2016-12-08 21:57:18 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public static function clearCache()
|
|
|
|
{
|
2017-07-25 22:11:02 +02:00
|
|
|
self::$issues_data = [];
|
2016-12-08 21:57:18 +01:00
|
|
|
self::$emitted = [];
|
2017-01-14 07:24:27 +01:00
|
|
|
self::$error_count = 0;
|
2017-03-13 23:06:56 +01:00
|
|
|
self::$recording_level = 0;
|
|
|
|
self::$recorded_issues = [];
|
2017-07-25 22:11:02 +02:00
|
|
|
self::$console_issues = [];
|
2019-08-18 20:27:50 +02:00
|
|
|
self::$unused_suppressions = [];
|
2019-09-16 17:58:42 +02:00
|
|
|
self::$used_suppressions = [];
|
2017-03-13 23:06:56 +01:00
|
|
|
}
|
|
|
|
|
2018-10-17 21:52:26 +02:00
|
|
|
/**
|
|
|
|
* @return array<int, array{severity: string, line_from: int, line_to: int, type: string, message: string,
|
|
|
|
* file_name: string, file_path: string, snippet: string, from: int, to: int, snippet_from: int, snippet_to: int,
|
|
|
|
* column_from: int, column_to: int}>
|
|
|
|
*/
|
|
|
|
public static function clear()
|
|
|
|
{
|
|
|
|
$current_data = self::$issues_data;
|
|
|
|
self::$issues_data = [];
|
|
|
|
self::$emitted = [];
|
2019-07-05 22:24:00 +02:00
|
|
|
|
2018-10-17 21:52:26 +02:00
|
|
|
return $current_data;
|
|
|
|
}
|
|
|
|
|
2017-06-29 06:28:37 +02:00
|
|
|
/**
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public static function isRecording()
|
|
|
|
{
|
|
|
|
return self::$recording_level > 0;
|
|
|
|
}
|
|
|
|
|
2017-03-13 23:06:56 +01:00
|
|
|
/**
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public static function startRecording()
|
|
|
|
{
|
2017-05-27 02:05:57 +02:00
|
|
|
++self::$recording_level;
|
2017-03-13 23:06:56 +01:00
|
|
|
self::$recorded_issues[self::$recording_level] = [];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public static function stopRecording()
|
|
|
|
{
|
|
|
|
if (self::$recording_level === 0) {
|
|
|
|
throw new \UnexpectedValueException('Cannot stop recording - already at base level');
|
|
|
|
}
|
|
|
|
|
2017-05-27 02:05:57 +02:00
|
|
|
--self::$recording_level;
|
2017-03-13 23:06:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return array<int, CodeIssue>
|
|
|
|
*/
|
|
|
|
public static function clearRecordingLevel()
|
|
|
|
{
|
|
|
|
if (self::$recording_level === 0) {
|
|
|
|
throw new \UnexpectedValueException('Not currently recording');
|
|
|
|
}
|
|
|
|
|
|
|
|
$recorded_issues = self::$recorded_issues[self::$recording_level];
|
|
|
|
|
|
|
|
self::$recorded_issues[self::$recording_level] = [];
|
|
|
|
|
|
|
|
return $recorded_issues;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public static function bubbleUp(CodeIssue $e)
|
|
|
|
{
|
|
|
|
if (self::$recording_level === 0) {
|
|
|
|
self::add($e);
|
2017-05-25 04:07:49 +02:00
|
|
|
|
2017-03-13 23:06:56 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
self::$recorded_issues[self::$recording_level][] = $e;
|
2016-12-08 21:57:18 +01:00
|
|
|
}
|
2016-06-06 02:25:16 +02:00
|
|
|
}
|