| 1 |
<?php declare(strict_types = 1); |
| 2 |
|
| 3 |
namespace PHPStan\PhpDocParser\Printer; |
| 4 |
|
| 5 |
use LogicException; |
| 6 |
use PHPStan\PhpDocParser\Ast\Attribute; |
| 7 |
use PHPStan\PhpDocParser\Ast\Comment; |
| 8 |
use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprArrayNode; |
| 9 |
use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprNode; |
| 10 |
use PHPStan\PhpDocParser\Ast\Node; |
| 11 |
use PHPStan\PhpDocParser\Ast\PhpDoc\AssertTagMethodValueNode; |
| 12 |
use PHPStan\PhpDocParser\Ast\PhpDoc\AssertTagPropertyValueNode; |
| 13 |
use PHPStan\PhpDocParser\Ast\PhpDoc\AssertTagValueNode; |
| 14 |
use PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine\DoctrineAnnotation; |
| 15 |
use PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine\DoctrineArgument; |
| 16 |
use PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine\DoctrineArray; |
| 17 |
use PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine\DoctrineArrayItem; |
| 18 |
use PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine\DoctrineTagValueNode; |
| 19 |
use PHPStan\PhpDocParser\Ast\PhpDoc\ExtendsTagValueNode; |
| 20 |
use PHPStan\PhpDocParser\Ast\PhpDoc\ImplementsTagValueNode; |
| 21 |
use PHPStan\PhpDocParser\Ast\PhpDoc\MethodTagValueNode; |
| 22 |
use PHPStan\PhpDocParser\Ast\PhpDoc\MethodTagValueParameterNode; |
| 23 |
use PHPStan\PhpDocParser\Ast\PhpDoc\MixinTagValueNode; |
| 24 |
use PHPStan\PhpDocParser\Ast\PhpDoc\ParamClosureThisTagValueNode; |
| 25 |
use PHPStan\PhpDocParser\Ast\PhpDoc\ParamImmediatelyInvokedCallableTagValueNode; |
| 26 |
use PHPStan\PhpDocParser\Ast\PhpDoc\ParamLaterInvokedCallableTagValueNode; |
| 27 |
use PHPStan\PhpDocParser\Ast\PhpDoc\ParamOutTagValueNode; |
| 28 |
use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode; |
| 29 |
use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocChildNode; |
| 30 |
use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocNode; |
| 31 |
use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode; |
| 32 |
use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagValueNode; |
| 33 |
use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTextNode; |
| 34 |
use PHPStan\PhpDocParser\Ast\PhpDoc\PropertyTagValueNode; |
| 35 |
use PHPStan\PhpDocParser\Ast\PhpDoc\PureUnlessCallableIsImpureTagValueNode; |
| 36 |
use PHPStan\PhpDocParser\Ast\PhpDoc\RequireExtendsTagValueNode; |
| 37 |
use PHPStan\PhpDocParser\Ast\PhpDoc\RequireImplementsTagValueNode; |
| 38 |
use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode; |
| 39 |
use PHPStan\PhpDocParser\Ast\PhpDoc\SealedTagValueNode; |
| 40 |
use PHPStan\PhpDocParser\Ast\PhpDoc\SelfOutTagValueNode; |
| 41 |
use PHPStan\PhpDocParser\Ast\PhpDoc\TemplateTagValueNode; |
| 42 |
use PHPStan\PhpDocParser\Ast\PhpDoc\ThrowsTagValueNode; |
| 43 |
use PHPStan\PhpDocParser\Ast\PhpDoc\TypeAliasImportTagValueNode; |
| 44 |
use PHPStan\PhpDocParser\Ast\PhpDoc\TypeAliasTagValueNode; |
| 45 |
use PHPStan\PhpDocParser\Ast\PhpDoc\UsesTagValueNode; |
| 46 |
use PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode; |
| 47 |
use PHPStan\PhpDocParser\Ast\Type\ArrayShapeItemNode; |
| 48 |
use PHPStan\PhpDocParser\Ast\Type\ArrayShapeNode; |
| 49 |
use PHPStan\PhpDocParser\Ast\Type\ArrayShapeUnsealedTypeNode; |
| 50 |
use PHPStan\PhpDocParser\Ast\Type\ArrayTypeNode; |
| 51 |
use PHPStan\PhpDocParser\Ast\Type\CallableTypeNode; |
| 52 |
use PHPStan\PhpDocParser\Ast\Type\CallableTypeParameterNode; |
| 53 |
use PHPStan\PhpDocParser\Ast\Type\ConditionalTypeForParameterNode; |
| 54 |
use PHPStan\PhpDocParser\Ast\Type\ConditionalTypeNode; |
| 55 |
use PHPStan\PhpDocParser\Ast\Type\ConstTypeNode; |
| 56 |
use PHPStan\PhpDocParser\Ast\Type\GenericTypeNode; |
| 57 |
use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode; |
| 58 |
use PHPStan\PhpDocParser\Ast\Type\IntersectionTypeNode; |
| 59 |
use PHPStan\PhpDocParser\Ast\Type\InvalidTypeNode; |
| 60 |
use PHPStan\PhpDocParser\Ast\Type\NullableTypeNode; |
| 61 |
use PHPStan\PhpDocParser\Ast\Type\ObjectShapeItemNode; |
| 62 |
use PHPStan\PhpDocParser\Ast\Type\ObjectShapeNode; |
| 63 |
use PHPStan\PhpDocParser\Ast\Type\OffsetAccessTypeNode; |
| 64 |
use PHPStan\PhpDocParser\Ast\Type\ThisTypeNode; |
| 65 |
use PHPStan\PhpDocParser\Ast\Type\TypeNode; |
| 66 |
use PHPStan\PhpDocParser\Ast\Type\UnionTypeNode; |
| 67 |
use PHPStan\PhpDocParser\Lexer\Lexer; |
| 68 |
use PHPStan\PhpDocParser\Parser\TokenIterator; |
| 69 |
use function array_keys; |
| 70 |
use function array_map; |
| 71 |
use function assert; |
| 72 |
use function count; |
| 73 |
use function get_class; |
| 74 |
use function get_object_vars; |
| 75 |
use function implode; |
| 76 |
use function in_array; |
| 77 |
use function is_array; |
| 78 |
use function preg_match_all; |
| 79 |
use function sprintf; |
| 80 |
use function str_replace; |
| 81 |
use function strlen; |
| 82 |
use function strpos; |
| 83 |
use function trim; |
| 84 |
use const PREG_SET_ORDER; |
| 85 |
|
| 86 |
/** |
| 87 |
* Inspired by https://github.com/nikic/PHP-Parser/tree/36a6dcd04e7b0285e8f0868f44bd4927802f7df1 |
| 88 |
* |
| 89 |
* Copyright (c) 2011, Nikita Popov |
| 90 |
* All rights reserved. |
| 91 |
*/ |
| 92 |
final class Printer |
| 93 |
{ |
| 94 |
|
| 95 |
/** @var Differ<Node> */ |
| 96 |
private Differ $differ; |
| 97 |
|
| 98 |
/** |
| 99 |
* Map From "{$class}->{$subNode}" to string that should be inserted |
| 100 |
* between elements of this list subnode |
| 101 |
* |
| 102 |
* @var array<string, string> |
| 103 |
*/ |
| 104 |
private array $listInsertionMap = [ |
| 105 |
PhpDocNode::class . '->children' => "\n * ", |
| 106 |
UnionTypeNode::class . '->types' => '|', |
| 107 |
IntersectionTypeNode::class . '->types' => '&', |
| 108 |
ArrayShapeNode::class . '->items' => ', ', |
| 109 |
ObjectShapeNode::class . '->items' => ', ', |
| 110 |
CallableTypeNode::class . '->parameters' => ', ', |
| 111 |
CallableTypeNode::class . '->templateTypes' => ', ', |
| 112 |
GenericTypeNode::class . '->genericTypes' => ', ', |
| 113 |
ConstExprArrayNode::class . '->items' => ', ', |
| 114 |
MethodTagValueNode::class . '->parameters' => ', ', |
| 115 |
DoctrineArray::class . '->items' => ', ', |
| 116 |
DoctrineAnnotation::class . '->arguments' => ', ', |
| 117 |
]; |
| 118 |
|
| 119 |
/** |
| 120 |
* [$find, $extraLeft, $extraRight] |
| 121 |
* |
| 122 |
* @var array<string, array{string|null, string, string}> |
| 123 |
*/ |
| 124 |
private array $emptyListInsertionMap = [ |
| 125 |
CallableTypeNode::class . '->parameters' => ['(', '', ''], |
| 126 |
ArrayShapeNode::class . '->items' => ['{', '', ''], |
| 127 |
ObjectShapeNode::class . '->items' => ['{', '', ''], |
| 128 |
DoctrineArray::class . '->items' => ['{', '', ''], |
| 129 |
DoctrineAnnotation::class . '->arguments' => ['(', '', ''], |
| 130 |
]; |
| 131 |
|
| 132 |
/** @var array<string, list<class-string<TypeNode>>> */ |
| 133 |
private array $parenthesesMap = [ |
| 134 |
CallableTypeNode::class . '->returnType' => [ |
| 135 |
CallableTypeNode::class, |
| 136 |
UnionTypeNode::class, |
| 137 |
IntersectionTypeNode::class, |
| 138 |
], |
| 139 |
ArrayTypeNode::class . '->type' => [ |
| 140 |
CallableTypeNode::class, |
| 141 |
UnionTypeNode::class, |
| 142 |
IntersectionTypeNode::class, |
| 143 |
ConstTypeNode::class, |
| 144 |
NullableTypeNode::class, |
| 145 |
], |
| 146 |
OffsetAccessTypeNode::class . '->type' => [ |
| 147 |
CallableTypeNode::class, |
| 148 |
UnionTypeNode::class, |
| 149 |
IntersectionTypeNode::class, |
| 150 |
NullableTypeNode::class, |
| 151 |
], |
| 152 |
]; |
| 153 |
|
| 154 |
/** @var array<string, list<class-string<TypeNode>>> */ |
| 155 |
private array $parenthesesListMap = [ |
| 156 |
IntersectionTypeNode::class . '->types' => [ |
| 157 |
IntersectionTypeNode::class, |
| 158 |
UnionTypeNode::class, |
| 159 |
NullableTypeNode::class, |
| 160 |
], |
| 161 |
UnionTypeNode::class . '->types' => [ |
| 162 |
IntersectionTypeNode::class, |
| 163 |
UnionTypeNode::class, |
| 164 |
NullableTypeNode::class, |
| 165 |
], |
| 166 |
]; |
| 167 |
|
| 168 |
public function printFormatPreserving(PhpDocNode $node, PhpDocNode $originalNode, TokenIterator $originalTokens): string |
| 169 |
{ |
| 170 |
$this->differ = new Differ(static function ($a, $b) { |
| 171 |
if ($a instanceof Node && $b instanceof Node) { |
| 172 |
return $a === $b->getAttribute(Attribute::ORIGINAL_NODE); |
| 173 |
} |
| 174 |
|
| 175 |
return false; |
| 176 |
}); |
| 177 |
|
| 178 |
$tokenIndex = 0; |
| 179 |
$result = $this->printArrayFormatPreserving( |
| 180 |
$node->children, |
| 181 |
$originalNode->children, |
| 182 |
$originalTokens, |
| 183 |
$tokenIndex, |
| 184 |
PhpDocNode::class, |
| 185 |
'children', |
| 186 |
); |
| 187 |
if ($result !== null) { |
| 188 |
return $result . $originalTokens->getContentBetween($tokenIndex, $originalTokens->getTokenCount()); |
| 189 |
} |
| 190 |
|
| 191 |
return $this->print($node); |
| 192 |
} |
| 193 |
|
| 194 |
public function print(Node $node): string |
| 195 |
{ |
| 196 |
if ($node instanceof PhpDocNode) { |
| 197 |
return "/**\n *" . implode("\n *", array_map( |
| 198 |
function (PhpDocChildNode $child): string { |
| 199 |
$s = $this->print($child); |
| 200 |
return $s === '' ? '' : ' ' . $s; |
| 201 |
}, |
| 202 |
$node->children, |
| 203 |
)) . "\n */"; |
| 204 |
} |
| 205 |
if ($node instanceof PhpDocTextNode) { |
| 206 |
return $node->text; |
| 207 |
} |
| 208 |
if ($node instanceof PhpDocTagNode) { |
| 209 |
if ($node->value instanceof DoctrineTagValueNode) { |
| 210 |
return $this->print($node->value); |
| 211 |
} |
| 212 |
|
| 213 |
return trim(sprintf('%s %s', $node->name, $this->print($node->value))); |
| 214 |
} |
| 215 |
if ($node instanceof PhpDocTagValueNode) { |
| 216 |
return $this->printTagValue($node); |
| 217 |
} |
| 218 |
if ($node instanceof TypeNode) { |
| 219 |
return $this->printType($node); |
| 220 |
} |
| 221 |
if ($node instanceof ConstExprNode) { |
| 222 |
return $this->printConstExpr($node); |
| 223 |
} |
| 224 |
if ($node instanceof MethodTagValueParameterNode) { |
| 225 |
$type = $node->type !== null ? $this->print($node->type) . ' ' : ''; |
| 226 |
$isReference = $node->isReference ? '&' : ''; |
| 227 |
$isVariadic = $node->isVariadic ? '...' : ''; |
| 228 |
$default = $node->defaultValue !== null ? ' = ' . $this->print($node->defaultValue) : ''; |
| 229 |
return "{$type}{$isReference}{$isVariadic}{$node->parameterName}{$default}"; |
| 230 |
} |
| 231 |
if ($node instanceof CallableTypeParameterNode) { |
| 232 |
$type = $this->print($node->type) . ' '; |
| 233 |
$isReference = $node->isReference ? '&' : ''; |
| 234 |
$isVariadic = $node->isVariadic ? '...' : ''; |
| 235 |
$isOptional = $node->isOptional ? '=' : ''; |
| 236 |
return trim("{$type}{$isReference}{$isVariadic}{$node->parameterName}") . $isOptional; |
| 237 |
} |
| 238 |
if ($node instanceof ArrayShapeUnsealedTypeNode) { |
| 239 |
if ($node->keyType !== null) { |
| 240 |
return sprintf('<%s, %s>', $this->printType($node->keyType), $this->printType($node->valueType)); |
| 241 |
} |
| 242 |
return sprintf('<%s>', $this->printType($node->valueType)); |
| 243 |
} |
| 244 |
if ($node instanceof DoctrineAnnotation) { |
| 245 |
return (string) $node; |
| 246 |
} |
| 247 |
if ($node instanceof DoctrineArgument) { |
| 248 |
return (string) $node; |
| 249 |
} |
| 250 |
if ($node instanceof DoctrineArray) { |
| 251 |
return (string) $node; |
| 252 |
} |
| 253 |
if ($node instanceof DoctrineArrayItem) { |
| 254 |
return (string) $node; |
| 255 |
} |
| 256 |
if ($node instanceof ArrayShapeItemNode) { |
| 257 |
if ($node->keyName !== null) { |
| 258 |
return sprintf( |
| 259 |
'%s%s: %s', |
| 260 |
$this->print($node->keyName), |
| 261 |
$node->optional ? '?' : '', |
| 262 |
$this->printType($node->valueType), |
| 263 |
); |
| 264 |
} |
| 265 |
|
| 266 |
return $this->printType($node->valueType); |
| 267 |
} |
| 268 |
if ($node instanceof ObjectShapeItemNode) { |
| 269 |
if ($node->keyName !== null) { |
| 270 |
return sprintf( |
| 271 |
'%s%s: %s', |
| 272 |
$this->print($node->keyName), |
| 273 |
$node->optional ? '?' : '', |
| 274 |
$this->printType($node->valueType), |
| 275 |
); |
| 276 |
} |
| 277 |
|
| 278 |
return $this->printType($node->valueType); |
| 279 |
} |
| 280 |
|
| 281 |
throw new LogicException(sprintf('Unknown node type %s', get_class($node))); |
| 282 |
} |
| 283 |
|
| 284 |
private function printTagValue(PhpDocTagValueNode $node): string |
| 285 |
{ |
| 286 |
// only nodes that contain another node are handled here |
| 287 |
// the rest falls back on (string) $node |
| 288 |
|
| 289 |
if ($node instanceof AssertTagMethodValueNode) { |
| 290 |
$isNegated = $node->isNegated ? '!' : ''; |
| 291 |
$isEquality = $node->isEquality ? '=' : ''; |
| 292 |
$type = $this->printType($node->type); |
| 293 |
return trim("{$isNegated}{$isEquality}{$type} {$node->parameter}->{$node->method}() {$node->description}"); |
| 294 |
} |
| 295 |
if ($node instanceof AssertTagPropertyValueNode) { |
| 296 |
$isNegated = $node->isNegated ? '!' : ''; |
| 297 |
$isEquality = $node->isEquality ? '=' : ''; |
| 298 |
$type = $this->printType($node->type); |
| 299 |
return trim("{$isNegated}{$isEquality}{$type} {$node->parameter}->{$node->property} {$node->description}"); |
| 300 |
} |
| 301 |
if ($node instanceof AssertTagValueNode) { |
| 302 |
$isNegated = $node->isNegated ? '!' : ''; |
| 303 |
$isEquality = $node->isEquality ? '=' : ''; |
| 304 |
$type = $this->printType($node->type); |
| 305 |
return trim("{$isNegated}{$isEquality}{$type} {$node->parameter} {$node->description}"); |
| 306 |
} |
| 307 |
if ($node instanceof ExtendsTagValueNode || $node instanceof ImplementsTagValueNode) { |
| 308 |
$type = $this->printType($node->type); |
| 309 |
return trim("{$type} {$node->description}"); |
| 310 |
} |
| 311 |
if ($node instanceof MethodTagValueNode) { |
| 312 |
$static = $node->isStatic ? 'static ' : ''; |
| 313 |
$returnType = $node->returnType !== null ? $this->printType($node->returnType) . ' ' : ''; |
| 314 |
$parameters = implode(', ', array_map(fn (MethodTagValueParameterNode $parameter): string => $this->print($parameter), $node->parameters)); |
| 315 |
$description = $node->description !== '' ? " {$node->description}" : ''; |
| 316 |
$templateTypes = count($node->templateTypes) > 0 ? '<' . implode(', ', array_map(fn (TemplateTagValueNode $templateTag): string => $this->print($templateTag), $node->templateTypes)) . '>' : ''; |
| 317 |
return "{$static}{$returnType}{$node->methodName}{$templateTypes}({$parameters}){$description}"; |
| 318 |
} |
| 319 |
if ($node instanceof MixinTagValueNode) { |
| 320 |
$type = $this->printType($node->type); |
| 321 |
return trim("{$type} {$node->description}"); |
| 322 |
} |
| 323 |
if ($node instanceof RequireExtendsTagValueNode) { |
| 324 |
$type = $this->printType($node->type); |
| 325 |
return trim("{$type} {$node->description}"); |
| 326 |
} |
| 327 |
if ($node instanceof RequireImplementsTagValueNode) { |
| 328 |
$type = $this->printType($node->type); |
| 329 |
return trim("{$type} {$node->description}"); |
| 330 |
} |
| 331 |
if ($node instanceof SealedTagValueNode) { |
| 332 |
$type = $this->printType($node->type); |
| 333 |
return trim("{$type} {$node->description}"); |
| 334 |
} |
| 335 |
if ($node instanceof ParamOutTagValueNode) { |
| 336 |
$type = $this->printType($node->type); |
| 337 |
return trim("{$type} {$node->parameterName} {$node->description}"); |
| 338 |
} |
| 339 |
if ($node instanceof ParamTagValueNode) { |
| 340 |
$reference = $node->isReference ? '&' : ''; |
| 341 |
$variadic = $node->isVariadic ? '...' : ''; |
| 342 |
$type = $this->printType($node->type); |
| 343 |
return trim("{$type} {$reference}{$variadic}{$node->parameterName} {$node->description}"); |
| 344 |
} |
| 345 |
if ($node instanceof ParamImmediatelyInvokedCallableTagValueNode) { |
| 346 |
return trim("{$node->parameterName} {$node->description}"); |
| 347 |
} |
| 348 |
if ($node instanceof ParamLaterInvokedCallableTagValueNode) { |
| 349 |
return trim("{$node->parameterName} {$node->description}"); |
| 350 |
} |
| 351 |
if ($node instanceof ParamClosureThisTagValueNode) { |
| 352 |
return trim("{$node->type} {$node->parameterName} {$node->description}"); |
| 353 |
} |
| 354 |
if ($node instanceof PureUnlessCallableIsImpureTagValueNode) { |
| 355 |
return trim("{$node->parameterName} {$node->description}"); |
| 356 |
} |
| 357 |
if ($node instanceof PropertyTagValueNode) { |
| 358 |
$type = $this->printType($node->type); |
| 359 |
return trim("{$type} {$node->propertyName} {$node->description}"); |
| 360 |
} |
| 361 |
if ($node instanceof ReturnTagValueNode) { |
| 362 |
$type = $this->printType($node->type); |
| 363 |
return trim("{$type} {$node->description}"); |
| 364 |
} |
| 365 |
if ($node instanceof SelfOutTagValueNode) { |
| 366 |
$type = $this->printType($node->type); |
| 367 |
return trim($type . ' ' . $node->description); |
| 368 |
} |
| 369 |
if ($node instanceof TemplateTagValueNode) { |
| 370 |
$upperBound = $node->bound !== null ? ' of ' . $this->printType($node->bound) : ''; |
| 371 |
$lowerBound = $node->lowerBound !== null ? ' super ' . $this->printType($node->lowerBound) : ''; |
| 372 |
$default = $node->default !== null ? ' = ' . $this->printType($node->default) : ''; |
| 373 |
return trim("{$node->name}{$upperBound}{$lowerBound}{$default} {$node->description}"); |
| 374 |
} |
| 375 |
if ($node instanceof ThrowsTagValueNode) { |
| 376 |
$type = $this->printType($node->type); |
| 377 |
return trim("{$type} {$node->description}"); |
| 378 |
} |
| 379 |
if ($node instanceof TypeAliasImportTagValueNode) { |
| 380 |
return trim( |
| 381 |
"{$node->importedAlias} from " . $this->printType($node->importedFrom) |
| 382 |
. ($node->importedAs !== null ? " as {$node->importedAs}" : ''), |
| 383 |
); |
| 384 |
} |
| 385 |
if ($node instanceof TypeAliasTagValueNode) { |
| 386 |
$type = $this->printType($node->type); |
| 387 |
return trim("{$node->alias} {$type}"); |
| 388 |
} |
| 389 |
if ($node instanceof UsesTagValueNode) { |
| 390 |
$type = $this->printType($node->type); |
| 391 |
return trim("{$type} {$node->description}"); |
| 392 |
} |
| 393 |
if ($node instanceof VarTagValueNode) { |
| 394 |
$type = $this->printType($node->type); |
| 395 |
return trim("{$type} " . trim("{$node->variableName} {$node->description}")); |
| 396 |
} |
| 397 |
|
| 398 |
return (string) $node; |
| 399 |
} |
| 400 |
|
| 401 |
private function printType(TypeNode $node): string |
| 402 |
{ |
| 403 |
if ($node instanceof ArrayShapeNode) { |
| 404 |
$items = array_map(fn (ArrayShapeItemNode $item): string => $this->print($item), $node->items); |
| 405 |
|
| 406 |
if (! $node->sealed) { |
| 407 |
$items[] = '...' . ($node->unsealedType === null ? '' : $this->print($node->unsealedType)); |
| 408 |
} |
| 409 |
|
| 410 |
return $node->kind . '{' . implode(', ', $items) . '}'; |
| 411 |
} |
| 412 |
if ($node instanceof ArrayTypeNode) { |
| 413 |
return $this->printOffsetAccessType($node->type) . '[]'; |
| 414 |
} |
| 415 |
if ($node instanceof CallableTypeNode) { |
| 416 |
if ($node->returnType instanceof CallableTypeNode || $node->returnType instanceof UnionTypeNode || $node->returnType instanceof IntersectionTypeNode) { |
| 417 |
$returnType = $this->wrapInParentheses($node->returnType); |
| 418 |
} else { |
| 419 |
$returnType = $this->printType($node->returnType); |
| 420 |
} |
| 421 |
$template = $node->templateTypes !== [] |
| 422 |
? '<' . implode(', ', array_map(fn (TemplateTagValueNode $templateNode): string => $this->print($templateNode), $node->templateTypes)) . '>' |
| 423 |
: ''; |
| 424 |
$parameters = implode(', ', array_map(fn (CallableTypeParameterNode $parameterNode): string => $this->print($parameterNode), $node->parameters)); |
| 425 |
return "{$node->identifier}{$template}({$parameters}): {$returnType}"; |
| 426 |
} |
| 427 |
if ($node instanceof ConditionalTypeForParameterNode) { |
| 428 |
return sprintf( |
| 429 |
'(%s %s %s ? %s : %s)', |
| 430 |
$node->parameterName, |
| 431 |
$node->negated ? 'is not' : 'is', |
| 432 |
$this->printType($node->targetType), |
| 433 |
$this->printType($node->if), |
| 434 |
$this->printType($node->else), |
| 435 |
); |
| 436 |
} |
| 437 |
if ($node instanceof ConditionalTypeNode) { |
| 438 |
return sprintf( |
| 439 |
'(%s %s %s ? %s : %s)', |
| 440 |
$this->printType($node->subjectType), |
| 441 |
$node->negated ? 'is not' : 'is', |
| 442 |
$this->printType($node->targetType), |
| 443 |
$this->printType($node->if), |
| 444 |
$this->printType($node->else), |
| 445 |
); |
| 446 |
} |
| 447 |
if ($node instanceof ConstTypeNode) { |
| 448 |
return $this->printConstExpr($node->constExpr); |
| 449 |
} |
| 450 |
if ($node instanceof GenericTypeNode) { |
| 451 |
$genericTypes = []; |
| 452 |
|
| 453 |
foreach ($node->genericTypes as $index => $type) { |
| 454 |
$variance = $node->variances[$index] ?? GenericTypeNode::VARIANCE_INVARIANT; |
| 455 |
if ($variance === GenericTypeNode::VARIANCE_INVARIANT) { |
| 456 |
$genericTypes[] = $this->printType($type); |
| 457 |
} elseif ($variance === GenericTypeNode::VARIANCE_BIVARIANT) { |
| 458 |
$genericTypes[] = '*'; |
| 459 |
} else { |
| 460 |
$genericTypes[] = sprintf('%s %s', $variance, $this->print($type)); |
| 461 |
} |
| 462 |
} |
| 463 |
|
| 464 |
return $node->type . '<' . implode(', ', $genericTypes) . '>'; |
| 465 |
} |
| 466 |
if ($node instanceof IdentifierTypeNode) { |
| 467 |
return $node->name; |
| 468 |
} |
| 469 |
if ($node instanceof IntersectionTypeNode || $node instanceof UnionTypeNode) { |
| 470 |
$items = []; |
| 471 |
foreach ($node->types as $type) { |
| 472 |
if ( |
| 473 |
$type instanceof IntersectionTypeNode |
| 474 |
|| $type instanceof UnionTypeNode |
| 475 |
|| $type instanceof NullableTypeNode |
| 476 |
) { |
| 477 |
$items[] = $this->wrapInParentheses($type); |
| 478 |
continue; |
| 479 |
} |
| 480 |
|
| 481 |
$items[] = $this->printType($type); |
| 482 |
} |
| 483 |
|
| 484 |
return implode($node instanceof IntersectionTypeNode ? '&' : '|', $items); |
| 485 |
} |
| 486 |
if ($node instanceof InvalidTypeNode) { |
| 487 |
return (string) $node; |
| 488 |
} |
| 489 |
if ($node instanceof NullableTypeNode) { |
| 490 |
if ($node->type instanceof IntersectionTypeNode || $node->type instanceof UnionTypeNode) { |
| 491 |
return '?(' . $this->printType($node->type) . ')'; |
| 492 |
} |
| 493 |
|
| 494 |
return '?' . $this->printType($node->type); |
| 495 |
} |
| 496 |
if ($node instanceof ObjectShapeNode) { |
| 497 |
$items = array_map(fn (ObjectShapeItemNode $item): string => $this->print($item), $node->items); |
| 498 |
|
| 499 |
return 'object{' . implode(', ', $items) . '}'; |
| 500 |
} |
| 501 |
if ($node instanceof OffsetAccessTypeNode) { |
| 502 |
return $this->printOffsetAccessType($node->type) . '[' . $this->printType($node->offset) . ']'; |
| 503 |
} |
| 504 |
if ($node instanceof ThisTypeNode) { |
| 505 |
return (string) $node; |
| 506 |
} |
| 507 |
|
| 508 |
throw new LogicException(sprintf('Unknown node type %s', get_class($node))); |
| 509 |
} |
| 510 |
|
| 511 |
private function wrapInParentheses(TypeNode $node): string |
| 512 |
{ |
| 513 |
return '(' . $this->printType($node) . ')'; |
| 514 |
} |
| 515 |
|
| 516 |
private function printOffsetAccessType(TypeNode $type): string |
| 517 |
{ |
| 518 |
if ( |
| 519 |
$type instanceof CallableTypeNode |
| 520 |
|| $type instanceof UnionTypeNode |
| 521 |
|| $type instanceof IntersectionTypeNode |
| 522 |
|| $type instanceof NullableTypeNode |
| 523 |
) { |
| 524 |
return $this->wrapInParentheses($type); |
| 525 |
} |
| 526 |
|
| 527 |
return $this->printType($type); |
| 528 |
} |
| 529 |
|
| 530 |
private function printConstExpr(ConstExprNode $node): string |
| 531 |
{ |
| 532 |
// this is fine - ConstExprNode classes do not contain nodes that need smart printer logic |
| 533 |
return (string) $node; |
| 534 |
} |
| 535 |
|
| 536 |
/** |
| 537 |
* @param Node[] $nodes |
| 538 |
* @param Node[] $originalNodes |
| 539 |
*/ |
| 540 |
private function printArrayFormatPreserving(array $nodes, array $originalNodes, TokenIterator $originalTokens, int &$tokenIndex, string $parentNodeClass, string $subNodeName): ?string |
| 541 |
{ |
| 542 |
$diff = $this->differ->diffWithReplacements($originalNodes, $nodes); |
| 543 |
$mapKey = $parentNodeClass . '->' . $subNodeName; |
| 544 |
$insertStr = $this->listInsertionMap[$mapKey] ?? null; |
| 545 |
$result = ''; |
| 546 |
$beforeFirstKeepOrReplace = true; |
| 547 |
$delayedAdd = []; |
| 548 |
|
| 549 |
$insertNewline = false; |
| 550 |
[$isMultiline, $beforeAsteriskIndent, $afterAsteriskIndent] = $this->isMultiline($tokenIndex, $originalNodes, $originalTokens); |
| 551 |
|
| 552 |
if ($insertStr === "\n * ") { |
| 553 |
$insertStr = sprintf('%s%s*%s', $originalTokens->getDetectedNewline() ?? "\n", $beforeAsteriskIndent, $afterAsteriskIndent); |
| 554 |
} |
| 555 |
|
| 556 |
foreach ($diff as $i => $diffElem) { |
| 557 |
$diffType = $diffElem->type; |
| 558 |
$arrItem = $diffElem->new; |
| 559 |
$origArrayItem = $diffElem->old; |
| 560 |
if ($diffType === DiffElem::TYPE_KEEP || $diffType === DiffElem::TYPE_REPLACE) { |
| 561 |
$beforeFirstKeepOrReplace = false; |
| 562 |
if (!$arrItem instanceof Node || !$origArrayItem instanceof Node) { |
| 563 |
return null; |
| 564 |
} |
| 565 |
|
| 566 |
/** @var int $itemStartPos */ |
| 567 |
$itemStartPos = $origArrayItem->getAttribute(Attribute::START_INDEX); |
| 568 |
|
| 569 |
/** @var int $itemEndPos */ |
| 570 |
$itemEndPos = $origArrayItem->getAttribute(Attribute::END_INDEX); |
| 571 |
|
| 572 |
if ($itemStartPos < 0 || $itemEndPos < 0 || $itemStartPos < $tokenIndex) { |
| 573 |
throw new LogicException(); |
| 574 |
} |
| 575 |
|
| 576 |
$comments = $arrItem->getAttribute(Attribute::COMMENTS) ?? []; |
| 577 |
$origComments = $origArrayItem->getAttribute(Attribute::COMMENTS) ?? []; |
| 578 |
|
| 579 |
$commentStartPos = count($origComments) > 0 ? $origComments[0]->startIndex : $itemStartPos; |
| 580 |
assert($commentStartPos >= 0); |
| 581 |
|
| 582 |
$result .= $originalTokens->getContentBetween($tokenIndex, $itemStartPos); |
| 583 |
|
| 584 |
if (count($delayedAdd) > 0) { |
| 585 |
foreach ($delayedAdd as $delayedAddNode) { |
| 586 |
$parenthesesNeeded = isset($this->parenthesesListMap[$mapKey]) |
| 587 |
&& in_array(get_class($delayedAddNode), $this->parenthesesListMap[$mapKey], true); |
| 588 |
if ($parenthesesNeeded) { |
| 589 |
$result .= '('; |
| 590 |
} |
| 591 |
|
| 592 |
if ($insertNewline) { |
| 593 |
$delayedAddComments = $delayedAddNode->getAttribute(Attribute::COMMENTS) ?? []; |
| 594 |
if (count($delayedAddComments) > 0) { |
| 595 |
$result .= $this->printComments($delayedAddComments, $beforeAsteriskIndent, $afterAsteriskIndent); |
| 596 |
$result .= sprintf('%s%s*%s', $originalTokens->getDetectedNewline() ?? "\n", $beforeAsteriskIndent, $afterAsteriskIndent); |
| 597 |
} |
| 598 |
} |
| 599 |
|
| 600 |
$result .= $this->printNodeFormatPreserving($delayedAddNode, $originalTokens); |
| 601 |
if ($parenthesesNeeded) { |
| 602 |
$result .= ')'; |
| 603 |
} |
| 604 |
|
| 605 |
if ($insertNewline) { |
| 606 |
$result .= $insertStr . sprintf('%s%s*%s', $originalTokens->getDetectedNewline() ?? "\n", $beforeAsteriskIndent, $afterAsteriskIndent); |
| 607 |
} else { |
| 608 |
$result .= $insertStr; |
| 609 |
} |
| 610 |
} |
| 611 |
|
| 612 |
$delayedAdd = []; |
| 613 |
} |
| 614 |
|
| 615 |
$parenthesesNeeded = isset($this->parenthesesListMap[$mapKey]) |
| 616 |
&& in_array(get_class($arrItem), $this->parenthesesListMap[$mapKey], true) |
| 617 |
&& !in_array(get_class($origArrayItem), $this->parenthesesListMap[$mapKey], true); |
| 618 |
$addParentheses = $parenthesesNeeded && !$originalTokens->hasParentheses($itemStartPos, $itemEndPos); |
| 619 |
if ($addParentheses) { |
| 620 |
$result .= '('; |
| 621 |
} |
| 622 |
|
| 623 |
if ($comments !== $origComments) { |
| 624 |
if (count($comments) > 0) { |
| 625 |
$result .= $this->printComments($comments, $beforeAsteriskIndent, $afterAsteriskIndent); |
| 626 |
$result .= sprintf('%s%s*%s', $originalTokens->getDetectedNewline() ?? "\n", $beforeAsteriskIndent, $afterAsteriskIndent); |
| 627 |
} |
| 628 |
} |
| 629 |
|
| 630 |
$result .= $this->printNodeFormatPreserving($arrItem, $originalTokens); |
| 631 |
if ($addParentheses) { |
| 632 |
$result .= ')'; |
| 633 |
} |
| 634 |
$tokenIndex = $itemEndPos + 1; |
| 635 |
|
| 636 |
} elseif ($diffType === DiffElem::TYPE_ADD) { |
| 637 |
if ($insertStr === null) { |
| 638 |
return null; |
| 639 |
} |
| 640 |
if (!$arrItem instanceof Node) { |
| 641 |
return null; |
| 642 |
} |
| 643 |
|
| 644 |
if ($insertStr === ', ' && $isMultiline || count($arrItem->getAttribute(Attribute::COMMENTS) ?? []) > 0) { |
| 645 |
$insertStr = ','; |
| 646 |
$insertNewline = true; |
| 647 |
} |
| 648 |
|
| 649 |
if ($beforeFirstKeepOrReplace) { |
| 650 |
// Will be inserted at the next "replace" or "keep" element |
| 651 |
$delayedAdd[] = $arrItem; |
| 652 |
continue; |
| 653 |
} |
| 654 |
|
| 655 |
/** @var int $itemEndPos */ |
| 656 |
$itemEndPos = $tokenIndex - 1; |
| 657 |
if ($insertNewline) { |
| 658 |
$comments = $arrItem->getAttribute(Attribute::COMMENTS) ?? []; |
| 659 |
$result .= $insertStr; |
| 660 |
if (count($comments) > 0) { |
| 661 |
$result .= sprintf('%s%s*%s', $originalTokens->getDetectedNewline() ?? "\n", $beforeAsteriskIndent, $afterAsteriskIndent); |
| 662 |
$result .= $this->printComments($comments, $beforeAsteriskIndent, $afterAsteriskIndent); |
| 663 |
} |
| 664 |
$result .= sprintf('%s%s*%s', $originalTokens->getDetectedNewline() ?? "\n", $beforeAsteriskIndent, $afterAsteriskIndent); |
| 665 |
} else { |
| 666 |
$result .= $insertStr; |
| 667 |
} |
| 668 |
|
| 669 |
$parenthesesNeeded = isset($this->parenthesesListMap[$mapKey]) |
| 670 |
&& in_array(get_class($arrItem), $this->parenthesesListMap[$mapKey], true); |
| 671 |
if ($parenthesesNeeded) { |
| 672 |
$result .= '('; |
| 673 |
} |
| 674 |
|
| 675 |
$result .= $this->printNodeFormatPreserving($arrItem, $originalTokens); |
| 676 |
if ($parenthesesNeeded) { |
| 677 |
$result .= ')'; |
| 678 |
} |
| 679 |
|
| 680 |
$tokenIndex = $itemEndPos + 1; |
| 681 |
|
| 682 |
} elseif ($diffType === DiffElem::TYPE_REMOVE) { |
| 683 |
if (!$origArrayItem instanceof Node) { |
| 684 |
return null; |
| 685 |
} |
| 686 |
|
| 687 |
/** @var int $itemStartPos */ |
| 688 |
$itemStartPos = $origArrayItem->getAttribute(Attribute::START_INDEX); |
| 689 |
|
| 690 |
/** @var int $itemEndPos */ |
| 691 |
$itemEndPos = $origArrayItem->getAttribute(Attribute::END_INDEX); |
| 692 |
if ($itemStartPos < 0 || $itemEndPos < 0) { |
| 693 |
throw new LogicException(); |
| 694 |
} |
| 695 |
|
| 696 |
if ($i === 0) { |
| 697 |
// If we're removing from the start, keep the tokens before the node and drop those after it, |
| 698 |
// instead of the other way around. |
| 699 |
$originalTokensArray = $originalTokens->getTokens(); |
| 700 |
for ($j = $tokenIndex; $j < $itemStartPos; $j++) { |
| 701 |
if ($originalTokensArray[$j][Lexer::TYPE_OFFSET] === Lexer::TOKEN_PHPDOC_EOL) { |
| 702 |
break; |
| 703 |
} |
| 704 |
$result .= $originalTokensArray[$j][Lexer::VALUE_OFFSET]; |
| 705 |
} |
| 706 |
} |
| 707 |
|
| 708 |
$tokenIndex = $itemEndPos + 1; |
| 709 |
} |
| 710 |
} |
| 711 |
|
| 712 |
if (count($delayedAdd) > 0) { |
| 713 |
if (!isset($this->emptyListInsertionMap[$mapKey])) { |
| 714 |
return null; |
| 715 |
} |
| 716 |
|
| 717 |
[$findToken, $extraLeft, $extraRight] = $this->emptyListInsertionMap[$mapKey]; |
| 718 |
if ($findToken !== null) { |
| 719 |
$originalTokensArray = $originalTokens->getTokens(); |
| 720 |
for (; $tokenIndex < count($originalTokensArray); $tokenIndex++) { |
| 721 |
$result .= $originalTokensArray[$tokenIndex][Lexer::VALUE_OFFSET]; |
| 722 |
if ($originalTokensArray[$tokenIndex][Lexer::VALUE_OFFSET] !== $findToken) { |
| 723 |
continue; |
| 724 |
} |
| 725 |
|
| 726 |
$tokenIndex++; |
| 727 |
break; |
| 728 |
} |
| 729 |
} |
| 730 |
$first = true; |
| 731 |
$result .= $extraLeft; |
| 732 |
foreach ($delayedAdd as $delayedAddNode) { |
| 733 |
if (!$first) { |
| 734 |
$result .= $insertStr; |
| 735 |
if ($insertNewline) { |
| 736 |
$result .= sprintf('%s%s*%s', $originalTokens->getDetectedNewline() ?? "\n", $beforeAsteriskIndent, $afterAsteriskIndent); |
| 737 |
} |
| 738 |
} |
| 739 |
|
| 740 |
$result .= $this->printNodeFormatPreserving($delayedAddNode, $originalTokens); |
| 741 |
$first = false; |
| 742 |
} |
| 743 |
$result .= $extraRight; |
| 744 |
} |
| 745 |
|
| 746 |
return $result; |
| 747 |
} |
| 748 |
|
| 749 |
/** |
| 750 |
* @param list<Comment> $comments |
| 751 |
*/ |
| 752 |
private function printComments(array $comments, string $beforeAsteriskIndent, string $afterAsteriskIndent): string |
| 753 |
{ |
| 754 |
$formattedComments = []; |
| 755 |
|
| 756 |
foreach ($comments as $comment) { |
| 757 |
$formattedComments[] = str_replace("\n", "\n" . $beforeAsteriskIndent . '*' . $afterAsteriskIndent, $comment->getReformattedText()); |
| 758 |
} |
| 759 |
|
| 760 |
return implode("\n$beforeAsteriskIndent*$afterAsteriskIndent", $formattedComments); |
| 761 |
} |
| 762 |
|
| 763 |
/** |
| 764 |
* @param array<Node|null> $nodes |
| 765 |
* @return array{bool, string, string} |
| 766 |
*/ |
| 767 |
private function isMultiline(int $initialIndex, array $nodes, TokenIterator $originalTokens): array |
| 768 |
{ |
| 769 |
$isMultiline = count($nodes) > 1; |
| 770 |
$pos = $initialIndex; |
| 771 |
$allText = ''; |
| 772 |
/** @var Node|null $node */ |
| 773 |
foreach ($nodes as $node) { |
| 774 |
if (!$node instanceof Node) { |
| 775 |
continue; |
| 776 |
} |
| 777 |
|
| 778 |
$endPos = $node->getAttribute(Attribute::END_INDEX) + 1; |
| 779 |
$text = $originalTokens->getContentBetween($pos, $endPos); |
| 780 |
$allText .= $text; |
| 781 |
if (strpos($text, "\n") === false) { |
| 782 |
// We require that a newline is present between *every* item. If the formatting |
| 783 |
// is inconsistent, with only some items having newlines, we don't consider it |
| 784 |
// as multiline |
| 785 |
$isMultiline = false; |
| 786 |
} |
| 787 |
$pos = $endPos; |
| 788 |
} |
| 789 |
|
| 790 |
$c = preg_match_all('~\n(?<before>[\\x09\\x20]*)\*(?<after>\\x20*)~', $allText, $matches, PREG_SET_ORDER); |
| 791 |
if ($c === 0) { |
| 792 |
return [$isMultiline, ' ', ' ']; |
| 793 |
} |
| 794 |
|
| 795 |
$before = ''; |
| 796 |
$after = ''; |
| 797 |
foreach ($matches as $match) { |
| 798 |
if (strlen($match['before']) > strlen($before)) { |
| 799 |
$before = $match['before']; |
| 800 |
} |
| 801 |
if (strlen($match['after']) <= strlen($after)) { |
| 802 |
continue; |
| 803 |
} |
| 804 |
|
| 805 |
$after = $match['after']; |
| 806 |
} |
| 807 |
|
| 808 |
$before = strlen($before) === 0 ? ' ' : $before; |
| 809 |
$after = strlen($after) === 0 ? ' ' : $after; |
| 810 |
|
| 811 |
return [$isMultiline, $before, $after]; |
| 812 |
} |
| 813 |
|
| 814 |
private function printNodeFormatPreserving(Node $node, TokenIterator $originalTokens): string |
| 815 |
{ |
| 816 |
/** @var Node|null $originalNode */ |
| 817 |
$originalNode = $node->getAttribute(Attribute::ORIGINAL_NODE); |
| 818 |
if ($originalNode === null) { |
| 819 |
return $this->print($node); |
| 820 |
} |
| 821 |
|
| 822 |
$class = get_class($node); |
| 823 |
if ($class !== get_class($originalNode)) { |
| 824 |
throw new LogicException(); |
| 825 |
} |
| 826 |
|
| 827 |
$startPos = $originalNode->getAttribute(Attribute::START_INDEX); |
| 828 |
$endPos = $originalNode->getAttribute(Attribute::END_INDEX); |
| 829 |
if ($startPos < 0 || $endPos < 0) { |
| 830 |
throw new LogicException(); |
| 831 |
} |
| 832 |
|
| 833 |
$result = ''; |
| 834 |
$pos = $startPos; |
| 835 |
$subNodeNames = array_keys(get_object_vars($node)); |
| 836 |
foreach ($subNodeNames as $subNodeName) { |
| 837 |
$subNode = $node->$subNodeName; |
| 838 |
$origSubNode = $originalNode->$subNodeName; |
| 839 |
|
| 840 |
if ( |
| 841 |
(!$subNode instanceof Node && $subNode !== null) |
| 842 |
|| (!$origSubNode instanceof Node && $origSubNode !== null) |
| 843 |
) { |
| 844 |
if ($subNode === $origSubNode) { |
| 845 |
// Unchanged, can reuse old code |
| 846 |
continue; |
| 847 |
} |
| 848 |
|
| 849 |
if (is_array($subNode) && is_array($origSubNode)) { |
| 850 |
// Array subnode changed, we might be able to reconstruct it |
| 851 |
$listResult = $this->printArrayFormatPreserving( |
| 852 |
$subNode, |
| 853 |
$origSubNode, |
| 854 |
$originalTokens, |
| 855 |
$pos, |
| 856 |
$class, |
| 857 |
$subNodeName, |
| 858 |
); |
| 859 |
|
| 860 |
if ($listResult === null) { |
| 861 |
return $this->print($node); |
| 862 |
} |
| 863 |
|
| 864 |
$result .= $listResult; |
| 865 |
continue; |
| 866 |
} |
| 867 |
|
| 868 |
return $this->print($node); |
| 869 |
} |
| 870 |
|
| 871 |
if ($origSubNode === null) { |
| 872 |
if ($subNode === null) { |
| 873 |
// Both null, nothing to do |
| 874 |
continue; |
| 875 |
} |
| 876 |
|
| 877 |
return $this->print($node); |
| 878 |
} |
| 879 |
|
| 880 |
$subStartPos = $origSubNode->getAttribute(Attribute::START_INDEX); |
| 881 |
$subEndPos = $origSubNode->getAttribute(Attribute::END_INDEX); |
| 882 |
if ($subStartPos < 0 || $subEndPos < 0) { |
| 883 |
throw new LogicException(); |
| 884 |
} |
| 885 |
|
| 886 |
if ($subEndPos < $subStartPos) { |
| 887 |
return $this->print($node); |
| 888 |
} |
| 889 |
|
| 890 |
if ($subNode === null) { |
| 891 |
return $this->print($node); |
| 892 |
} |
| 893 |
|
| 894 |
$result .= $originalTokens->getContentBetween($pos, $subStartPos); |
| 895 |
$mapKey = get_class($node) . '->' . $subNodeName; |
| 896 |
$parenthesesNeeded = isset($this->parenthesesMap[$mapKey]) |
| 897 |
&& in_array(get_class($subNode), $this->parenthesesMap[$mapKey], true); |
| 898 |
|
| 899 |
if ($subNode->getAttribute(Attribute::ORIGINAL_NODE) !== null) { |
| 900 |
$parenthesesNeeded = $parenthesesNeeded |
| 901 |
&& !in_array(get_class($subNode->getAttribute(Attribute::ORIGINAL_NODE)), $this->parenthesesMap[$mapKey], true); |
| 902 |
} |
| 903 |
|
| 904 |
$addParentheses = $parenthesesNeeded && !$originalTokens->hasParentheses($subStartPos, $subEndPos); |
| 905 |
if ($addParentheses) { |
| 906 |
$result .= '('; |
| 907 |
} |
| 908 |
|
| 909 |
$result .= $this->printNodeFormatPreserving($subNode, $originalTokens); |
| 910 |
if ($addParentheses) { |
| 911 |
$result .= ')'; |
| 912 |
} |
| 913 |
|
| 914 |
$pos = $subEndPos + 1; |
| 915 |
} |
| 916 |
|
| 917 |
return $result . $originalTokens->getContentBetween($pos, $endPos + 1); |
| 918 |
} |
| 919 |
|
| 920 |
} |