2016-06-24 00:45:46 +02:00
|
|
|
<?php
|
2018-11-06 03:57:36 +01:00
|
|
|
namespace Psalm\Internal\Analyzer;
|
2016-08-13 20:20:46 +02:00
|
|
|
|
2019-06-01 17:53:32 +02:00
|
|
|
use PhpParser;
|
2017-07-25 22:11:02 +02:00
|
|
|
use Psalm\Aliases;
|
2018-11-06 03:57:36 +01:00
|
|
|
use Psalm\DocComment;
|
2016-11-02 07:29:00 +01:00
|
|
|
use Psalm\Exception\DocblockParseException;
|
2017-11-15 03:43:31 +01:00
|
|
|
use Psalm\Exception\IncorrectDocblockException;
|
2017-05-19 06:48:26 +02:00
|
|
|
use Psalm\Exception\TypeParseTreeException;
|
2018-01-21 18:44:46 +01:00
|
|
|
use Psalm\FileSource;
|
2018-11-06 03:57:36 +01:00
|
|
|
use Psalm\Internal\Scanner\ClassLikeDocblockComment;
|
|
|
|
use Psalm\Internal\Scanner\FunctionDocblockComment;
|
|
|
|
use Psalm\Internal\Scanner\VarDocblockComment;
|
2020-05-29 04:14:41 +02:00
|
|
|
use Psalm\Internal\Scanner\ParsedDocblock;
|
2018-11-18 18:41:47 +01:00
|
|
|
use Psalm\Internal\Type\ParseTree;
|
2020-05-28 20:31:09 +02:00
|
|
|
use Psalm\Internal\Type\ParseTreeCreator;
|
2020-05-14 01:29:59 +02:00
|
|
|
use Psalm\Internal\Type\TypeAlias;
|
2020-05-14 01:12:45 +02:00
|
|
|
use Psalm\Internal\Type\TypeParser;
|
|
|
|
use Psalm\Internal\Type\TypeTokenizer;
|
2016-08-13 20:20:46 +02:00
|
|
|
use Psalm\Type;
|
2020-05-30 22:54:16 +02:00
|
|
|
use function array_unique;
|
2019-06-26 22:52:29 +02:00
|
|
|
use function trim;
|
|
|
|
use function substr_count;
|
|
|
|
use function strlen;
|
|
|
|
use function preg_replace;
|
|
|
|
use function str_replace;
|
|
|
|
use function preg_match;
|
|
|
|
use function count;
|
|
|
|
use function reset;
|
|
|
|
use function preg_split;
|
|
|
|
use const PREG_SPLIT_DELIM_CAPTURE;
|
|
|
|
use const PREG_SPLIT_NO_EMPTY;
|
|
|
|
use function array_shift;
|
|
|
|
use function implode;
|
|
|
|
use function substr;
|
|
|
|
use function strpos;
|
|
|
|
use function strtolower;
|
|
|
|
use function in_array;
|
|
|
|
use function explode;
|
|
|
|
use function array_merge;
|
|
|
|
use const PREG_OFFSET_CAPTURE;
|
|
|
|
use function rtrim;
|
2016-06-24 00:45:46 +02:00
|
|
|
|
2018-12-02 00:37:49 +01:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*/
|
2018-11-06 03:57:36 +01:00
|
|
|
class CommentAnalyzer
|
2016-06-24 00:45:46 +02:00
|
|
|
{
|
2018-04-22 04:13:10 +02:00
|
|
|
const TYPE_REGEX = '(\??\\\?[\(\)A-Za-z0-9_&\<\.=,\>\[\]\-\{\}:|?\\\\]*|\$[a-zA-Z_0-9_]+)';
|
2016-06-24 00:45:46 +02:00
|
|
|
|
|
|
|
/**
|
2019-03-22 20:59:10 +01:00
|
|
|
* @param array<string, array<string, array{Type\Union}>>|null $template_type_map
|
2020-05-14 01:29:59 +02:00
|
|
|
* @param array<string, TypeAlias> $type_aliases
|
2017-05-27 02:16:18 +02:00
|
|
|
*
|
|
|
|
* @throws DocblockParseException if there was a problem parsing the docblock
|
|
|
|
*
|
2018-02-08 05:33:31 +01:00
|
|
|
* @return VarDocblockComment[]
|
2016-06-24 00:45:46 +02:00
|
|
|
*/
|
2016-11-02 07:29:00 +01:00
|
|
|
public static function getTypeFromComment(
|
2019-06-01 17:53:32 +02:00
|
|
|
PhpParser\Comment\Doc $comment,
|
2018-01-21 18:44:46 +01:00
|
|
|
FileSource $source,
|
2017-07-25 22:11:02 +02:00
|
|
|
Aliases $aliases,
|
2020-09-07 01:36:47 +02:00
|
|
|
?array $template_type_map = null,
|
2019-06-01 18:25:57 +02:00
|
|
|
?array $type_aliases = null
|
2020-09-04 22:26:33 +02:00
|
|
|
): array {
|
2019-06-26 22:26:14 +02:00
|
|
|
$parsed_docblock = DocComment::parsePreservingLength($comment);
|
|
|
|
|
|
|
|
return self::arrayToDocblocks(
|
|
|
|
$comment,
|
|
|
|
$parsed_docblock,
|
|
|
|
$source,
|
|
|
|
$aliases,
|
|
|
|
$template_type_map,
|
|
|
|
$type_aliases
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param array<string, array<string, array{Type\Union}>>|null $template_type_map
|
2020-05-14 01:29:59 +02:00
|
|
|
* @param array<string, TypeAlias> $type_aliases
|
2019-06-26 22:26:14 +02:00
|
|
|
*
|
|
|
|
* @return VarDocblockComment[]
|
|
|
|
*
|
|
|
|
* @throws DocblockParseException if there was a problem parsing the docblock
|
|
|
|
*/
|
|
|
|
public static function arrayToDocblocks(
|
|
|
|
PhpParser\Comment\Doc $comment,
|
2020-05-29 04:14:41 +02:00
|
|
|
ParsedDocblock $parsed_docblock,
|
2019-06-26 22:26:14 +02:00
|
|
|
FileSource $source,
|
|
|
|
Aliases $aliases,
|
2020-09-07 01:36:47 +02:00
|
|
|
?array $template_type_map = null,
|
2019-06-26 22:26:14 +02:00
|
|
|
?array $type_aliases = null
|
|
|
|
) : array {
|
2017-05-25 07:32:34 +02:00
|
|
|
$var_id = null;
|
2016-06-24 00:45:46 +02:00
|
|
|
|
2018-05-20 23:19:53 +02:00
|
|
|
$var_type_tokens = null;
|
2018-01-02 02:04:03 +01:00
|
|
|
$original_type = null;
|
2016-06-24 00:45:46 +02:00
|
|
|
|
2018-02-08 05:33:31 +01:00
|
|
|
$var_comments = [];
|
2016-06-24 00:45:46 +02:00
|
|
|
|
2019-06-01 22:57:33 +02:00
|
|
|
$comment_text = $comment->getText();
|
|
|
|
|
2020-09-20 14:56:49 +02:00
|
|
|
$var_line_number = $comment->getStartLine();
|
2019-06-01 17:53:32 +02:00
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->combined_tags['var'])) {
|
|
|
|
foreach ($parsed_docblock->combined_tags['var'] as $offset => $var_line) {
|
2017-03-02 04:27:52 +01:00
|
|
|
$var_line = trim($var_line);
|
2016-06-24 00:45:46 +02:00
|
|
|
|
2017-03-02 04:27:52 +01:00
|
|
|
if (!$var_line) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-06-01 18:25:57 +02:00
|
|
|
$type_start = null;
|
|
|
|
$type_end = null;
|
|
|
|
|
2019-02-01 02:21:20 +01:00
|
|
|
$line_parts = self::splitDocLine($var_line);
|
2017-03-02 04:27:52 +01:00
|
|
|
|
2020-09-20 14:56:49 +02:00
|
|
|
$line_number = $comment->getStartLine() + substr_count($comment_text, "\n", 0, $offset);
|
2019-06-01 22:57:33 +02:00
|
|
|
|
2017-03-02 04:27:52 +01:00
|
|
|
if ($line_parts && $line_parts[0]) {
|
2020-09-20 14:56:49 +02:00
|
|
|
$type_start = $offset + $comment->getStartFilePos();
|
2019-06-02 00:44:59 +02:00
|
|
|
$type_end = $type_start + strlen($line_parts[0]);
|
|
|
|
|
2020-04-03 20:56:11 +02:00
|
|
|
$line_parts[0] = self::sanitizeDocblockType($line_parts[0]);
|
2019-06-02 00:44:59 +02:00
|
|
|
|
2019-06-03 21:46:25 +02:00
|
|
|
if ($line_parts[0] === ''
|
|
|
|
|| ($line_parts[0][0] === '$'
|
|
|
|
&& !preg_match('/^\$this(\||$)/', $line_parts[0]))
|
|
|
|
) {
|
2017-11-15 03:43:31 +01:00
|
|
|
throw new IncorrectDocblockException('Misplaced variable');
|
|
|
|
}
|
|
|
|
|
2018-04-05 23:18:49 +02:00
|
|
|
try {
|
2020-05-14 01:12:45 +02:00
|
|
|
$var_type_tokens = TypeTokenizer::getFullyQualifiedTokens(
|
2019-06-02 00:44:59 +02:00
|
|
|
$line_parts[0],
|
2018-04-05 23:18:49 +02:00
|
|
|
$aliases,
|
2018-12-18 05:29:27 +01:00
|
|
|
$template_type_map,
|
2018-07-15 23:23:17 +02:00
|
|
|
$type_aliases
|
2018-04-05 23:18:49 +02:00
|
|
|
);
|
|
|
|
} catch (TypeParseTreeException $e) {
|
|
|
|
throw new DocblockParseException($line_parts[0] . ' is not a valid type');
|
|
|
|
}
|
2017-03-02 04:27:52 +01:00
|
|
|
|
2018-01-02 02:04:03 +01:00
|
|
|
$original_type = $line_parts[0];
|
|
|
|
|
2017-03-02 04:27:52 +01:00
|
|
|
$var_line_number = $line_number;
|
|
|
|
|
|
|
|
if (count($line_parts) > 1 && $line_parts[1][0] === '$') {
|
2017-05-25 07:32:34 +02:00
|
|
|
$var_id = $line_parts[1];
|
2017-03-02 04:27:52 +01:00
|
|
|
}
|
2018-02-08 05:33:31 +01:00
|
|
|
}
|
2017-03-02 04:27:52 +01:00
|
|
|
|
2018-05-20 23:19:53 +02:00
|
|
|
if (!$var_type_tokens || !$original_type) {
|
2018-02-08 05:33:31 +01:00
|
|
|
continue;
|
2016-06-24 00:45:46 +02:00
|
|
|
}
|
|
|
|
|
2018-02-08 05:33:31 +01:00
|
|
|
try {
|
2020-05-15 06:15:48 +02:00
|
|
|
$defined_type = TypeParser::parseTokens(
|
|
|
|
$var_type_tokens,
|
|
|
|
null,
|
|
|
|
$template_type_map ?: [],
|
|
|
|
$type_aliases ?: []
|
|
|
|
);
|
2018-02-08 05:33:31 +01:00
|
|
|
} catch (TypeParseTreeException $e) {
|
2019-06-01 17:53:32 +02:00
|
|
|
throw new DocblockParseException(
|
2019-06-23 05:30:40 +02:00
|
|
|
$line_parts[0] .
|
2019-06-01 17:53:32 +02:00
|
|
|
' is not a valid type' .
|
|
|
|
' (from ' .
|
|
|
|
$source->getFilePath() .
|
|
|
|
':' .
|
2020-09-20 14:56:49 +02:00
|
|
|
$comment->getStartLine() .
|
2019-06-01 17:53:32 +02:00
|
|
|
')'
|
|
|
|
);
|
2018-02-08 05:33:31 +01:00
|
|
|
}
|
2017-05-25 07:32:34 +02:00
|
|
|
|
2018-02-08 05:33:31 +01:00
|
|
|
$defined_type->setFromDocblock();
|
2016-06-24 00:45:46 +02:00
|
|
|
|
2018-02-08 05:33:31 +01:00
|
|
|
$var_comment = new VarDocblockComment();
|
|
|
|
$var_comment->type = $defined_type;
|
|
|
|
$var_comment->original_type = $original_type;
|
|
|
|
$var_comment->var_id = $var_id;
|
|
|
|
$var_comment->line_number = $var_line_number;
|
2019-06-01 18:25:57 +02:00
|
|
|
$var_comment->type_start = $type_start;
|
|
|
|
$var_comment->type_end = $type_end;
|
2019-05-15 00:27:27 +02:00
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
self::decorateVarDocblockComment($var_comment, $parsed_docblock);
|
2017-02-04 04:07:14 +01:00
|
|
|
|
2018-02-08 05:33:31 +01:00
|
|
|
$var_comments[] = $var_comment;
|
|
|
|
}
|
|
|
|
}
|
2016-06-24 00:45:46 +02:00
|
|
|
|
2019-08-11 22:01:37 +02:00
|
|
|
if (!$var_comments
|
2020-05-29 04:14:41 +02:00
|
|
|
&& (isset($parsed_docblock->tags['deprecated'])
|
|
|
|
|| isset($parsed_docblock->tags['internal'])
|
|
|
|
|| isset($parsed_docblock->tags['readonly'])
|
|
|
|
|| isset($parsed_docblock->tags['psalm-readonly'])
|
|
|
|
|| isset($parsed_docblock->tags['psalm-readonly-allow-private-mutation'])
|
2020-06-21 17:43:08 +02:00
|
|
|
|| isset($parsed_docblock->tags['psalm-taint-escape'])
|
2020-05-29 04:14:41 +02:00
|
|
|
|| isset($parsed_docblock->tags['psalm-internal']))
|
2019-08-11 22:01:37 +02:00
|
|
|
) {
|
|
|
|
$var_comment = new VarDocblockComment();
|
2020-05-29 04:14:41 +02:00
|
|
|
|
|
|
|
self::decorateVarDocblockComment($var_comment, $parsed_docblock);
|
2019-08-11 22:01:37 +02:00
|
|
|
|
|
|
|
$var_comments[] = $var_comment;
|
|
|
|
}
|
|
|
|
|
2018-02-08 05:33:31 +01:00
|
|
|
return $var_comments;
|
2016-06-24 00:45:46 +02:00
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
private static function decorateVarDocblockComment(
|
|
|
|
VarDocblockComment $var_comment,
|
|
|
|
ParsedDocblock $parsed_docblock
|
|
|
|
) : void {
|
|
|
|
$var_comment->deprecated = isset($parsed_docblock->tags['deprecated']);
|
|
|
|
$var_comment->internal = isset($parsed_docblock->tags['internal']);
|
|
|
|
$var_comment->readonly = isset($parsed_docblock->tags['readonly'])
|
|
|
|
|| isset($parsed_docblock->tags['psalm-readonly'])
|
|
|
|
|| isset($parsed_docblock->tags['psalm-readonly-allow-private-mutation']);
|
|
|
|
|
|
|
|
$var_comment->allow_private_mutation
|
|
|
|
= isset($parsed_docblock->tags['psalm-allow-private-mutation'])
|
|
|
|
|| isset($parsed_docblock->tags['psalm-readonly-allow-private-mutation']);
|
|
|
|
|
2020-06-21 17:43:08 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-taint-escape'])) {
|
|
|
|
foreach ($parsed_docblock->tags['psalm-taint-escape'] as $param) {
|
2020-05-29 04:14:41 +02:00
|
|
|
$param = trim($param);
|
|
|
|
$var_comment->removed_taints[] = $param;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isset($parsed_docblock->tags['psalm-internal'])) {
|
|
|
|
$psalm_internal = reset($parsed_docblock->tags['psalm-internal']);
|
|
|
|
|
|
|
|
if (!$psalm_internal) {
|
|
|
|
throw new DocblockParseException('psalm-internal annotation used without specifying namespace');
|
|
|
|
}
|
|
|
|
|
|
|
|
$var_comment->psalm_internal = reset($parsed_docblock->tags['psalm-internal']);
|
2020-07-26 16:47:48 +02:00
|
|
|
$var_comment->internal = true;
|
2020-05-29 04:14:41 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-23 19:52:31 +02:00
|
|
|
/**
|
|
|
|
* @psalm-pure
|
|
|
|
*/
|
2020-04-03 20:56:11 +02:00
|
|
|
private static function sanitizeDocblockType(string $docblock_type) : string
|
|
|
|
{
|
|
|
|
$docblock_type = preg_replace('@^[ \t]*\*@m', '', $docblock_type);
|
|
|
|
$docblock_type = preg_replace('/,\n\s+\}/', '}', $docblock_type);
|
|
|
|
return str_replace("\n", '', $docblock_type);
|
|
|
|
}
|
|
|
|
|
2018-07-15 23:23:17 +02:00
|
|
|
/**
|
2020-05-14 01:29:59 +02:00
|
|
|
* @param array<string, TypeAlias> $type_aliases
|
2018-07-15 23:23:17 +02:00
|
|
|
*
|
2020-05-14 06:41:50 +02:00
|
|
|
* @return array<string, TypeAlias\InlineTypeAlias>
|
2020-09-04 22:26:33 +02:00
|
|
|
*
|
|
|
|
* @throws DocblockParseException if there was a problem parsing the docblock
|
2018-07-15 23:23:17 +02:00
|
|
|
*/
|
|
|
|
public static function getTypeAliasesFromComment(
|
2019-06-01 17:53:32 +02:00
|
|
|
PhpParser\Comment\Doc $comment,
|
2018-07-15 23:23:17 +02:00
|
|
|
Aliases $aliases,
|
2020-06-07 18:00:55 +02:00
|
|
|
?array $type_aliases,
|
|
|
|
?string $self_fqcln
|
2020-09-04 22:26:33 +02:00
|
|
|
): array {
|
2019-06-26 22:26:14 +02:00
|
|
|
$parsed_docblock = DocComment::parsePreservingLength($comment);
|
2018-07-15 23:23:17 +02:00
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (!isset($parsed_docblock->tags['psalm-type'])) {
|
2018-07-15 23:23:17 +02:00
|
|
|
return [];
|
|
|
|
}
|
|
|
|
|
|
|
|
return self::getTypeAliasesFromCommentLines(
|
2020-05-29 04:14:41 +02:00
|
|
|
$parsed_docblock->tags['psalm-type'],
|
2018-07-15 23:23:17 +02:00
|
|
|
$aliases,
|
2020-06-07 18:00:55 +02:00
|
|
|
$type_aliases,
|
|
|
|
$self_fqcln
|
2018-07-15 23:23:17 +02:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param array<string> $type_alias_comment_lines
|
2020-05-14 01:29:59 +02:00
|
|
|
* @param array<string, TypeAlias> $type_aliases
|
2018-07-15 23:23:17 +02:00
|
|
|
*
|
2020-05-14 06:41:50 +02:00
|
|
|
* @return array<string, TypeAlias\InlineTypeAlias>
|
2020-09-04 22:26:33 +02:00
|
|
|
*
|
|
|
|
* @throws DocblockParseException if there was a problem parsing the docblock
|
2018-07-15 23:23:17 +02:00
|
|
|
*/
|
|
|
|
private static function getTypeAliasesFromCommentLines(
|
|
|
|
array $type_alias_comment_lines,
|
|
|
|
Aliases $aliases,
|
2020-06-07 18:00:55 +02:00
|
|
|
?array $type_aliases,
|
|
|
|
?string $self_fqcln
|
2020-09-04 22:26:33 +02:00
|
|
|
): array {
|
2018-07-15 23:23:17 +02:00
|
|
|
$type_alias_tokens = [];
|
|
|
|
|
|
|
|
foreach ($type_alias_comment_lines as $var_line) {
|
|
|
|
$var_line = trim($var_line);
|
|
|
|
|
|
|
|
if (!$var_line) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-06-02 00:44:59 +02:00
|
|
|
$var_line = preg_replace('/[ \t]+/', ' ', preg_replace('@^[ \t]*\*@m', '', $var_line));
|
2020-03-05 18:31:58 +01:00
|
|
|
$var_line = preg_replace('/,\n\s+\}/', '}', $var_line);
|
|
|
|
$var_line = str_replace("\n", '', $var_line);
|
2018-07-15 23:23:17 +02:00
|
|
|
|
|
|
|
$var_line_parts = preg_split('/( |=)/', $var_line, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
|
|
|
|
|
2018-12-19 22:15:19 +01:00
|
|
|
if (!$var_line_parts) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-07-15 23:23:17 +02:00
|
|
|
$type_alias = array_shift($var_line_parts);
|
|
|
|
|
|
|
|
if (!isset($var_line_parts[0])) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($var_line_parts[0] === ' ') {
|
|
|
|
array_shift($var_line_parts);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($var_line_parts[0] === '=') {
|
|
|
|
array_shift($var_line_parts);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!isset($var_line_parts[0])) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($var_line_parts[0] === ' ') {
|
|
|
|
array_shift($var_line_parts);
|
|
|
|
}
|
|
|
|
|
2019-06-01 22:57:33 +02:00
|
|
|
$type_string = str_replace("\n", '', implode('', $var_line_parts));
|
2018-07-15 23:23:17 +02:00
|
|
|
|
2019-06-16 18:45:02 +02:00
|
|
|
$type_string = preg_replace('/>[^>^\}]*$/', '>', $type_string);
|
|
|
|
$type_string = preg_replace('/\}[^>^\}]*$/', '}', $type_string);
|
|
|
|
|
2018-07-15 23:23:17 +02:00
|
|
|
try {
|
2020-05-14 01:12:45 +02:00
|
|
|
$type_tokens = TypeTokenizer::getFullyQualifiedTokens(
|
2018-07-15 23:23:17 +02:00
|
|
|
$type_string,
|
|
|
|
$aliases,
|
|
|
|
null,
|
2020-06-07 18:00:55 +02:00
|
|
|
$type_alias_tokens + $type_aliases,
|
|
|
|
$self_fqcln
|
2018-07-15 23:23:17 +02:00
|
|
|
);
|
|
|
|
} catch (TypeParseTreeException $e) {
|
|
|
|
throw new DocblockParseException($type_string . ' is not a valid type');
|
|
|
|
}
|
|
|
|
|
2020-05-14 06:41:50 +02:00
|
|
|
$type_alias_tokens[$type_alias] = new TypeAlias\InlineTypeAlias($type_tokens);
|
2018-07-15 23:23:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return $type_alias_tokens;
|
|
|
|
}
|
|
|
|
|
2016-10-14 06:53:43 +02:00
|
|
|
/**
|
2017-05-27 02:16:18 +02:00
|
|
|
* @throws DocblockParseException if there was a problem parsing the docblock
|
2016-10-14 06:53:43 +02:00
|
|
|
*/
|
2020-09-04 22:26:33 +02:00
|
|
|
public static function extractFunctionDocblockInfo(PhpParser\Comment\Doc $comment): FunctionDocblockComment
|
2018-07-22 04:55:16 +02:00
|
|
|
{
|
2019-06-26 22:26:14 +02:00
|
|
|
$parsed_docblock = DocComment::parsePreservingLength($comment);
|
2016-06-24 00:45:46 +02:00
|
|
|
|
2019-06-01 22:57:33 +02:00
|
|
|
$comment_text = $comment->getText();
|
|
|
|
|
2016-11-13 05:59:31 +01:00
|
|
|
$info = new FunctionDocblockComment();
|
2016-06-24 00:45:46 +02:00
|
|
|
|
2020-05-30 22:54:16 +02:00
|
|
|
self::checkDuplicatedTags($parsed_docblock);
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->combined_tags['return'])) {
|
2019-06-01 19:02:20 +02:00
|
|
|
self::extractReturnType(
|
|
|
|
$comment,
|
2020-05-29 04:14:41 +02:00
|
|
|
$parsed_docblock->combined_tags['return'],
|
2019-06-01 19:02:20 +02:00
|
|
|
$info
|
|
|
|
);
|
2016-06-24 00:45:46 +02:00
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->combined_tags['param'])) {
|
|
|
|
foreach ($parsed_docblock->combined_tags['param'] as $offset => $param) {
|
2019-02-01 02:21:20 +01:00
|
|
|
$line_parts = self::splitDocLine($param);
|
2016-06-24 00:45:46 +02:00
|
|
|
|
2017-05-30 05:21:46 +02:00
|
|
|
if (count($line_parts) === 1 && isset($line_parts[0][0]) && $line_parts[0][0] === '$') {
|
2018-03-30 23:46:12 +02:00
|
|
|
continue;
|
2017-01-16 05:49:58 +01:00
|
|
|
}
|
|
|
|
|
2016-12-25 12:32:21 +01:00
|
|
|
if (count($line_parts) > 1) {
|
2019-05-24 08:12:58 +02:00
|
|
|
if (preg_match('/^&?(\.\.\.)?&?\$[A-Za-z0-9_]+,?$/', $line_parts[1])
|
2017-01-15 16:58:44 +01:00
|
|
|
&& $line_parts[0][0] !== '{'
|
2016-12-25 12:32:21 +01:00
|
|
|
) {
|
2019-04-09 20:23:48 +02:00
|
|
|
$line_parts[1] = str_replace('&', '', $line_parts[1]);
|
2016-12-25 12:32:21 +01:00
|
|
|
|
2017-01-28 08:37:52 +01:00
|
|
|
$line_parts[1] = preg_replace('/,$/', '', $line_parts[1]);
|
|
|
|
|
2020-09-20 14:56:49 +02:00
|
|
|
$start = $offset + $comment->getStartFilePos();
|
2019-06-01 22:57:33 +02:00
|
|
|
$end = $start + strlen($line_parts[0]);
|
|
|
|
|
2020-04-03 20:56:11 +02:00
|
|
|
$line_parts[0] = self::sanitizeDocblockType($line_parts[0]);
|
2019-06-02 00:44:59 +02:00
|
|
|
|
2019-06-03 21:46:25 +02:00
|
|
|
if ($line_parts[0] === ''
|
|
|
|
|| ($line_parts[0][0] === '$'
|
|
|
|
&& !preg_match('/^\$this(\||$)/', $line_parts[0]))
|
|
|
|
) {
|
2019-06-02 00:44:59 +02:00
|
|
|
throw new IncorrectDocblockException('Misplaced variable');
|
|
|
|
}
|
|
|
|
|
2016-12-25 12:32:21 +01:00
|
|
|
$info->params[] = [
|
2019-06-01 22:57:33 +02:00
|
|
|
'name' => trim($line_parts[1]),
|
2019-06-02 00:44:59 +02:00
|
|
|
'type' => $line_parts[0],
|
2020-09-20 14:56:49 +02:00
|
|
|
'line_number' => $comment->getStartLine() + substr_count($comment_text, "\n", 0, $offset),
|
2019-06-01 22:57:33 +02:00
|
|
|
'start' => $start,
|
|
|
|
'end' => $end,
|
2016-12-25 12:32:21 +01:00
|
|
|
];
|
2016-10-15 06:12:57 +02:00
|
|
|
}
|
2016-12-25 12:32:21 +01:00
|
|
|
} else {
|
|
|
|
throw new DocblockParseException('Badly-formatted @param');
|
2016-06-24 00:45:46 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['param-out'])) {
|
|
|
|
foreach ($parsed_docblock->tags['param-out'] as $offset => $param) {
|
2019-02-01 02:21:20 +01:00
|
|
|
$line_parts = self::splitDocLine($param);
|
2019-01-19 19:32:43 +01:00
|
|
|
|
|
|
|
if (count($line_parts) === 1 && isset($line_parts[0][0]) && $line_parts[0][0] === '$') {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (count($line_parts) > 1) {
|
|
|
|
if (!preg_match('/\[[^\]]+\]/', $line_parts[0])
|
|
|
|
&& preg_match('/^(\.\.\.)?&?\$[A-Za-z0-9_]+,?$/', $line_parts[1])
|
|
|
|
&& $line_parts[0][0] !== '{'
|
|
|
|
) {
|
|
|
|
if ($line_parts[1][0] === '&') {
|
|
|
|
$line_parts[1] = substr($line_parts[1], 1);
|
|
|
|
}
|
|
|
|
|
2019-06-03 21:46:25 +02:00
|
|
|
$line_parts[0] = str_replace("\n", '', preg_replace('@^[ \t]*\*@m', '', $line_parts[0]));
|
|
|
|
|
|
|
|
if ($line_parts[0] === ''
|
|
|
|
|| ($line_parts[0][0] === '$'
|
|
|
|
&& !preg_match('/^\$this(\||$)/', $line_parts[0]))
|
|
|
|
) {
|
2019-01-19 19:32:43 +01:00
|
|
|
throw new IncorrectDocblockException('Misplaced variable');
|
|
|
|
}
|
|
|
|
|
|
|
|
$line_parts[1] = preg_replace('/,$/', '', $line_parts[1]);
|
|
|
|
|
|
|
|
$info->params_out[] = [
|
2019-06-01 22:57:33 +02:00
|
|
|
'name' => trim($line_parts[1]),
|
|
|
|
'type' => str_replace("\n", '', $line_parts[0]),
|
2020-09-20 14:56:49 +02:00
|
|
|
'line_number' => $comment->getStartLine() + substr_count($comment_text, "\n", 0, $offset),
|
2019-01-19 19:32:43 +01:00
|
|
|
];
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
throw new DocblockParseException('Badly-formatted @param');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-02 00:10:24 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-self-out'])) {
|
|
|
|
foreach ($parsed_docblock->tags['psalm-self-out'] as $offset => $param) {
|
|
|
|
$line_parts = self::splitDocLine($param);
|
|
|
|
|
|
|
|
if (count($line_parts) > 0) {
|
|
|
|
$line_parts[0] = str_replace("\n", '', preg_replace('@^[ \t]*\*@m', '', $line_parts[0]));
|
|
|
|
|
|
|
|
$info->self_out = [
|
|
|
|
'type' => str_replace("\n", '', $line_parts[0]),
|
2020-09-20 14:56:49 +02:00
|
|
|
'line_number' => $comment->getStartLine() + substr_count($comment_text, "\n", 0, $offset),
|
2020-07-02 00:10:24 +02:00
|
|
|
];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-flow'])) {
|
2020-06-22 23:53:03 +02:00
|
|
|
foreach ($parsed_docblock->tags['psalm-flow'] as $param) {
|
|
|
|
$info->flows[] = trim($param);
|
|
|
|
}
|
2020-05-22 04:47:58 +02:00
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-taint-sink'])) {
|
|
|
|
foreach ($parsed_docblock->tags['psalm-taint-sink'] as $param) {
|
2020-05-22 04:47:58 +02:00
|
|
|
$param_parts = preg_split('/\s+/', trim($param));
|
|
|
|
|
|
|
|
if (count($param_parts) === 2) {
|
2020-06-21 17:43:08 +02:00
|
|
|
$info->taint_sink_params[] = ['name' => $param_parts[1], 'taint' => $param_parts[0]];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// support for MediaWiki taint plugin
|
|
|
|
if (isset($parsed_docblock->tags['param-taint'])) {
|
|
|
|
foreach ($parsed_docblock->tags['param-taint'] as $param) {
|
|
|
|
$param_parts = preg_split('/\s+/', trim($param));
|
|
|
|
|
|
|
|
if (count($param_parts) === 2) {
|
|
|
|
$taint_type = $param_parts[1];
|
|
|
|
|
|
|
|
if (substr($taint_type, 0, 5) === 'exec_') {
|
|
|
|
$taint_type = substr($taint_type, 5);
|
|
|
|
|
|
|
|
if ($taint_type === 'tainted') {
|
|
|
|
$taint_type = 'input';
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($taint_type === 'misc') {
|
|
|
|
$taint_type = 'text';
|
|
|
|
}
|
|
|
|
|
|
|
|
$info->taint_sink_params[] = ['name' => $param_parts[0], 'taint' => $taint_type];
|
|
|
|
}
|
2020-05-22 04:47:58 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-21 06:58:56 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-taint-source'])) {
|
|
|
|
foreach ($parsed_docblock->tags['psalm-taint-source'] as $param) {
|
|
|
|
$param_parts = preg_split('/\s+/', trim($param));
|
|
|
|
|
2020-06-21 17:43:08 +02:00
|
|
|
if ($param_parts[0]) {
|
|
|
|
$info->taint_source_types[] = $param_parts[0];
|
|
|
|
}
|
|
|
|
}
|
2020-07-05 15:12:00 +02:00
|
|
|
} elseif (isset($parsed_docblock->tags['return-taint'])) {
|
|
|
|
// support for MediaWiki taint plugin
|
2020-06-21 17:43:08 +02:00
|
|
|
foreach ($parsed_docblock->tags['return-taint'] as $param) {
|
|
|
|
$param_parts = preg_split('/\s+/', trim($param));
|
|
|
|
|
|
|
|
if ($param_parts[0]) {
|
|
|
|
if ($param_parts[0] === 'tainted') {
|
|
|
|
$param_parts[0] = 'input';
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($param_parts[0] === 'misc') {
|
|
|
|
$param_parts[0] = 'text';
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($param_parts[0] !== 'none') {
|
|
|
|
$info->taint_source_types[] = $param_parts[0];
|
|
|
|
}
|
2020-06-21 06:58:56 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-21 17:43:08 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-taint-unescape'])) {
|
|
|
|
foreach ($parsed_docblock->tags['psalm-taint-unescape'] as $param) {
|
2019-08-04 16:37:36 +02:00
|
|
|
$param = trim($param);
|
2020-05-22 04:47:58 +02:00
|
|
|
$info->added_taints[] = $param;
|
|
|
|
}
|
|
|
|
}
|
2019-08-04 16:37:36 +02:00
|
|
|
|
2020-06-21 17:43:08 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-taint-escape'])) {
|
|
|
|
foreach ($parsed_docblock->tags['psalm-taint-escape'] as $param) {
|
2020-05-22 04:47:58 +02:00
|
|
|
$param = trim($param);
|
|
|
|
$info->removed_taints[] = $param;
|
2019-08-04 16:37:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-assert-untainted'])) {
|
|
|
|
foreach ($parsed_docblock->tags['psalm-assert-untainted'] as $param) {
|
2019-08-04 16:37:36 +02:00
|
|
|
$param = trim($param);
|
|
|
|
|
|
|
|
$info->assert_untainted_params[] = ['name' => $param];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-taint-specialize'])) {
|
2020-05-22 18:33:04 +02:00
|
|
|
$info->specialize_call = true;
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['global'])) {
|
|
|
|
foreach ($parsed_docblock->tags['global'] as $offset => $global) {
|
2019-02-01 02:21:20 +01:00
|
|
|
$line_parts = self::splitDocLine($global);
|
2018-06-08 15:31:21 +02:00
|
|
|
|
|
|
|
if (count($line_parts) === 1 && isset($line_parts[0][0]) && $line_parts[0][0] === '$') {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (count($line_parts) > 1) {
|
|
|
|
if (!preg_match('/\[[^\]]+\]/', $line_parts[0])
|
|
|
|
&& preg_match('/^(\.\.\.)?&?\$[A-Za-z0-9_]+,?$/', $line_parts[1])
|
|
|
|
&& $line_parts[0][0] !== '{'
|
|
|
|
) {
|
|
|
|
if ($line_parts[1][0] === '&') {
|
|
|
|
$line_parts[1] = substr($line_parts[1], 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($line_parts[0][0] === '$' && !preg_match('/^\$this(\||$)/', $line_parts[0])) {
|
|
|
|
throw new IncorrectDocblockException('Misplaced variable');
|
|
|
|
}
|
|
|
|
|
|
|
|
$line_parts[1] = preg_replace('/,$/', '', $line_parts[1]);
|
|
|
|
|
|
|
|
$info->globals[] = [
|
|
|
|
'name' => $line_parts[1],
|
|
|
|
'type' => $line_parts[0],
|
2020-09-20 14:56:49 +02:00
|
|
|
'line_number' => $comment->getStartLine() + substr_count($comment_text, "\n", 0, $offset),
|
2018-06-08 15:31:21 +02:00
|
|
|
];
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
throw new DocblockParseException('Badly-formatted @param');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['deprecated'])) {
|
2016-11-13 05:59:31 +01:00
|
|
|
$info->deprecated = true;
|
2016-07-22 19:29:46 +02:00
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['internal'])) {
|
2018-12-02 00:37:49 +01:00
|
|
|
$info->internal = true;
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-internal'])) {
|
|
|
|
$psalm_internal = reset($parsed_docblock->tags['psalm-internal']);
|
2019-05-11 21:39:53 +02:00
|
|
|
if ($psalm_internal) {
|
|
|
|
$info->psalm_internal = $psalm_internal;
|
2019-05-11 17:55:37 +02:00
|
|
|
} else {
|
2019-05-15 00:27:27 +02:00
|
|
|
throw new DocblockParseException('@psalm-internal annotation used without specifying namespace');
|
2019-05-11 17:55:37 +02:00
|
|
|
}
|
2020-05-29 04:14:41 +02:00
|
|
|
$info->psalm_internal = reset($parsed_docblock->tags['psalm-internal']);
|
2020-07-26 16:47:48 +02:00
|
|
|
$info->internal = true;
|
2019-05-11 16:15:50 +02:00
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-suppress'])) {
|
|
|
|
foreach ($parsed_docblock->tags['psalm-suppress'] as $offset => $suppress_entry) {
|
2020-09-13 22:41:14 +02:00
|
|
|
foreach (DocComment::parseSuppressList($suppress_entry) as $issue_offset => $suppressed_issue) {
|
2020-09-20 14:56:49 +02:00
|
|
|
$info->suppressed_issues[$issue_offset + $offset + $comment->getStartFilePos()] = $suppressed_issue;
|
2020-09-13 22:41:14 +02:00
|
|
|
}
|
2016-07-22 19:29:46 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['throws'])) {
|
|
|
|
foreach ($parsed_docblock->tags['throws'] as $offset => $throws_entry) {
|
2019-01-06 16:01:35 +01:00
|
|
|
$throws_class = preg_split('/[\s]+/', $throws_entry)[0];
|
|
|
|
|
|
|
|
if (!$throws_class) {
|
|
|
|
throw new IncorrectDocblockException('Unexpectedly empty @throws');
|
|
|
|
}
|
|
|
|
|
2019-08-13 21:44:18 +02:00
|
|
|
$info->throws[] = [
|
|
|
|
$throws_class,
|
2020-09-20 14:56:49 +02:00
|
|
|
$offset + $comment->getStartFilePos(),
|
|
|
|
$comment->getStartLine() + substr_count($comment->getText(), "\n", 0, $offset)
|
2019-08-13 21:44:18 +02:00
|
|
|
];
|
2018-06-22 07:13:49 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (strpos(strtolower($parsed_docblock->description), '@inheritdoc') !== false
|
|
|
|
|| isset($parsed_docblock->tags['inheritdoc'])
|
|
|
|
|| isset($parsed_docblock->tags['inheritDoc'])
|
|
|
|
) {
|
2018-12-21 17:01:24 +01:00
|
|
|
$info->inheritdoc = true;
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->combined_tags['template'])) {
|
|
|
|
foreach ($parsed_docblock->combined_tags['template'] as $template_line) {
|
2019-06-02 00:44:59 +02:00
|
|
|
$template_type = preg_split('/[\s]+/', preg_replace('@^[ \t]*\*@m', '', $template_line));
|
2017-02-10 02:35:17 +01:00
|
|
|
|
2019-05-06 22:38:08 +02:00
|
|
|
$template_name = array_shift($template_type);
|
|
|
|
|
2019-12-09 03:19:29 +01:00
|
|
|
if (!$template_name) {
|
|
|
|
throw new IncorrectDocblockException('Empty @template tag');
|
|
|
|
}
|
|
|
|
|
2019-05-06 22:38:08 +02:00
|
|
|
if (count($template_type) > 1
|
|
|
|
&& in_array(strtolower($template_type[0]), ['as', 'super', 'of'], true)
|
2019-01-16 15:23:18 +01:00
|
|
|
) {
|
2019-05-06 22:38:08 +02:00
|
|
|
$template_modifier = strtolower(array_shift($template_type));
|
2018-12-18 05:29:27 +01:00
|
|
|
$info->templates[] = [
|
2019-05-06 22:38:08 +02:00
|
|
|
$template_name,
|
|
|
|
$template_modifier,
|
|
|
|
implode(' ', $template_type),
|
|
|
|
false
|
2018-06-19 19:19:34 +02:00
|
|
|
];
|
2017-02-10 02:35:17 +01:00
|
|
|
} else {
|
2019-05-06 22:38:08 +02:00
|
|
|
$info->templates[] = [$template_name, null, null, false];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-assert'])) {
|
|
|
|
foreach ($parsed_docblock->tags['psalm-assert'] as $assertion) {
|
2019-09-22 03:50:11 +02:00
|
|
|
$line_parts = self::splitDocLine($assertion);
|
2018-05-28 21:07:42 +02:00
|
|
|
|
2019-09-22 03:50:11 +02:00
|
|
|
if (count($line_parts) < 2 || $line_parts[1][0] !== '$') {
|
2018-05-28 21:07:42 +02:00
|
|
|
throw new IncorrectDocblockException('Misplaced variable');
|
|
|
|
}
|
|
|
|
|
2020-04-03 20:56:11 +02:00
|
|
|
$line_parts[0] = self::sanitizeDocblockType($line_parts[0]);
|
|
|
|
|
2018-05-28 21:07:42 +02:00
|
|
|
$info->assertions[] = [
|
2019-09-22 03:50:11 +02:00
|
|
|
'type' => $line_parts[0],
|
|
|
|
'param_name' => substr($line_parts[1], 1),
|
2018-05-28 21:07:42 +02:00
|
|
|
];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-assert-if-true'])) {
|
|
|
|
foreach ($parsed_docblock->tags['psalm-assert-if-true'] as $assertion) {
|
2019-12-19 20:24:26 +01:00
|
|
|
$line_parts = self::splitDocLine($assertion);
|
2018-05-28 21:07:42 +02:00
|
|
|
|
2019-12-19 20:24:26 +01:00
|
|
|
if (count($line_parts) < 2 || $line_parts[1][0] !== '$') {
|
2018-05-28 21:07:42 +02:00
|
|
|
throw new IncorrectDocblockException('Misplaced variable');
|
|
|
|
}
|
|
|
|
|
|
|
|
$info->if_true_assertions[] = [
|
2019-12-19 20:24:26 +01:00
|
|
|
'type' => $line_parts[0],
|
|
|
|
'param_name' => substr($line_parts[1], 1),
|
2018-05-28 21:07:42 +02:00
|
|
|
];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-assert-if-false'])) {
|
|
|
|
foreach ($parsed_docblock->tags['psalm-assert-if-false'] as $assertion) {
|
2019-12-19 20:24:26 +01:00
|
|
|
$line_parts = self::splitDocLine($assertion);
|
2018-05-28 21:07:42 +02:00
|
|
|
|
2019-12-19 20:24:26 +01:00
|
|
|
if (count($line_parts) < 2 || $line_parts[1][0] !== '$') {
|
2018-05-28 21:07:42 +02:00
|
|
|
throw new IncorrectDocblockException('Misplaced variable');
|
|
|
|
}
|
|
|
|
|
|
|
|
$info->if_false_assertions[] = [
|
2019-12-19 20:24:26 +01:00
|
|
|
'type' => $line_parts[0],
|
|
|
|
'param_name' => substr($line_parts[1], 1),
|
2018-05-28 21:07:42 +02:00
|
|
|
];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
$info->variadic = isset($parsed_docblock->tags['psalm-variadic']);
|
|
|
|
$info->pure = isset($parsed_docblock->tags['psalm-pure'])
|
|
|
|
|| isset($parsed_docblock->tags['pure']);
|
2019-08-31 06:47:12 +02:00
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-mutation-free'])) {
|
2019-08-31 06:47:12 +02:00
|
|
|
$info->mutation_free = true;
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-external-mutation-free'])) {
|
2019-08-31 06:47:12 +02:00
|
|
|
$info->external_mutation_free = true;
|
|
|
|
}
|
|
|
|
|
2020-08-14 06:27:33 +02:00
|
|
|
if (isset($parsed_docblock->tags['no-named-arguments'])) {
|
|
|
|
$info->no_named_args = true;
|
2020-08-10 15:58:43 +02:00
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
$info->ignore_nullable_return = isset($parsed_docblock->tags['psalm-ignore-nullable-return']);
|
|
|
|
$info->ignore_falsable_return = isset($parsed_docblock->tags['psalm-ignore-falsable-return']);
|
2020-09-13 22:40:31 +02:00
|
|
|
$info->stub_override = isset($parsed_docblock->tags['psalm-stub-override']);
|
2016-10-18 23:55:07 +02:00
|
|
|
|
2016-06-24 00:45:46 +02:00
|
|
|
return $info;
|
|
|
|
}
|
2016-10-28 06:11:16 +02:00
|
|
|
|
2017-02-10 02:35:17 +01:00
|
|
|
/**
|
2019-06-01 22:57:33 +02:00
|
|
|
* @param array<int, string> $return_specials
|
2019-01-09 17:51:29 +01:00
|
|
|
* @return void
|
|
|
|
*/
|
2019-06-01 19:02:20 +02:00
|
|
|
private static function extractReturnType(
|
|
|
|
PhpParser\Comment\Doc $comment,
|
2019-06-01 22:57:33 +02:00
|
|
|
array $return_specials,
|
2019-06-01 19:02:20 +02:00
|
|
|
FunctionDocblockComment $info
|
|
|
|
) {
|
2019-06-01 22:57:33 +02:00
|
|
|
foreach ($return_specials as $offset => $return_block) {
|
|
|
|
$return_lines = explode("\n", $return_block);
|
2019-01-09 17:51:29 +01:00
|
|
|
|
2019-06-01 22:57:33 +02:00
|
|
|
if (!trim($return_lines[0])) {
|
|
|
|
return;
|
|
|
|
}
|
2019-01-09 17:51:29 +01:00
|
|
|
|
2019-06-01 22:57:33 +02:00
|
|
|
$return_block = trim($return_block);
|
2019-01-09 17:51:29 +01:00
|
|
|
|
2019-06-01 22:57:33 +02:00
|
|
|
if (!$return_block) {
|
|
|
|
return;
|
|
|
|
}
|
2019-01-09 17:51:29 +01:00
|
|
|
|
2019-06-01 22:57:33 +02:00
|
|
|
$line_parts = self::splitDocLine($return_block);
|
2019-01-09 17:51:29 +01:00
|
|
|
|
2019-06-01 22:57:33 +02:00
|
|
|
if ($line_parts[0][0] !== '{') {
|
|
|
|
if ($line_parts[0][0] === '$' && !preg_match('/^\$this(\||$)/', $line_parts[0])) {
|
|
|
|
throw new IncorrectDocblockException('Misplaced variable');
|
|
|
|
}
|
2019-01-09 17:51:29 +01:00
|
|
|
|
2020-09-20 14:56:49 +02:00
|
|
|
$start = $offset + $comment->getStartFilePos();
|
2019-06-01 22:57:33 +02:00
|
|
|
$end = $start + strlen($line_parts[0]);
|
2019-06-01 19:02:20 +02:00
|
|
|
|
2020-04-03 20:56:11 +02:00
|
|
|
$line_parts[0] = self::sanitizeDocblockType($line_parts[0]);
|
2019-06-02 00:44:59 +02:00
|
|
|
|
2020-02-12 15:18:43 +01:00
|
|
|
$info->return_type = array_shift($line_parts);
|
2019-06-01 22:57:33 +02:00
|
|
|
$info->return_type_description = $line_parts ? implode(' ', $line_parts) : null;
|
2019-01-09 17:51:29 +01:00
|
|
|
|
2019-06-01 22:57:33 +02:00
|
|
|
$info->return_type_line_number
|
2020-09-20 14:56:49 +02:00
|
|
|
= $comment->getStartLine() + substr_count($comment->getText(), "\n", 0, $offset);
|
2019-06-01 22:57:33 +02:00
|
|
|
$info->return_type_start = $start;
|
|
|
|
$info->return_type_end = $end;
|
|
|
|
} else {
|
|
|
|
throw new DocblockParseException('Badly-formatted @return type');
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
2019-01-09 17:51:29 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-05-27 02:16:18 +02:00
|
|
|
* @throws DocblockParseException if there was a problem parsing the docblock
|
|
|
|
*
|
2017-02-10 02:35:17 +01:00
|
|
|
* @psalm-suppress MixedArrayAccess
|
|
|
|
*/
|
2019-08-08 23:25:56 +02:00
|
|
|
public static function extractClassLikeDocblockInfo(
|
|
|
|
\PhpParser\Node $node,
|
|
|
|
PhpParser\Comment\Doc $comment,
|
|
|
|
Aliases $aliases
|
2020-09-04 22:26:33 +02:00
|
|
|
): ClassLikeDocblockComment {
|
2019-06-26 22:26:14 +02:00
|
|
|
$parsed_docblock = DocComment::parsePreservingLength($comment);
|
2020-04-08 15:35:53 +02:00
|
|
|
$codebase = ProjectAnalyzer::getInstance()->getCodebase();
|
2017-02-10 02:35:17 +01:00
|
|
|
|
|
|
|
$info = new ClassLikeDocblockComment();
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->combined_tags['template'])) {
|
|
|
|
foreach ($parsed_docblock->combined_tags['template'] as $offset => $template_line) {
|
2019-06-02 00:44:59 +02:00
|
|
|
$template_type = preg_split('/[\s]+/', preg_replace('@^[ \t]*\*@m', '', $template_line));
|
2017-02-10 02:35:17 +01:00
|
|
|
|
2019-03-01 15:20:51 +01:00
|
|
|
$template_name = array_shift($template_type);
|
|
|
|
|
2019-12-09 03:19:29 +01:00
|
|
|
if (!$template_name) {
|
|
|
|
throw new IncorrectDocblockException('Empty @template tag');
|
|
|
|
}
|
|
|
|
|
2019-03-01 15:20:51 +01:00
|
|
|
if (count($template_type) > 1
|
|
|
|
&& in_array(strtolower($template_type[0]), ['as', 'super', 'of'], true)
|
2019-01-16 15:23:18 +01:00
|
|
|
) {
|
2019-03-01 15:20:51 +01:00
|
|
|
$template_modifier = strtolower(array_shift($template_type));
|
2018-12-18 05:29:27 +01:00
|
|
|
$info->templates[] = [
|
2019-03-01 15:20:51 +01:00
|
|
|
$template_name,
|
|
|
|
$template_modifier,
|
2019-05-06 22:38:08 +02:00
|
|
|
implode(' ', $template_type),
|
2019-11-30 07:02:23 +01:00
|
|
|
false,
|
|
|
|
$offset
|
2019-05-06 22:38:08 +02:00
|
|
|
];
|
|
|
|
} else {
|
2019-11-30 07:02:23 +01:00
|
|
|
$info->templates[] = [$template_name, null, null, false, $offset];
|
2019-05-06 22:38:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->combined_tags['template-covariant'])) {
|
|
|
|
foreach ($parsed_docblock->combined_tags['template-covariant'] as $offset => $template_line) {
|
2019-06-02 00:44:59 +02:00
|
|
|
$template_type = preg_split('/[\s]+/', preg_replace('@^[ \t]*\*@m', '', $template_line));
|
2019-05-06 22:38:08 +02:00
|
|
|
|
|
|
|
$template_name = array_shift($template_type);
|
|
|
|
|
2019-12-09 03:19:29 +01:00
|
|
|
if (!$template_name) {
|
|
|
|
throw new IncorrectDocblockException('Empty @template-covariant tag');
|
|
|
|
}
|
|
|
|
|
2019-05-06 22:38:08 +02:00
|
|
|
if (count($template_type) > 1
|
|
|
|
&& in_array(strtolower($template_type[0]), ['as', 'super', 'of'], true)
|
|
|
|
) {
|
|
|
|
$template_modifier = strtolower(array_shift($template_type));
|
|
|
|
$info->templates[] = [
|
|
|
|
$template_name,
|
|
|
|
$template_modifier,
|
|
|
|
implode(' ', $template_type),
|
2019-11-30 07:02:23 +01:00
|
|
|
true,
|
|
|
|
$offset
|
2018-06-19 19:19:34 +02:00
|
|
|
];
|
2017-02-10 02:35:17 +01:00
|
|
|
} else {
|
2019-11-30 07:02:23 +01:00
|
|
|
$info->templates[] = [$template_name, null, null, true, $offset];
|
2017-02-10 02:35:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->combined_tags['extends'])) {
|
|
|
|
foreach ($parsed_docblock->combined_tags['extends'] as $template_line) {
|
2019-06-03 16:28:54 +02:00
|
|
|
$info->template_extends[] = trim(preg_replace('@^[ \t]*\*@m', '', $template_line));
|
2019-01-10 22:59:44 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->combined_tags['implements'])) {
|
|
|
|
foreach ($parsed_docblock->combined_tags['implements'] as $template_line) {
|
2019-06-03 16:28:54 +02:00
|
|
|
$info->template_implements[] = trim(preg_replace('@^[ \t]*\*@m', '', $template_line));
|
2018-05-28 23:26:43 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-yield'])
|
2020-04-03 04:38:10 +02:00
|
|
|
) {
|
2020-05-29 04:14:41 +02:00
|
|
|
$yield = reset($parsed_docblock->tags['psalm-yield']);
|
2020-04-03 04:38:10 +02:00
|
|
|
|
|
|
|
$info->yield = trim(preg_replace('@^[ \t]*\*@m', '', $yield));
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['deprecated'])) {
|
2017-05-05 00:35:05 +02:00
|
|
|
$info->deprecated = true;
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['internal'])) {
|
2018-12-02 00:37:49 +01:00
|
|
|
$info->internal = true;
|
|
|
|
}
|
|
|
|
|
2020-06-13 06:29:59 +02:00
|
|
|
if (isset($parsed_docblock->tags['final'])) {
|
|
|
|
$info->final = true;
|
|
|
|
}
|
|
|
|
|
2020-08-06 01:39:27 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-consistent-constructor'])) {
|
|
|
|
$info->consistent_constructor = true;
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-internal'])) {
|
|
|
|
$psalm_internal = reset($parsed_docblock->tags['psalm-internal']);
|
2019-05-11 21:39:53 +02:00
|
|
|
if ($psalm_internal) {
|
|
|
|
$info->psalm_internal = $psalm_internal;
|
2019-05-11 17:55:37 +02:00
|
|
|
} else {
|
|
|
|
throw new DocblockParseException('psalm-internal annotation used without specifying namespace');
|
|
|
|
}
|
2019-05-15 00:27:27 +02:00
|
|
|
|
2020-07-26 16:47:48 +02:00
|
|
|
$info->internal = true;
|
2019-05-10 00:33:27 +02:00
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['mixin'])) {
|
2020-08-05 21:49:19 +02:00
|
|
|
foreach ($parsed_docblock->tags['mixin'] as $rawMixin) {
|
|
|
|
$mixin = trim($rawMixin);
|
|
|
|
$doc_line_parts = self::splitDocLine($mixin);
|
|
|
|
$mixin = $doc_line_parts[0];
|
2020-01-03 05:50:19 +01:00
|
|
|
|
2020-08-05 21:49:19 +02:00
|
|
|
if ($mixin) {
|
|
|
|
$info->mixins[] = $mixin;
|
|
|
|
} else {
|
|
|
|
throw new DocblockParseException('@mixin annotation used without specifying class');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// backwards compatibility
|
|
|
|
if ($info->mixins) {
|
|
|
|
/** @psalm-suppress DeprecatedProperty */
|
|
|
|
$info->mixin = reset($info->mixins);
|
2020-01-03 05:50:19 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-seal-properties'])) {
|
2017-11-17 02:47:58 +01:00
|
|
|
$info->sealed_properties = true;
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-seal-methods'])) {
|
2018-04-22 06:40:30 +02:00
|
|
|
$info->sealed_methods = true;
|
2018-11-25 00:31:00 +01:00
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-immutable'])
|
|
|
|
|| isset($parsed_docblock->tags['psalm-mutation-free'])
|
2019-08-30 18:36:35 +02:00
|
|
|
) {
|
|
|
|
$info->mutation_free = true;
|
2019-08-31 16:07:23 +02:00
|
|
|
$info->external_mutation_free = true;
|
2020-06-19 07:22:51 +02:00
|
|
|
$info->taint_specialize = true;
|
2019-08-30 18:36:35 +02:00
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-external-mutation-free'])) {
|
2019-08-30 18:36:35 +02:00
|
|
|
$info->external_mutation_free = true;
|
|
|
|
}
|
|
|
|
|
2020-06-19 07:22:51 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-taint-specialize'])) {
|
|
|
|
$info->taint_specialize = true;
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-override-property-visibility'])) {
|
2018-11-25 17:11:33 +01:00
|
|
|
$info->override_property_visibility = true;
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-override-method-visibility'])) {
|
2018-11-25 17:11:33 +01:00
|
|
|
$info->override_method_visibility = true;
|
2018-04-22 06:40:30 +02:00
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-suppress'])) {
|
|
|
|
foreach ($parsed_docblock->tags['psalm-suppress'] as $offset => $suppress_entry) {
|
2020-09-13 22:41:14 +02:00
|
|
|
foreach (DocComment::parseSuppressList($suppress_entry) as $issue_offset => $suppressed_issue) {
|
2020-09-20 14:56:49 +02:00
|
|
|
$info->suppressed_issues[$issue_offset + $offset + $comment->getStartFilePos()] = $suppressed_issue;
|
2020-09-13 22:41:14 +02:00
|
|
|
}
|
2017-09-13 17:32:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-import-type'])) {
|
2020-08-17 04:53:53 +02:00
|
|
|
foreach ($parsed_docblock->tags['psalm-import-type'] as $offset => $imported_type_entry) {
|
|
|
|
$info->imported_types[] = [
|
2020-09-20 14:56:49 +02:00
|
|
|
'line_number' => $comment->getStartLine() + substr_count($comment->getText(), "\n", 0, $offset),
|
|
|
|
'start_offset' => $comment->getStartFilePos() + $offset,
|
|
|
|
'end_offset' => $comment->getStartFilePos() + $offset + strlen($imported_type_entry),
|
2020-08-17 04:53:53 +02:00
|
|
|
'parts' => self::splitDocLine($imported_type_entry) ?: []
|
|
|
|
];
|
2020-05-14 06:41:50 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
if (isset($parsed_docblock->combined_tags['method'])) {
|
|
|
|
foreach ($parsed_docblock->combined_tags['method'] as $offset => $method_entry) {
|
2018-04-23 15:52:40 +02:00
|
|
|
$method_entry = preg_replace('/[ \t]+/', ' ', trim($method_entry));
|
2018-04-22 04:13:10 +02:00
|
|
|
|
2018-07-07 06:06:05 +02:00
|
|
|
$docblock_lines = [];
|
2018-04-22 04:13:10 +02:00
|
|
|
|
2019-01-18 17:37:52 +01:00
|
|
|
$is_static = false;
|
|
|
|
|
2020-06-20 21:30:47 +02:00
|
|
|
$has_return = false;
|
|
|
|
|
2018-04-22 04:13:10 +02:00
|
|
|
if (!preg_match('/^([a-z_A-Z][a-z_0-9A-Z]+) *\(/', $method_entry, $matches)) {
|
|
|
|
$doc_line_parts = self::splitDocLine($method_entry);
|
|
|
|
|
2019-01-30 17:44:12 +01:00
|
|
|
if ($doc_line_parts[0] === 'static' && !strpos($doc_line_parts[1], '(')) {
|
2019-01-18 17:37:52 +01:00
|
|
|
$is_static = true;
|
|
|
|
array_shift($doc_line_parts);
|
|
|
|
}
|
|
|
|
|
2019-09-08 04:30:09 +02:00
|
|
|
if (count($doc_line_parts) > 1) {
|
|
|
|
$docblock_lines[] = '@return ' . array_shift($doc_line_parts);
|
2020-06-20 21:30:47 +02:00
|
|
|
$has_return = true;
|
2018-04-22 04:13:10 +02:00
|
|
|
|
2019-09-08 04:30:09 +02:00
|
|
|
$method_entry = implode(' ', $doc_line_parts);
|
|
|
|
}
|
2018-04-22 04:13:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
$method_entry = trim(preg_replace('/\/\/.*/', '', $method_entry));
|
|
|
|
|
2019-12-11 17:40:47 +01:00
|
|
|
$method_entry = preg_replace(
|
|
|
|
'/array\(([0-9a-zA-Z_\'\" ]+,)*([0-9a-zA-Z_\'\" ]+)\)/',
|
|
|
|
'[]',
|
|
|
|
$method_entry
|
|
|
|
);
|
2019-12-11 17:29:00 +01:00
|
|
|
|
2018-04-23 15:52:40 +02:00
|
|
|
$end_of_method_regex = '/(?<!array\()\) ?(\: ?(\??[\\\\a-zA-Z0-9_]+))?/';
|
|
|
|
|
|
|
|
if (preg_match($end_of_method_regex, $method_entry, $matches, PREG_OFFSET_CAPTURE)) {
|
|
|
|
$method_entry = substr($method_entry, 0, (int) $matches[0][1] + strlen((string) $matches[0][0]));
|
|
|
|
}
|
|
|
|
|
2018-07-07 06:06:05 +02:00
|
|
|
$method_entry = str_replace([', ', '( '], [',', '('], $method_entry);
|
|
|
|
$method_entry = preg_replace('/ (?!(\$|\.\.\.|&))/', '', trim($method_entry));
|
2018-06-28 23:39:25 +02:00
|
|
|
|
2019-12-11 17:29:00 +01:00
|
|
|
// replace array bracket contents
|
|
|
|
$method_entry = preg_replace('/\[([0-9a-zA-Z_\'\" ]+,)*([0-9a-zA-Z_\'\" ]+)\]/', '[]', $method_entry);
|
|
|
|
|
2020-07-01 15:00:33 +02:00
|
|
|
if (!$method_entry) {
|
|
|
|
throw new DocblockParseException('No @method entry specified');
|
|
|
|
}
|
|
|
|
|
2018-07-07 06:06:05 +02:00
|
|
|
try {
|
2020-05-28 20:31:09 +02:00
|
|
|
$parse_tree_creator = new ParseTreeCreator(
|
2020-05-14 01:12:45 +02:00
|
|
|
TypeTokenizer::getFullyQualifiedTokens(
|
2019-08-08 23:25:56 +02:00
|
|
|
$method_entry,
|
|
|
|
$aliases,
|
|
|
|
null
|
|
|
|
)
|
|
|
|
);
|
2020-05-28 20:31:09 +02:00
|
|
|
|
|
|
|
$method_tree = $parse_tree_creator->create();
|
2018-07-07 06:06:05 +02:00
|
|
|
} catch (TypeParseTreeException $e) {
|
|
|
|
throw new DocblockParseException($method_entry . ' is not a valid method');
|
|
|
|
}
|
|
|
|
|
2018-11-18 18:41:47 +01:00
|
|
|
if (!$method_tree instanceof ParseTree\MethodWithReturnTypeTree
|
|
|
|
&& !$method_tree instanceof ParseTree\MethodTree) {
|
2018-07-07 06:06:05 +02:00
|
|
|
throw new DocblockParseException($method_entry . ' is not a valid method');
|
|
|
|
}
|
|
|
|
|
2018-11-18 18:41:47 +01:00
|
|
|
if ($method_tree instanceof ParseTree\MethodWithReturnTypeTree) {
|
2020-06-20 21:30:47 +02:00
|
|
|
if (!$has_return) {
|
|
|
|
$docblock_lines[] = '@return ' . TypeParser::getTypeFromTree(
|
|
|
|
$method_tree->children[1],
|
|
|
|
$codebase
|
|
|
|
)->toNamespacedString($aliases->namespace, $aliases->uses, null, false);
|
|
|
|
}
|
|
|
|
|
2018-07-07 06:06:05 +02:00
|
|
|
$method_tree = $method_tree->children[0];
|
|
|
|
}
|
|
|
|
|
2018-11-18 18:41:47 +01:00
|
|
|
if (!$method_tree instanceof ParseTree\MethodTree) {
|
2018-07-07 06:06:05 +02:00
|
|
|
throw new DocblockParseException($method_entry . ' is not a valid method');
|
|
|
|
}
|
|
|
|
|
|
|
|
$args = [];
|
|
|
|
|
|
|
|
foreach ($method_tree->children as $method_tree_child) {
|
2018-11-18 18:41:47 +01:00
|
|
|
if (!$method_tree_child instanceof ParseTree\MethodParamTree) {
|
2018-07-07 06:06:05 +02:00
|
|
|
throw new DocblockParseException($method_entry . ' is not a valid method');
|
|
|
|
}
|
|
|
|
|
|
|
|
$args[] = ($method_tree_child->byref ? '&' : '')
|
|
|
|
. ($method_tree_child->variadic ? '...' : '')
|
|
|
|
. $method_tree_child->name
|
2018-07-10 22:01:44 +02:00
|
|
|
. ($method_tree_child->default != '' ? ' = ' . $method_tree_child->default : '');
|
2018-07-07 06:06:05 +02:00
|
|
|
|
|
|
|
|
|
|
|
if ($method_tree_child->children) {
|
2020-05-12 00:39:07 +02:00
|
|
|
try {
|
2020-05-14 01:12:45 +02:00
|
|
|
$param_type = TypeParser::getTypeFromTree($method_tree_child->children[0], $codebase);
|
2020-05-12 00:39:07 +02:00
|
|
|
} catch (\Exception $e) {
|
|
|
|
throw new DocblockParseException(
|
|
|
|
'Badly-formatted @method string ' . $method_entry . ' - ' . $e
|
|
|
|
);
|
|
|
|
}
|
2020-08-29 17:46:24 +02:00
|
|
|
|
|
|
|
$param_type_string = $param_type->toNamespacedString('\\', [], null, false);
|
|
|
|
$docblock_lines[] = '@param ' . $param_type_string . ' '
|
2018-07-07 06:06:05 +02:00
|
|
|
. ($method_tree_child->variadic ? '...' : '')
|
|
|
|
. $method_tree_child->name;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$function_string = 'function ' . $method_tree->value . '(' . implode(', ', $args) . ')';
|
|
|
|
|
2019-01-18 17:37:52 +01:00
|
|
|
if ($is_static) {
|
|
|
|
$function_string = 'static ' . $function_string;
|
|
|
|
}
|
|
|
|
|
2018-07-07 06:06:05 +02:00
|
|
|
$function_docblock = $docblock_lines ? "/**\n * " . implode("\n * ", $docblock_lines) . "\n*/\n" : "";
|
2018-06-05 23:59:32 +02:00
|
|
|
|
2018-07-07 06:06:05 +02:00
|
|
|
$php_string = '<?php class A { ' . $function_docblock . ' public ' . $function_string . '{} }';
|
2018-04-22 04:13:10 +02:00
|
|
|
|
|
|
|
try {
|
2020-08-09 22:23:43 +02:00
|
|
|
$statements = \Psalm\Internal\Provider\StatementsProvider::parseStatements(
|
|
|
|
$php_string,
|
|
|
|
$codebase->php_major_version . '.' . $codebase->php_minor_version
|
|
|
|
);
|
2018-04-22 04:13:10 +02:00
|
|
|
} catch (\Exception $e) {
|
|
|
|
throw new DocblockParseException('Badly-formatted @method string ' . $method_entry);
|
|
|
|
}
|
|
|
|
|
2020-04-09 18:16:58 +02:00
|
|
|
if (!$statements
|
|
|
|
|| !$statements[0] instanceof \PhpParser\Node\Stmt\Class_
|
2018-06-14 23:20:02 +02:00
|
|
|
|| !isset($statements[0]->stmts[0])
|
|
|
|
|| !$statements[0]->stmts[0] instanceof \PhpParser\Node\Stmt\ClassMethod
|
|
|
|
) {
|
2018-04-23 15:52:40 +02:00
|
|
|
throw new DocblockParseException('Badly-formatted @method string ' . $method_entry);
|
2018-04-22 04:13:10 +02:00
|
|
|
}
|
|
|
|
|
2019-03-19 02:05:37 +01:00
|
|
|
/** @var \PhpParser\Comment\Doc */
|
|
|
|
$node_doc_comment = $node->getDocComment();
|
|
|
|
|
2020-09-20 14:56:49 +02:00
|
|
|
$statements[0]->stmts[0]->setAttribute('startLine', $node_doc_comment->getStartLine());
|
|
|
|
$statements[0]->stmts[0]->setAttribute('startFilePos', $node_doc_comment->getStartFilePos());
|
2019-03-19 02:05:37 +01:00
|
|
|
$statements[0]->stmts[0]->setAttribute('endFilePos', $node->getAttribute('startFilePos'));
|
|
|
|
|
|
|
|
if ($doc_comment = $statements[0]->stmts[0]->getDocComment()) {
|
|
|
|
$statements[0]->stmts[0]->setDocComment(
|
|
|
|
new \PhpParser\Comment\Doc(
|
|
|
|
$doc_comment->getText(),
|
2020-09-20 14:56:49 +02:00
|
|
|
$comment->getStartLine() + substr_count($comment->getText(), "\n", 0, $offset),
|
|
|
|
$node_doc_comment->getStartFilePos()
|
2019-03-19 02:05:37 +01:00
|
|
|
)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2018-06-14 23:20:02 +02:00
|
|
|
$info->methods[] = $statements[0]->stmts[0];
|
2018-04-22 04:13:10 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-13 22:40:31 +02:00
|
|
|
if (isset($parsed_docblock->tags['psalm-stub-override'])) {
|
|
|
|
$info->stub_override = true;
|
|
|
|
}
|
|
|
|
|
2020-05-29 04:14:41 +02:00
|
|
|
self::addMagicPropertyToInfo($comment, $info, $parsed_docblock->tags, 'property');
|
|
|
|
self::addMagicPropertyToInfo($comment, $info, $parsed_docblock->tags, 'psalm-property');
|
|
|
|
self::addMagicPropertyToInfo($comment, $info, $parsed_docblock->tags, 'property-read');
|
|
|
|
self::addMagicPropertyToInfo($comment, $info, $parsed_docblock->tags, 'psalm-property-read');
|
|
|
|
self::addMagicPropertyToInfo($comment, $info, $parsed_docblock->tags, 'property-write');
|
|
|
|
self::addMagicPropertyToInfo($comment, $info, $parsed_docblock->tags, 'psalm-property-write');
|
2017-05-05 00:35:05 +02:00
|
|
|
|
2017-12-14 20:22:27 +01:00
|
|
|
return $info;
|
|
|
|
}
|
2017-05-05 00:35:05 +02:00
|
|
|
|
2017-12-14 20:22:27 +01:00
|
|
|
/**
|
2018-01-10 16:56:43 +01:00
|
|
|
* @param array<string, array<int, string>> $specials
|
2020-03-24 23:32:57 +01:00
|
|
|
* @param 'property'|'psalm-property'|'property-read'|
|
|
|
|
* 'psalm-property-read'|'property-write'|'psalm-property-write' $property_tag
|
2017-12-15 22:48:06 +01:00
|
|
|
*
|
2017-12-14 20:22:27 +01:00
|
|
|
* @throws DocblockParseException
|
2017-12-15 22:48:06 +01:00
|
|
|
*
|
2017-12-14 20:22:27 +01:00
|
|
|
*/
|
2019-06-01 22:57:33 +02:00
|
|
|
protected static function addMagicPropertyToInfo(
|
|
|
|
PhpParser\Comment\Doc $comment,
|
|
|
|
ClassLikeDocblockComment $info,
|
|
|
|
array $specials,
|
|
|
|
string $property_tag
|
|
|
|
) : void {
|
2017-12-14 20:22:27 +01:00
|
|
|
$magic_property_comments = isset($specials[$property_tag]) ? $specials[$property_tag] : [];
|
2019-06-01 22:57:33 +02:00
|
|
|
|
|
|
|
foreach ($magic_property_comments as $offset => $property) {
|
2019-02-01 02:21:20 +01:00
|
|
|
$line_parts = self::splitDocLine($property);
|
2017-05-05 00:35:05 +02:00
|
|
|
|
2019-06-14 16:45:00 +02:00
|
|
|
if (count($line_parts) === 1 && isset($line_parts[0][0]) && $line_parts[0][0] === '$') {
|
|
|
|
continue;
|
2017-12-14 20:22:27 +01:00
|
|
|
}
|
2017-05-25 03:11:18 +02:00
|
|
|
|
2017-12-14 20:22:27 +01:00
|
|
|
if (count($line_parts) > 1) {
|
2019-06-14 16:45:00 +02:00
|
|
|
if (preg_match('/^&?\$[A-Za-z0-9_]+,?$/', $line_parts[1])
|
2017-12-14 20:22:27 +01:00
|
|
|
&& $line_parts[0][0] !== '{'
|
|
|
|
) {
|
2019-06-14 16:45:00 +02:00
|
|
|
$line_parts[1] = str_replace('&', '', $line_parts[1]);
|
|
|
|
|
|
|
|
$line_parts[1] = preg_replace('/,$/', '', $line_parts[1]);
|
|
|
|
|
2020-09-20 14:56:49 +02:00
|
|
|
$start = $offset + $comment->getStartFilePos();
|
2019-06-14 16:45:00 +02:00
|
|
|
$end = $start + strlen($line_parts[0]);
|
|
|
|
|
|
|
|
$line_parts[0] = str_replace("\n", '', preg_replace('@^[ \t]*\*@m', '', $line_parts[0]));
|
2017-05-05 00:35:05 +02:00
|
|
|
|
2019-06-14 16:45:00 +02:00
|
|
|
if ($line_parts[0] === ''
|
|
|
|
|| ($line_parts[0][0] === '$'
|
|
|
|
&& !preg_match('/^\$this(\||$)/', $line_parts[0]))
|
|
|
|
) {
|
2017-12-14 20:22:27 +01:00
|
|
|
throw new IncorrectDocblockException('Misplaced variable');
|
2017-05-05 00:35:05 +02:00
|
|
|
}
|
2017-12-14 20:22:27 +01:00
|
|
|
|
2020-04-26 16:10:14 +02:00
|
|
|
$name = trim($line_parts[1]);
|
|
|
|
|
|
|
|
if (!preg_match('/^\$([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)$/', $name)) {
|
|
|
|
throw new DocblockParseException('Badly-formatted @property name');
|
|
|
|
}
|
|
|
|
|
2017-12-14 20:22:27 +01:00
|
|
|
$info->properties[] = [
|
2020-04-26 16:10:14 +02:00
|
|
|
'name' => $name,
|
2017-12-14 20:22:27 +01:00
|
|
|
'type' => $line_parts[0],
|
2020-09-20 14:56:49 +02:00
|
|
|
'line_number' => $comment->getStartLine() + substr_count($comment->getText(), "\n", 0, $offset),
|
2017-12-14 20:22:27 +01:00
|
|
|
'tag' => $property_tag,
|
2019-06-14 16:45:00 +02:00
|
|
|
'start' => $start,
|
|
|
|
'end' => $end,
|
2017-12-14 20:22:27 +01:00
|
|
|
];
|
2017-05-05 00:35:05 +02:00
|
|
|
}
|
2017-12-14 20:22:27 +01:00
|
|
|
} else {
|
|
|
|
throw new DocblockParseException('Badly-formatted @property');
|
2017-05-05 00:35:05 +02:00
|
|
|
}
|
|
|
|
}
|
2017-02-10 02:35:17 +01:00
|
|
|
}
|
|
|
|
|
2016-10-28 06:11:16 +02:00
|
|
|
/**
|
2017-05-27 02:16:18 +02:00
|
|
|
* @throws DocblockParseException if an invalid string is found
|
|
|
|
*
|
2020-08-17 04:53:53 +02:00
|
|
|
* @return list<string>
|
2020-08-23 19:52:31 +02:00
|
|
|
*
|
|
|
|
* @psalm-pure
|
2016-10-28 06:11:16 +02:00
|
|
|
*/
|
2020-09-12 17:24:05 +02:00
|
|
|
public static function splitDocLine(string $return_block): array
|
2016-10-28 06:11:16 +02:00
|
|
|
{
|
|
|
|
$brackets = '';
|
|
|
|
|
|
|
|
$type = '';
|
|
|
|
|
2018-03-27 04:13:10 +02:00
|
|
|
$expects_callable_return = false;
|
|
|
|
|
2019-06-02 00:44:59 +02:00
|
|
|
$return_block = str_replace("\t", ' ', $return_block);
|
2018-03-27 04:13:10 +02:00
|
|
|
|
2018-05-20 23:19:53 +02:00
|
|
|
$quote_char = null;
|
|
|
|
$escaped = false;
|
|
|
|
|
2018-03-27 04:13:10 +02:00
|
|
|
for ($i = 0, $l = strlen($return_block); $i < $l; ++$i) {
|
2016-10-28 06:11:16 +02:00
|
|
|
$char = $return_block[$i];
|
2018-03-27 04:13:10 +02:00
|
|
|
$next_char = $i < $l - 1 ? $return_block[$i + 1] : null;
|
2019-02-01 13:50:48 +01:00
|
|
|
$last_char = $i > 0 ? $return_block[$i - 1] : null;
|
2016-10-28 06:11:16 +02:00
|
|
|
|
2018-05-20 23:19:53 +02:00
|
|
|
if ($quote_char) {
|
|
|
|
if ($char === $quote_char && $i > 1 && !$escaped) {
|
|
|
|
$quote_char = null;
|
|
|
|
|
|
|
|
$type .= $char;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($char === '\\' && !$escaped && ($next_char === $quote_char || $next_char === '\\')) {
|
|
|
|
$escaped = true;
|
|
|
|
|
|
|
|
$type .= $char;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
$escaped = false;
|
|
|
|
|
|
|
|
$type .= $char;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($char === '"' || $char === '\'') {
|
|
|
|
$quote_char = $char;
|
|
|
|
|
|
|
|
$type .= $char;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-02-01 13:50:48 +01:00
|
|
|
if ($char === ':' && $last_char === ')') {
|
2019-02-01 14:58:52 +01:00
|
|
|
$expects_callable_return = true;
|
2019-02-01 13:50:48 +01:00
|
|
|
|
|
|
|
$type .= $char;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2016-10-28 06:11:16 +02:00
|
|
|
if ($char === '[' || $char === '{' || $char === '(' || $char === '<') {
|
|
|
|
$brackets .= $char;
|
2016-11-02 07:29:00 +01:00
|
|
|
} elseif ($char === ']' || $char === '}' || $char === ')' || $char === '>') {
|
2016-10-28 06:11:16 +02:00
|
|
|
$last_bracket = substr($brackets, -1);
|
|
|
|
$brackets = substr($brackets, 0, -1);
|
|
|
|
|
|
|
|
if (($char === ']' && $last_bracket !== '[')
|
|
|
|
|| ($char === '}' && $last_bracket !== '{')
|
|
|
|
|| ($char === ')' && $last_bracket !== '(')
|
|
|
|
|| ($char === '>' && $last_bracket !== '<')
|
|
|
|
) {
|
2016-11-02 07:29:00 +01:00
|
|
|
throw new DocblockParseException('Invalid string ' . $return_block);
|
2016-10-28 06:11:16 +02:00
|
|
|
}
|
2018-08-23 04:53:44 +02:00
|
|
|
} elseif ($char === ' ') {
|
2019-02-01 14:58:52 +01:00
|
|
|
if ($brackets) {
|
|
|
|
$expects_callable_return = false;
|
2019-06-01 23:22:33 +02:00
|
|
|
$type .= ' ';
|
2016-10-28 06:11:16 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-05-16 19:52:58 +02:00
|
|
|
if ($next_char === '|' || $next_char === '&') {
|
|
|
|
$nexter_char = $i < $l - 2 ? $return_block[$i + 2] : null;
|
|
|
|
|
|
|
|
if ($nexter_char === ' ') {
|
|
|
|
++$i;
|
2019-06-06 19:57:00 +02:00
|
|
|
$type .= $next_char . ' ';
|
2019-05-16 19:52:58 +02:00
|
|
|
continue;
|
|
|
|
}
|
2018-08-23 04:53:44 +02:00
|
|
|
}
|
|
|
|
|
2019-05-16 19:52:58 +02:00
|
|
|
if ($last_char === '|' || $last_char === '&') {
|
2019-06-06 19:57:00 +02:00
|
|
|
$type .= ' ';
|
2018-08-23 04:53:44 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-03-27 04:13:10 +02:00
|
|
|
if ($next_char === ':') {
|
|
|
|
++$i;
|
2019-06-06 19:57:00 +02:00
|
|
|
$type .= ' :';
|
2018-03-27 04:13:10 +02:00
|
|
|
$expects_callable_return = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($expects_callable_return) {
|
2019-06-06 20:27:49 +02:00
|
|
|
$type .= ' ';
|
2018-03-27 04:13:10 +02:00
|
|
|
$expects_callable_return = false;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-06-02 00:44:59 +02:00
|
|
|
$remaining = trim(preg_replace('@^[ \t]*\* *@m', ' ', substr($return_block, $i + 1)));
|
2016-11-01 05:39:41 +01:00
|
|
|
|
|
|
|
if ($remaining) {
|
2019-06-02 00:44:59 +02:00
|
|
|
return array_merge([rtrim($type)], preg_split('/[ \s]+/', $remaining));
|
2016-11-01 05:39:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return [$type];
|
2016-10-28 06:11:16 +02:00
|
|
|
}
|
|
|
|
|
2019-02-01 14:58:52 +01:00
|
|
|
$expects_callable_return = false;
|
2019-02-01 13:50:48 +01:00
|
|
|
|
2016-10-28 06:11:16 +02:00
|
|
|
$type .= $char;
|
|
|
|
}
|
|
|
|
|
|
|
|
return [$type];
|
|
|
|
}
|
2020-05-30 22:54:16 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @throws DocblockParseException if a duplicate is found
|
|
|
|
*/
|
2020-09-12 17:24:05 +02:00
|
|
|
private static function checkDuplicatedTags(ParsedDocblock $parsed_docblock): void
|
2020-05-30 22:54:16 +02:00
|
|
|
{
|
|
|
|
if (count($parsed_docblock->tags['return'] ?? []) > 1
|
|
|
|
|| count($parsed_docblock->tags['psalm-return'] ?? []) > 1
|
|
|
|
|| count($parsed_docblock->tags['phpstan-return'] ?? []) > 1
|
|
|
|
) {
|
|
|
|
throw new DocblockParseException('Found duplicated @return or prefixed @return tag');
|
|
|
|
}
|
|
|
|
|
|
|
|
self::checkDuplicatedParams($parsed_docblock->tags['param'] ?? []);
|
|
|
|
self::checkDuplicatedParams($parsed_docblock->tags['psalm-param'] ?? []);
|
|
|
|
self::checkDuplicatedParams($parsed_docblock->tags['phpstan-param'] ?? []);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param array<int, string> $param
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* @throws DocblockParseException if a duplicate is found
|
|
|
|
*/
|
2020-09-12 17:24:05 +02:00
|
|
|
private static function checkDuplicatedParams(array $param): void
|
2020-05-30 22:54:16 +02:00
|
|
|
{
|
|
|
|
$list_names = self::extractAllParamNames($param);
|
|
|
|
|
|
|
|
if (count($list_names) !== count(array_unique($list_names))) {
|
|
|
|
throw new DocblockParseException('Found duplicated @param or prefixed @param tag');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param array<int, string> $lines
|
|
|
|
*
|
|
|
|
* @return list<string>
|
2020-08-23 19:52:31 +02:00
|
|
|
*
|
|
|
|
* @psalm-pure
|
2020-05-30 22:54:16 +02:00
|
|
|
*/
|
2020-09-12 17:24:05 +02:00
|
|
|
private static function extractAllParamNames(array $lines): array
|
2020-05-30 22:54:16 +02:00
|
|
|
{
|
|
|
|
$names = [];
|
|
|
|
|
|
|
|
foreach ($lines as $line) {
|
|
|
|
$split_by_dollar = explode('$', $line, 2);
|
|
|
|
if (count($split_by_dollar) > 1) {
|
|
|
|
$split_by_space = explode(' ', $split_by_dollar[1], 2);
|
|
|
|
$names[] = $split_by_space[0];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $names;
|
|
|
|
}
|
2016-06-24 00:45:46 +02:00
|
|
|
}
|