promotedPropertyCandidateResolver = $promotedPropertyCandidateResolver; $this->variableRenamer = $variableRenamer; $this->paramAnalyzer = $paramAnalyzer; $this->propertyPromotionDocBlockMerger = $propertyPromotionDocBlockMerger; $this->makePropertyPromotionGuard = $makePropertyPromotionGuard; $this->typeComparator = $typeComparator; $this->reflectionResolver = $reflectionResolver; $this->propertyPromotionRenamer = $propertyPromotionRenamer; $this->phpDocInfoFactory = $phpDocInfoFactory; $this->staticTypeMapper = $staticTypeMapper; } public function getRuleDefinition() : RuleDefinition { return new RuleDefinition('Change simple property init and assign to constructor promotion', [new ConfiguredCodeSample(<<<'CODE_SAMPLE' class SomeClass { public float $price; public function __construct( float $price = 0.0 ) { $this->price = $price; } } CODE_SAMPLE , <<<'CODE_SAMPLE' class SomeClass { public function __construct( public float $price = 0.0 ) { } } CODE_SAMPLE , [self::INLINE_PUBLIC => \false, self::RENAME_PROPERTY => \true])]); } public function configure(array $configuration) : void { $this->inlinePublic = $configuration[self::INLINE_PUBLIC] ?? \false; $this->renameProperty = $configuration[self::RENAME_PROPERTY] ?? \true; } /** * @return array> */ public function getNodeTypes() : array { return [Class_::class]; } /** * @param Class_ $node */ public function refactor(Node $node) : ?Node { $constructClassMethod = $node->getMethod(MethodName::CONSTRUCT); if (!$constructClassMethod instanceof ClassMethod) { return null; } $promotionCandidates = $this->promotedPropertyCandidateResolver->resolveFromClass($node, $constructClassMethod); if ($promotionCandidates === []) { return null; } $constructorPhpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($constructClassMethod); $classReflection = $this->reflectionResolver->resolveClassReflection($node); if (!$classReflection instanceof ClassReflection) { return null; } foreach ($promotionCandidates as $promotionCandidate) { $param = $promotionCandidate->getParam(); if ($this->shouldSkipParam($param)) { continue; } $property = $promotionCandidate->getProperty(); if (!$this->makePropertyPromotionGuard->isLegal($node, $classReflection, $property, $param, $this->inlinePublic)) { continue; } $paramName = $this->getName($param); // rename also following calls $propertyName = $this->getName($property->props[0]); if (!$this->renameProperty && $paramName !== $propertyName) { continue; } // remove property from class $propertyStmtKey = $property->getAttribute(AttributeKey::STMT_KEY); unset($node->stmts[$propertyStmtKey]); // remove assign in constructor $assignStmtPosition = $promotionCandidate->getStmtPosition(); unset($constructClassMethod->stmts[$assignStmtPosition]); /** @var string $oldName */ $oldName = $this->getName($param->var); $this->variableRenamer->renameVariableInFunctionLike($constructClassMethod, $oldName, $propertyName, null); $paramTagValueNode = $constructorPhpDocInfo->getParamTagValueByName($paramName); if (!$paramTagValueNode instanceof ParamTagValueNode) { $this->propertyPromotionDocBlockMerger->decorateParamWithPropertyPhpDocInfo($constructClassMethod, $property, $param, $paramName); } elseif ($paramTagValueNode->parameterName !== '$' . $propertyName) { $this->propertyPromotionRenamer->renameParamDoc($constructorPhpDocInfo, $constructClassMethod, $param, $paramTagValueNode->parameterName, $propertyName); } // property name has higher priority $paramName = $this->getName($property); $param->var = new Variable($paramName); $param->flags = $property->flags; // copy attributes of the old property $param->attrGroups = \array_merge($param->attrGroups, $property->attrGroups); $this->processUnionType($property, $param); $this->propertyPromotionDocBlockMerger->mergePropertyAndParamDocBlocks($property, $param, $paramTagValueNode); // update variable to property fetch references $this->traverseNodesWithCallable((array) $constructClassMethod->stmts, function (Node $node) use($promotionCandidate, $propertyName) : ?PropertyFetch { if (!$node instanceof Variable) { return null; } if (!$this->isName($node, $promotionCandidate->getParamName())) { return null; } return new PropertyFetch(new Variable('this'), $propertyName); }); } return $node; } public function provideMinPhpVersion() : int { return PhpVersionFeature::PROPERTY_PROMOTION; } private function processUnionType(Property $property, Param $param) : void { if ($property->type instanceof Node) { $param->type = $property->type; return; } if (!$param->default instanceof Expr) { return; } if (!$param->type instanceof Node) { return; } $defaultType = $this->getType($param->default); $paramType = $this->getType($param->type); if ($this->typeComparator->isSubtype($defaultType, $paramType)) { return; } if ($this->typeComparator->areTypesEqual($defaultType, $paramType)) { return; } if ($paramType instanceof MixedType) { return; } $paramType = TypeCombinator::union($paramType, $defaultType); $param->type = $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode($paramType, TypeKind::PARAM); } private function shouldSkipParam(Param $param) : bool { if ($param->variadic) { return \true; } if ($this->paramAnalyzer->isNullable($param)) { /** @var NullableType $type */ $type = $param->type; $type = $type->type; } else { $type = $param->type; } if ($this->isCallableTypeIdentifier($type)) { return \true; } if (!$type instanceof UnionType) { return \false; } foreach ($type->types as $type) { if ($this->isCallableTypeIdentifier($type)) { return \true; } } return \false; } private function isCallableTypeIdentifier(?Node $node) : bool { return $node instanceof Identifier && $this->isName($node, 'callable'); } }