rectorphp/rector

10→8 BetterPhpDocParser.PhpDocInfo uses StaticTypeMapper✕

Connections

2 pairs of types, where a type in BetterPhpDocParser.PhpDocInfo uses a type in StaticTypeMapper.

The types involved

• Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory → Rector.StaticTypeMapper.StaticTypeMapper

Direction

BetterPhpDocParser.PhpDocInfo uses StaticTypeMapper, so a change to StaticTypeMapper can break BetterPhpDocParser.PhpDocInfo, while a change to BetterPhpDocParser.PhpDocInfo can't break StaticTypeMapper.

Position

Below the diagonal: BetterPhpDocParser.PhpDocInfo uses a module listed above it, which is the healthy direction.

11→30 NodeNameResolver uses NodeAnalyzer part of a loop✕

Connections

1 pair of types, where a type in NodeNameResolver uses a type in NodeAnalyzer.

The types involved

• Rector.NodeNameResolver.NodeNameResolver → Rector.NodeAnalyzer.CallAnalyzer

Direction

NodeNameResolver uses NodeAnalyzer, so a change to NodeAnalyzer can break NodeNameResolver, while a change to NodeNameResolver can't break NodeAnalyzer.

Position

Above the diagonal, so it is part of a loop. Neither module can be changed, tested or released on its own until one of these dependencies is removed.

12→10 Comments.NodeDocBlock uses BetterPhpDocParser.PhpDocInfo✕

Connections

1 pair of types, where a type in Comments.NodeDocBlock uses a type in BetterPhpDocParser.PhpDocInfo.

The types involved

• Rector.Comments.NodeDocBlock.DocBlockUpdater → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo

Direction

Comments.NodeDocBlock uses BetterPhpDocParser.PhpDocInfo, so a change to BetterPhpDocParser.PhpDocInfo can break Comments.NodeDocBlock, while a change to Comments.NodeDocBlock can't break BetterPhpDocParser.PhpDocInfo.

Position

Below the diagonal: Comments.NodeDocBlock uses a module listed above it, which is the healthy direction.

13→5 NodeTypeResolver uses Php✕

Connections

1 pair of types, where a type in NodeTypeResolver uses a type in Php.

The types involved

• Rector.NodeTypeResolver.NodeTypeResolver → Rector.Php.PhpVersionProvider

Direction

NodeTypeResolver uses Php, so a change to Php can break NodeTypeResolver, while a change to NodeTypeResolver can't break Php.

Position

Below the diagonal: NodeTypeResolver uses a module listed above it, which is the healthy direction.

13→11 NodeTypeResolver uses NodeNameResolver✕

Connections

1 pair of types, where a type in NodeTypeResolver uses a type in NodeNameResolver.

The types involved

• Rector.NodeTypeResolver.NodeTypeResolver → Rector.NodeNameResolver.NodeNameResolver

Direction

NodeTypeResolver uses NodeNameResolver, so a change to NodeNameResolver can break NodeTypeResolver, while a change to NodeTypeResolver can't break NodeNameResolver.

Position

Below the diagonal: NodeTypeResolver uses a module listed above it, which is the healthy direction.

13→30 NodeTypeResolver uses NodeAnalyzer part of a loop✕

Connections

1 pair of types, where a type in NodeTypeResolver uses a type in NodeAnalyzer.

The types involved

• Rector.NodeTypeResolver.NodeTypeResolver → Rector.NodeAnalyzer.ClassAnalyzer

Direction

NodeTypeResolver uses NodeAnalyzer, so a change to NodeAnalyzer can break NodeTypeResolver, while a change to NodeTypeResolver can't break NodeAnalyzer.

Position

Above the diagonal, so it is part of a loop. Neither module can be changed, tested or released on its own until one of these dependencies is removed.

14→5 PhpParser.Node uses Php✕

Connections

1 pair of types, where a type in PhpParser.Node uses a type in Php.

The types involved

• Rector.PhpParser.Node.NodeFactory → Rector.Php.PhpVersionProvider

Direction

PhpParser.Node uses Php, so a change to Php can break PhpParser.Node, while a change to PhpParser.Node can't break Php.

Position

Below the diagonal: PhpParser.Node uses a module listed above it, which is the healthy direction.

14→6 PhpParser.Node uses PhpDocParser.NodeTraverser✕

Connections

2 pairs of types, where a type in PhpParser.Node uses a type in PhpDocParser.NodeTraverser.

The types involved

• Rector.PhpParser.Node.BetterNodeFinder → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser
• Rector.PhpParser.Node.NodeFactory → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser

Direction

PhpParser.Node uses PhpDocParser.NodeTraverser, so a change to PhpDocParser.NodeTraverser can break PhpParser.Node, while a change to PhpParser.Node can't break PhpDocParser.NodeTraverser.

Position

Below the diagonal: PhpParser.Node uses a module listed above it, which is the healthy direction.

14→8 PhpParser.Node uses StaticTypeMapper✕

Connections

1 pair of types, where a type in PhpParser.Node uses a type in StaticTypeMapper.

The types involved

• Rector.PhpParser.Node.NodeFactory → Rector.StaticTypeMapper.StaticTypeMapper

Direction

PhpParser.Node uses StaticTypeMapper, so a change to StaticTypeMapper can break PhpParser.Node, while a change to PhpParser.Node can't break StaticTypeMapper.

Position

Below the diagonal: PhpParser.Node uses a module listed above it, which is the healthy direction.

14→10 PhpParser.Node uses BetterPhpDocParser.PhpDocInfo✕

Connections

1 pair of types, where a type in PhpParser.Node uses a type in BetterPhpDocParser.PhpDocInfo.

The types involved

• Rector.PhpParser.Node.NodeFactory → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory

Direction

PhpParser.Node uses BetterPhpDocParser.PhpDocInfo, so a change to BetterPhpDocParser.PhpDocInfo can break PhpParser.Node, while a change to PhpParser.Node can't break BetterPhpDocParser.PhpDocInfo.

Position

Below the diagonal: PhpParser.Node uses a module listed above it, which is the healthy direction.

14→11 PhpParser.Node uses NodeNameResolver✕

Connections

1 pair of types, where a type in PhpParser.Node uses a type in NodeNameResolver.

The types involved

• Rector.PhpParser.Node.BetterNodeFinder → Rector.NodeNameResolver.NodeNameResolver

Direction

PhpParser.Node uses NodeNameResolver, so a change to NodeNameResolver can break PhpParser.Node, while a change to PhpParser.Node can't break NodeNameResolver.

Position

Below the diagonal: PhpParser.Node uses a module listed above it, which is the healthy direction.

15→11 Privatization.NodeManipulator uses NodeNameResolver✕

Connections

1 pair of types, where a type in Privatization.NodeManipulator uses a type in NodeNameResolver.

The types involved

• Rector.Privatization.NodeManipulator.VisibilityManipulator → Rector.NodeNameResolver.NodeNameResolver

Direction

Privatization.NodeManipulator uses NodeNameResolver, so a change to NodeNameResolver can break Privatization.NodeManipulator, while a change to Privatization.NodeManipulator can't break NodeNameResolver.

Position

Below the diagonal: Privatization.NodeManipulator uses a module listed above it, which is the healthy direction.

16→8 BetterPhpDocParser.PhpDocManipulator uses StaticTypeMapper✕

Connections

1 pair of types, where a type in BetterPhpDocParser.PhpDocManipulator uses a type in StaticTypeMapper.

The types involved

• Rector.BetterPhpDocParser.PhpDocManipulator.PhpDocTypeChanger → Rector.StaticTypeMapper.StaticTypeMapper

Direction

BetterPhpDocParser.PhpDocManipulator uses StaticTypeMapper, so a change to StaticTypeMapper can break BetterPhpDocParser.PhpDocManipulator, while a change to BetterPhpDocParser.PhpDocManipulator can't break StaticTypeMapper.

Position

Below the diagonal: BetterPhpDocParser.PhpDocManipulator uses a module listed above it, which is the healthy direction.

16→10 BetterPhpDocParser.PhpDocManipulator uses BetterPhpDocParser.PhpDocInfo✕

Connections

3 pairs of types, where a type in BetterPhpDocParser.PhpDocManipulator uses a type in BetterPhpDocParser.PhpDocInfo.

The types involved

• Rector.BetterPhpDocParser.PhpDocManipulator.PhpDocClassRenamer → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.BetterPhpDocParser.PhpDocManipulator.PhpDocTagRemover → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.BetterPhpDocParser.PhpDocManipulator.PhpDocTypeChanger → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo

Direction

BetterPhpDocParser.PhpDocManipulator uses BetterPhpDocParser.PhpDocInfo, so a change to BetterPhpDocParser.PhpDocInfo can break BetterPhpDocParser.PhpDocManipulator, while a change to BetterPhpDocParser.PhpDocManipulator can't break BetterPhpDocParser.PhpDocInfo.

Position

Below the diagonal: BetterPhpDocParser.PhpDocManipulator uses a module listed above it, which is the healthy direction.

16→12 BetterPhpDocParser.PhpDocManipulator uses Comments.NodeDocBlock✕

Connections

1 pair of types, where a type in BetterPhpDocParser.PhpDocManipulator uses a type in Comments.NodeDocBlock.

The types involved

• Rector.BetterPhpDocParser.PhpDocManipulator.PhpDocTypeChanger → Rector.Comments.NodeDocBlock.DocBlockUpdater

Direction

BetterPhpDocParser.PhpDocManipulator uses Comments.NodeDocBlock, so a change to Comments.NodeDocBlock can break BetterPhpDocParser.PhpDocManipulator, while a change to BetterPhpDocParser.PhpDocManipulator can't break Comments.NodeDocBlock.

Position

Below the diagonal: BetterPhpDocParser.PhpDocManipulator uses a module listed above it, which is the healthy direction.

17→14 PhpParser.Printer uses PhpParser.Node✕

Connections

1 pair of types, where a type in PhpParser.Printer uses a type in PhpParser.Node.

The types involved

• Rector.PhpParser.Printer.BetterStandardPrinter → Rector.PhpParser.Node.FileNode

Direction

PhpParser.Printer uses PhpParser.Node, so a change to PhpParser.Node can break PhpParser.Printer, while a change to PhpParser.Printer can't break PhpParser.Node.

Position

Below the diagonal: PhpParser.Printer uses a module listed above it, which is the healthy direction.

17→30 PhpParser.Printer uses NodeAnalyzer part of a loop✕

Connections

1 pair of types, where a type in PhpParser.Printer uses a type in NodeAnalyzer.

The types involved

• Rector.PhpParser.Printer.BetterStandardPrinter → Rector.NodeAnalyzer.ExprAnalyzer

Direction

PhpParser.Printer uses NodeAnalyzer, so a change to NodeAnalyzer can break PhpParser.Printer, while a change to PhpParser.Printer can't break NodeAnalyzer.

Position

Above the diagonal, so it is part of a loop. Neither module can be changed, tested or released on its own until one of these dependencies is removed.

18→11 Reflection uses NodeNameResolver✕

Connections

1 pair of types, where a type in Reflection uses a type in NodeNameResolver.

The types involved

• Rector.Reflection.ReflectionResolver → Rector.NodeNameResolver.NodeNameResolver

Direction

Reflection uses NodeNameResolver, so a change to NodeNameResolver can break Reflection, while a change to Reflection can't break NodeNameResolver.

Position

Below the diagonal: Reflection uses a module listed above it, which is the healthy direction.

18→13 Reflection uses NodeTypeResolver✕

Connections

1 pair of types, where a type in Reflection uses a type in NodeTypeResolver.

The types involved

• Rector.Reflection.ReflectionResolver → Rector.NodeTypeResolver.NodeTypeResolver

Direction

Reflection uses NodeTypeResolver, so a change to NodeTypeResolver can break Reflection, while a change to Reflection can't break NodeTypeResolver.

Position

Below the diagonal: Reflection uses a module listed above it, which is the healthy direction.

18→30 Reflection uses NodeAnalyzer part of a loop✕

Connections

1 pair of types, where a type in Reflection uses a type in NodeAnalyzer.

The types involved

• Rector.Reflection.ReflectionResolver → Rector.NodeAnalyzer.ClassAnalyzer

Direction

Reflection uses NodeAnalyzer, so a change to NodeAnalyzer can break Reflection, while a change to Reflection can't break NodeAnalyzer.

Position

Above the diagonal, so it is part of a loop. Neither module can be changed, tested or released on its own until one of these dependencies is removed.

19→14 ValueObject.Application uses PhpParser.Node✕

Connections

1 pair of types, where a type in ValueObject.Application uses a type in PhpParser.Node.

The types involved

• Rector.ValueObject.Application.File → Rector.PhpParser.Node.FileNode

Direction

ValueObject.Application uses PhpParser.Node, so a change to PhpParser.Node can break ValueObject.Application, while a change to ValueObject.Application can't break PhpParser.Node.

Position

Below the diagonal: ValueObject.Application uses a module listed above it, which is the healthy direction.

20→10 DeadCode.PhpDoc.TagRemover uses BetterPhpDocParser.PhpDocInfo✕

Connections

4 pairs of types, where a type in DeadCode.PhpDoc.TagRemover uses a type in BetterPhpDocParser.PhpDocInfo.

The types involved

• Rector.DeadCode.PhpDoc.TagRemover.ParamTagRemover → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.DeadCode.PhpDoc.TagRemover.ReturnTagRemover → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.DeadCode.PhpDoc.TagRemover.VarTagRemover → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.DeadCode.PhpDoc.TagRemover.VarTagRemover → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory

Direction

DeadCode.PhpDoc.TagRemover uses BetterPhpDocParser.PhpDocInfo, so a change to BetterPhpDocParser.PhpDocInfo can break DeadCode.PhpDoc.TagRemover, while a change to DeadCode.PhpDoc.TagRemover can't break BetterPhpDocParser.PhpDocInfo.

Position

Below the diagonal: DeadCode.PhpDoc.TagRemover uses a module listed above it, which is the healthy direction.

20→12 DeadCode.PhpDoc.TagRemover uses Comments.NodeDocBlock✕

Connections

2 pairs of types, where a type in DeadCode.PhpDoc.TagRemover uses a type in Comments.NodeDocBlock.

The types involved

• Rector.DeadCode.PhpDoc.TagRemover.ParamTagRemover → Rector.Comments.NodeDocBlock.DocBlockUpdater
• Rector.DeadCode.PhpDoc.TagRemover.VarTagRemover → Rector.Comments.NodeDocBlock.DocBlockUpdater

Direction

DeadCode.PhpDoc.TagRemover uses Comments.NodeDocBlock, so a change to Comments.NodeDocBlock can break DeadCode.PhpDoc.TagRemover, while a change to DeadCode.PhpDoc.TagRemover can't break Comments.NodeDocBlock.

Position

Below the diagonal: DeadCode.PhpDoc.TagRemover uses a module listed above it, which is the healthy direction.

20→16 DeadCode.PhpDoc.TagRemover uses BetterPhpDocParser.PhpDocManipulator✕

Connections

1 pair of types, where a type in DeadCode.PhpDoc.TagRemover uses a type in BetterPhpDocParser.PhpDocManipulator.

The types involved

• Rector.DeadCode.PhpDoc.TagRemover.VarTagRemover → Rector.BetterPhpDocParser.PhpDocManipulator.PhpDocTypeChanger

Direction

DeadCode.PhpDoc.TagRemover uses BetterPhpDocParser.PhpDocManipulator, so a change to BetterPhpDocParser.PhpDocManipulator can break DeadCode.PhpDoc.TagRemover, while a change to DeadCode.PhpDoc.TagRemover can't break BetterPhpDocParser.PhpDocManipulator.

Position

Below the diagonal: DeadCode.PhpDoc.TagRemover uses a module listed above it, which is the healthy direction.

21→11 PhpParser uses NodeNameResolver✕

Connections

1 pair of types, where a type in PhpParser uses a type in NodeNameResolver.

The types involved

• Rector.PhpParser.AstResolver → Rector.NodeNameResolver.NodeNameResolver

Direction

PhpParser uses NodeNameResolver, so a change to NodeNameResolver can break PhpParser, while a change to PhpParser can't break NodeNameResolver.

Position

Below the diagonal: PhpParser uses a module listed above it, which is the healthy direction.

21→13 PhpParser uses NodeTypeResolver✕

Connections

2 pairs of types, where a type in PhpParser uses a type in NodeTypeResolver.

The types involved

• Rector.PhpParser.AstResolver → Rector.NodeTypeResolver.NodeScopeAndMetadataDecorator
• Rector.PhpParser.AstResolver → Rector.NodeTypeResolver.NodeTypeResolver

Direction

PhpParser uses NodeTypeResolver, so a change to NodeTypeResolver can break PhpParser, while a change to PhpParser can't break NodeTypeResolver.

Position

Below the diagonal: PhpParser uses a module listed above it, which is the healthy direction.

21→14 PhpParser uses PhpParser.Node✕

Connections

1 pair of types, where a type in PhpParser uses a type in PhpParser.Node.

The types involved

• Rector.PhpParser.AstResolver → Rector.PhpParser.Node.BetterNodeFinder

Direction

PhpParser uses PhpParser.Node, so a change to PhpParser.Node can break PhpParser, while a change to PhpParser can't break PhpParser.Node.

Position

Below the diagonal: PhpParser uses a module listed above it, which is the healthy direction.

21→18 PhpParser uses Reflection✕

Connections

1 pair of types, where a type in PhpParser uses a type in Reflection.

The types involved

• Rector.PhpParser.AstResolver → Rector.Reflection.MethodReflectionResolver

Direction

PhpParser uses Reflection, so a change to Reflection can break PhpParser, while a change to PhpParser can't break Reflection.

Position

Below the diagonal: PhpParser uses a module listed above it, which is the healthy direction.

22→17 PhpParser.Comparing uses PhpParser.Printer✕

Connections

1 pair of types, where a type in PhpParser.Comparing uses a type in PhpParser.Printer.

The types involved

• Rector.PhpParser.Comparing.NodeComparator → Rector.PhpParser.Printer.BetterStandardPrinter

Direction

PhpParser.Comparing uses PhpParser.Printer, so a change to PhpParser.Printer can break PhpParser.Comparing, while a change to PhpParser.Comparing can't break PhpParser.Printer.

Position

Below the diagonal: PhpParser.Comparing uses a module listed above it, which is the healthy direction.

23→11 PhpParser.Node.Value uses NodeNameResolver✕

Connections

1 pair of types, where a type in PhpParser.Node.Value uses a type in NodeNameResolver.

The types involved

• Rector.PhpParser.Node.Value.ValueResolver → Rector.NodeNameResolver.NodeNameResolver

Direction

PhpParser.Node.Value uses NodeNameResolver, so a change to NodeNameResolver can break PhpParser.Node.Value, while a change to PhpParser.Node.Value can't break NodeNameResolver.

Position

Below the diagonal: PhpParser.Node.Value uses a module listed above it, which is the healthy direction.

23→13 PhpParser.Node.Value uses NodeTypeResolver✕

Connections

1 pair of types, where a type in PhpParser.Node.Value uses a type in NodeTypeResolver.

The types involved

• Rector.PhpParser.Node.Value.ValueResolver → Rector.NodeTypeResolver.NodeTypeResolver

Direction

PhpParser.Node.Value uses NodeTypeResolver, so a change to NodeTypeResolver can break PhpParser.Node.Value, while a change to PhpParser.Node.Value can't break NodeTypeResolver.

Position

Below the diagonal: PhpParser.Node.Value uses a module listed above it, which is the healthy direction.

23→18 PhpParser.Node.Value uses Reflection✕

Connections

2 pairs of types, where a type in PhpParser.Node.Value uses a type in Reflection.

The types involved

• Rector.PhpParser.Node.Value.ValueResolver → Rector.Reflection.ClassReflectionAnalyzer
• Rector.PhpParser.Node.Value.ValueResolver → Rector.Reflection.ReflectionResolver

Direction

PhpParser.Node.Value uses Reflection, so a change to Reflection can break PhpParser.Node.Value, while a change to PhpParser.Node.Value can't break Reflection.

Position

Below the diagonal: PhpParser.Node.Value uses a module listed above it, which is the healthy direction.

23→30 PhpParser.Node.Value uses NodeAnalyzer part of a loop✕

Connections

1 pair of types, where a type in PhpParser.Node.Value uses a type in NodeAnalyzer.

The types involved

• Rector.PhpParser.Node.Value.ValueResolver → Rector.NodeAnalyzer.ConstFetchAnalyzer

Direction

PhpParser.Node.Value uses NodeAnalyzer, so a change to NodeAnalyzer can break PhpParser.Node.Value, while a change to PhpParser.Node.Value can't break NodeAnalyzer.

Position

Above the diagonal, so it is part of a loop. Neither module can be changed, tested or released on its own until one of these dependencies is removed.

24→6 DeadCode.NodeAnalyzer uses PhpDocParser.NodeTraverser✕

Connections

1 pair of types, where a type in DeadCode.NodeAnalyzer uses a type in PhpDocParser.NodeTraverser.

The types involved

• Rector.DeadCode.NodeAnalyzer.IsClassMethodUsedAnalyzer → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser

Direction

DeadCode.NodeAnalyzer uses PhpDocParser.NodeTraverser, so a change to PhpDocParser.NodeTraverser can break DeadCode.NodeAnalyzer, while a change to DeadCode.NodeAnalyzer can't break PhpDocParser.NodeTraverser.

Position

Below the diagonal: DeadCode.NodeAnalyzer uses a module listed above it, which is the healthy direction.

24→11 DeadCode.NodeAnalyzer uses NodeNameResolver✕

Connections

5 pairs of types, where a type in DeadCode.NodeAnalyzer uses a type in NodeNameResolver.

The types involved

• Rector.DeadCode.NodeAnalyzer.CallCollectionAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.DeadCode.NodeAnalyzer.IsClassMethodUsedAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.DeadCode.NodeAnalyzer.NoDiscardCallAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.DeadCode.NodeAnalyzer.PropertyWriteonlyAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.DeadCode.NodeAnalyzer.UsedVariableNameAnalyzer → Rector.NodeNameResolver.NodeNameResolver

Direction

DeadCode.NodeAnalyzer uses NodeNameResolver, so a change to NodeNameResolver can break DeadCode.NodeAnalyzer, while a change to DeadCode.NodeAnalyzer can't break NodeNameResolver.

Position

Below the diagonal: DeadCode.NodeAnalyzer uses a module listed above it, which is the healthy direction.

24→13 DeadCode.NodeAnalyzer uses NodeTypeResolver✕

Connections

3 pairs of types, where a type in DeadCode.NodeAnalyzer uses a type in NodeTypeResolver.

The types involved

• Rector.DeadCode.NodeAnalyzer.CallCollectionAnalyzer → Rector.NodeTypeResolver.NodeTypeResolver
• Rector.DeadCode.NodeAnalyzer.NoDiscardCallAnalyzer → Rector.NodeTypeResolver.NodeTypeResolver
• Rector.DeadCode.NodeAnalyzer.SafeLeftTypeBooleanAndOrAnalyzer → Rector.NodeTypeResolver.NodeTypeResolver

Direction

DeadCode.NodeAnalyzer uses NodeTypeResolver, so a change to NodeTypeResolver can break DeadCode.NodeAnalyzer, while a change to DeadCode.NodeAnalyzer can't break NodeTypeResolver.

Position

Below the diagonal: DeadCode.NodeAnalyzer uses a module listed above it, which is the healthy direction.

24→14 DeadCode.NodeAnalyzer uses PhpParser.Node✕

Connections

3 pairs of types, where a type in DeadCode.NodeAnalyzer uses a type in PhpParser.Node.

The types involved

• Rector.DeadCode.NodeAnalyzer.IsClassMethodUsedAnalyzer → Rector.PhpParser.Node.BetterNodeFinder
• Rector.DeadCode.NodeAnalyzer.PropertyWriteonlyAnalyzer → Rector.PhpParser.Node.BetterNodeFinder
• Rector.DeadCode.NodeAnalyzer.SafeLeftTypeBooleanAndOrAnalyzer → Rector.PhpParser.Node.BetterNodeFinder

Direction

DeadCode.NodeAnalyzer uses PhpParser.Node, so a change to PhpParser.Node can break DeadCode.NodeAnalyzer, while a change to DeadCode.NodeAnalyzer can't break PhpParser.Node.

Position

Below the diagonal: DeadCode.NodeAnalyzer uses a module listed above it, which is the healthy direction.

24→18 DeadCode.NodeAnalyzer uses Reflection✕

Connections

3 pairs of types, where a type in DeadCode.NodeAnalyzer uses a type in Reflection.

The types involved

• Rector.DeadCode.NodeAnalyzer.CallLikeParamDefaultResolver → Rector.Reflection.ReflectionResolver
• Rector.DeadCode.NodeAnalyzer.IsClassMethodUsedAnalyzer → Rector.Reflection.ReflectionResolver
• Rector.DeadCode.NodeAnalyzer.SafeLeftTypeBooleanAndOrAnalyzer → Rector.Reflection.ReflectionResolver

Direction

DeadCode.NodeAnalyzer uses Reflection, so a change to Reflection can break DeadCode.NodeAnalyzer, while a change to DeadCode.NodeAnalyzer can't break Reflection.

Position

Below the diagonal: DeadCode.NodeAnalyzer uses a module listed above it, which is the healthy direction.

24→21 DeadCode.NodeAnalyzer uses PhpParser✕

Connections

1 pair of types, where a type in DeadCode.NodeAnalyzer uses a type in PhpParser.

The types involved

• Rector.DeadCode.NodeAnalyzer.IsClassMethodUsedAnalyzer → Rector.PhpParser.AstResolver

Direction

DeadCode.NodeAnalyzer uses PhpParser, so a change to PhpParser can break DeadCode.NodeAnalyzer, while a change to DeadCode.NodeAnalyzer can't break PhpParser.

Position

Below the diagonal: DeadCode.NodeAnalyzer uses a module listed above it, which is the healthy direction.

24→23 DeadCode.NodeAnalyzer uses PhpParser.Node.Value✕

Connections

1 pair of types, where a type in DeadCode.NodeAnalyzer uses a type in PhpParser.Node.Value.

The types involved

• Rector.DeadCode.NodeAnalyzer.IsClassMethodUsedAnalyzer → Rector.PhpParser.Node.Value.ValueResolver

Direction

DeadCode.NodeAnalyzer uses PhpParser.Node.Value, so a change to PhpParser.Node.Value can break DeadCode.NodeAnalyzer, while a change to DeadCode.NodeAnalyzer can't break PhpParser.Node.Value.

Position

Below the diagonal: DeadCode.NodeAnalyzer uses a module listed above it, which is the healthy direction.

24→30 DeadCode.NodeAnalyzer uses NodeAnalyzer part of a loop✕

Connections

3 pairs of types, where a type in DeadCode.NodeAnalyzer uses a type in NodeAnalyzer.

The types involved

• Rector.DeadCode.NodeAnalyzer.CallLikeParamDefaultResolver → Rector.NodeAnalyzer.VariadicAnalyzer
• Rector.DeadCode.NodeAnalyzer.ExprUsedInNodeAnalyzer → Rector.NodeAnalyzer.CompactFuncCallAnalyzer
• Rector.DeadCode.NodeAnalyzer.SafeLeftTypeBooleanAndOrAnalyzer → Rector.NodeAnalyzer.ExprAnalyzer

Direction

DeadCode.NodeAnalyzer uses NodeAnalyzer, so a change to NodeAnalyzer can break DeadCode.NodeAnalyzer, while a change to DeadCode.NodeAnalyzer can't break NodeAnalyzer.

Position

Above the diagonal, so it is part of a loop. Neither module can be changed, tested or released on its own until one of these dependencies is removed.

25→4 Php80.NodeAnalyzer uses NodeTypeResolver.PHPStan.Type✕

Connections

1 pair of types, where a type in Php80.NodeAnalyzer uses a type in NodeTypeResolver.PHPStan.Type.

The types involved

• Rector.Php80.NodeAnalyzer.SwitchAnalyzer → Rector.NodeTypeResolver.PHPStan.Type.TypeFactory

Direction

Php80.NodeAnalyzer uses NodeTypeResolver.PHPStan.Type, so a change to NodeTypeResolver.PHPStan.Type can break Php80.NodeAnalyzer, while a change to Php80.NodeAnalyzer can't break NodeTypeResolver.PHPStan.Type.

Position

Below the diagonal: Php80.NodeAnalyzer uses a module listed above it, which is the healthy direction.

25→10 Php80.NodeAnalyzer uses BetterPhpDocParser.PhpDocInfo✕

Connections

1 pair of types, where a type in Php80.NodeAnalyzer uses a type in BetterPhpDocParser.PhpDocInfo.

The types involved

• Rector.Php80.NodeAnalyzer.PromotedPropertyCandidateResolver → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory

Direction

Php80.NodeAnalyzer uses BetterPhpDocParser.PhpDocInfo, so a change to BetterPhpDocParser.PhpDocInfo can break Php80.NodeAnalyzer, while a change to Php80.NodeAnalyzer can't break BetterPhpDocParser.PhpDocInfo.

Position

Below the diagonal: Php80.NodeAnalyzer uses a module listed above it, which is the healthy direction.

25→11 Php80.NodeAnalyzer uses NodeNameResolver✕

Connections

3 pairs of types, where a type in Php80.NodeAnalyzer uses a type in NodeNameResolver.

The types involved

• Rector.Php80.NodeAnalyzer.MatchSwitchAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.Php80.NodeAnalyzer.PhpAttributeAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.Php80.NodeAnalyzer.PromotedPropertyCandidateResolver → Rector.NodeNameResolver.NodeNameResolver

Direction

Php80.NodeAnalyzer uses NodeNameResolver, so a change to NodeNameResolver can break Php80.NodeAnalyzer, while a change to Php80.NodeAnalyzer can't break NodeNameResolver.

Position

Below the diagonal: Php80.NodeAnalyzer uses a module listed above it, which is the healthy direction.

25→13 Php80.NodeAnalyzer uses NodeTypeResolver✕

Connections

1 pair of types, where a type in Php80.NodeAnalyzer uses a type in NodeTypeResolver.

The types involved

• Rector.Php80.NodeAnalyzer.SwitchAnalyzer → Rector.NodeTypeResolver.NodeTypeResolver

Direction

Php80.NodeAnalyzer uses NodeTypeResolver, so a change to NodeTypeResolver can break Php80.NodeAnalyzer, while a change to Php80.NodeAnalyzer can't break NodeTypeResolver.

Position

Below the diagonal: Php80.NodeAnalyzer uses a module listed above it, which is the healthy direction.

25→14 Php80.NodeAnalyzer uses PhpParser.Node✕

Connections

1 pair of types, where a type in Php80.NodeAnalyzer uses a type in PhpParser.Node.

The types involved

• Rector.Php80.NodeAnalyzer.PromotedPropertyCandidateResolver → Rector.PhpParser.Node.BetterNodeFinder

Direction

Php80.NodeAnalyzer uses PhpParser.Node, so a change to PhpParser.Node can break Php80.NodeAnalyzer, while a change to Php80.NodeAnalyzer can't break PhpParser.Node.

Position

Below the diagonal: Php80.NodeAnalyzer uses a module listed above it, which is the healthy direction.

25→17 Php80.NodeAnalyzer uses PhpParser.Printer✕

Connections

1 pair of types, where a type in Php80.NodeAnalyzer uses a type in PhpParser.Printer.

The types involved

• Rector.Php80.NodeAnalyzer.MatchSwitchAnalyzer → Rector.PhpParser.Printer.BetterStandardPrinter

Direction

Php80.NodeAnalyzer uses PhpParser.Printer, so a change to PhpParser.Printer can break Php80.NodeAnalyzer, while a change to Php80.NodeAnalyzer can't break PhpParser.Printer.

Position

Below the diagonal: Php80.NodeAnalyzer uses a module listed above it, which is the healthy direction.

25→22 Php80.NodeAnalyzer uses PhpParser.Comparing✕

Connections

2 pairs of types, where a type in Php80.NodeAnalyzer uses a type in PhpParser.Comparing.

The types involved

• Rector.Php80.NodeAnalyzer.MatchSwitchAnalyzer → Rector.PhpParser.Comparing.NodeComparator
• Rector.Php80.NodeAnalyzer.PromotedPropertyCandidateResolver → Rector.PhpParser.Comparing.NodeComparator

Direction

Php80.NodeAnalyzer uses PhpParser.Comparing, so a change to PhpParser.Comparing can break Php80.NodeAnalyzer, while a change to Php80.NodeAnalyzer can't break PhpParser.Comparing.

Position

Below the diagonal: Php80.NodeAnalyzer uses a module listed above it, which is the healthy direction.

25→30 Php80.NodeAnalyzer uses NodeAnalyzer part of a loop✕

Connections

1 pair of types, where a type in Php80.NodeAnalyzer uses a type in NodeAnalyzer.

The types involved

• Rector.Php80.NodeAnalyzer.PromotedPropertyCandidateResolver → Rector.NodeAnalyzer.PropertyFetchAnalyzer

Direction

Php80.NodeAnalyzer uses NodeAnalyzer, so a change to NodeAnalyzer can break Php80.NodeAnalyzer, while a change to Php80.NodeAnalyzer can't break NodeAnalyzer.

Position

Above the diagonal, so it is part of a loop. Neither module can be changed, tested or released on its own until one of these dependencies is removed.

26→6 PhpParser.NodeFinder uses PhpDocParser.NodeTraverser✕

Connections

1 pair of types, where a type in PhpParser.NodeFinder uses a type in PhpDocParser.NodeTraverser.

The types involved

• Rector.PhpParser.NodeFinder.PropertyFetchFinder → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser

Direction

PhpParser.NodeFinder uses PhpDocParser.NodeTraverser, so a change to PhpDocParser.NodeTraverser can break PhpParser.NodeFinder, while a change to PhpParser.NodeFinder can't break PhpDocParser.NodeTraverser.

Position

Below the diagonal: PhpParser.NodeFinder uses a module listed above it, which is the healthy direction.

26→11 PhpParser.NodeFinder uses NodeNameResolver✕

Connections

2 pairs of types, where a type in PhpParser.NodeFinder uses a type in NodeNameResolver.

The types involved

• Rector.PhpParser.NodeFinder.LocalMethodCallFinder → Rector.NodeNameResolver.NodeNameResolver
• Rector.PhpParser.NodeFinder.PropertyFetchFinder → Rector.NodeNameResolver.NodeNameResolver

Direction

PhpParser.NodeFinder uses NodeNameResolver, so a change to NodeNameResolver can break PhpParser.NodeFinder, while a change to PhpParser.NodeFinder can't break NodeNameResolver.

Position

Below the diagonal: PhpParser.NodeFinder uses a module listed above it, which is the healthy direction.

26→13 PhpParser.NodeFinder uses NodeTypeResolver✕

Connections

2 pairs of types, where a type in PhpParser.NodeFinder uses a type in NodeTypeResolver.

The types involved

• Rector.PhpParser.NodeFinder.LocalMethodCallFinder → Rector.NodeTypeResolver.NodeTypeResolver
• Rector.PhpParser.NodeFinder.PropertyFetchFinder → Rector.NodeTypeResolver.NodeTypeResolver

Direction

PhpParser.NodeFinder uses NodeTypeResolver, so a change to NodeTypeResolver can break PhpParser.NodeFinder, while a change to PhpParser.NodeFinder can't break NodeTypeResolver.

Position

Below the diagonal: PhpParser.NodeFinder uses a module listed above it, which is the healthy direction.

26→14 PhpParser.NodeFinder uses PhpParser.Node✕

Connections

2 pairs of types, where a type in PhpParser.NodeFinder uses a type in PhpParser.Node.

The types involved

• Rector.PhpParser.NodeFinder.LocalMethodCallFinder → Rector.PhpParser.Node.BetterNodeFinder
• Rector.PhpParser.NodeFinder.PropertyFetchFinder → Rector.PhpParser.Node.BetterNodeFinder

Direction

PhpParser.NodeFinder uses PhpParser.Node, so a change to PhpParser.Node can break PhpParser.NodeFinder, while a change to PhpParser.NodeFinder can't break PhpParser.Node.

Position

Below the diagonal: PhpParser.NodeFinder uses a module listed above it, which is the healthy direction.

26→18 PhpParser.NodeFinder uses Reflection✕

Connections

1 pair of types, where a type in PhpParser.NodeFinder uses a type in Reflection.

The types involved

• Rector.PhpParser.NodeFinder.PropertyFetchFinder → Rector.Reflection.ReflectionResolver

Direction

PhpParser.NodeFinder uses Reflection, so a change to Reflection can break PhpParser.NodeFinder, while a change to PhpParser.NodeFinder can't break Reflection.

Position

Below the diagonal: PhpParser.NodeFinder uses a module listed above it, which is the healthy direction.

26→21 PhpParser.NodeFinder uses PhpParser✕

Connections

1 pair of types, where a type in PhpParser.NodeFinder uses a type in PhpParser.

The types involved

• Rector.PhpParser.NodeFinder.PropertyFetchFinder → Rector.PhpParser.AstResolver

Direction

PhpParser.NodeFinder uses PhpParser, so a change to PhpParser can break PhpParser.NodeFinder, while a change to PhpParser.NodeFinder can't break PhpParser.

Position

Below the diagonal: PhpParser.NodeFinder uses a module listed above it, which is the healthy direction.

26→30 PhpParser.NodeFinder uses NodeAnalyzer part of a loop✕

Connections

1 pair of types, where a type in PhpParser.NodeFinder uses a type in NodeAnalyzer.

The types involved

• Rector.PhpParser.NodeFinder.PropertyFetchFinder → Rector.NodeAnalyzer.PropertyFetchAnalyzer

Direction

PhpParser.NodeFinder uses NodeAnalyzer, so a change to NodeAnalyzer can break PhpParser.NodeFinder, while a change to PhpParser.NodeFinder can't break NodeAnalyzer.

Position

Above the diagonal, so it is part of a loop. Neither module can be changed, tested or released on its own until one of these dependencies is removed.

27→4 TypeDeclaration.TypeInferer uses NodeTypeResolver.PHPStan.Type✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer uses a type in NodeTypeResolver.PHPStan.Type.

The types involved

• Rector.TypeDeclaration.TypeInferer.AssignToPropertyTypeInferer → Rector.NodeTypeResolver.PHPStan.Type.TypeFactory

Direction

TypeDeclaration.TypeInferer uses NodeTypeResolver.PHPStan.Type, so a change to NodeTypeResolver.PHPStan.Type can break TypeDeclaration.TypeInferer, while a change to TypeDeclaration.TypeInferer can't break NodeTypeResolver.PHPStan.Type.

Position

Below the diagonal: TypeDeclaration.TypeInferer uses a module listed above it, which is the healthy direction.

27→6 TypeDeclaration.TypeInferer uses PhpDocParser.NodeTraverser✕

Connections

2 pairs of types, where a type in TypeDeclaration.TypeInferer uses a type in PhpDocParser.NodeTraverser.

The types involved

• Rector.TypeDeclaration.TypeInferer.AssignToPropertyTypeInferer → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser
• Rector.TypeDeclaration.TypeInferer.SilentVoidResolver → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser

Direction

TypeDeclaration.TypeInferer uses PhpDocParser.NodeTraverser, so a change to PhpDocParser.NodeTraverser can break TypeDeclaration.TypeInferer, while a change to TypeDeclaration.TypeInferer can't break PhpDocParser.NodeTraverser.

Position

Below the diagonal: TypeDeclaration.TypeInferer uses a module listed above it, which is the healthy direction.

27→13 TypeDeclaration.TypeInferer uses NodeTypeResolver✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer uses a type in NodeTypeResolver.

The types involved

• Rector.TypeDeclaration.TypeInferer.AssignToPropertyTypeInferer → Rector.NodeTypeResolver.NodeTypeResolver

Direction

TypeDeclaration.TypeInferer uses NodeTypeResolver, so a change to NodeTypeResolver can break TypeDeclaration.TypeInferer, while a change to TypeDeclaration.TypeInferer can't break NodeTypeResolver.

Position

Below the diagonal: TypeDeclaration.TypeInferer uses a module listed above it, which is the healthy direction.

27→14 TypeDeclaration.TypeInferer uses PhpParser.Node✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer uses a type in PhpParser.Node.

The types involved

• Rector.TypeDeclaration.TypeInferer.SilentVoidResolver → Rector.PhpParser.Node.BetterNodeFinder

Direction

TypeDeclaration.TypeInferer uses PhpParser.Node, so a change to PhpParser.Node can break TypeDeclaration.TypeInferer, while a change to TypeDeclaration.TypeInferer can't break PhpParser.Node.

Position

Below the diagonal: TypeDeclaration.TypeInferer uses a module listed above it, which is the healthy direction.

27→18 TypeDeclaration.TypeInferer uses Reflection✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer uses a type in Reflection.

The types involved

• Rector.TypeDeclaration.TypeInferer.SilentVoidResolver → Rector.Reflection.ReflectionResolver

Direction

TypeDeclaration.TypeInferer uses Reflection, so a change to Reflection can break TypeDeclaration.TypeInferer, while a change to TypeDeclaration.TypeInferer can't break Reflection.

Position

Below the diagonal: TypeDeclaration.TypeInferer uses a module listed above it, which is the healthy direction.

27→23 TypeDeclaration.TypeInferer uses PhpParser.Node.Value✕

Connections

2 pairs of types, where a type in TypeDeclaration.TypeInferer uses a type in PhpParser.Node.Value.

The types involved

• Rector.TypeDeclaration.TypeInferer.AssignToPropertyTypeInferer → Rector.PhpParser.Node.Value.ValueResolver
• Rector.TypeDeclaration.TypeInferer.SilentVoidResolver → Rector.PhpParser.Node.Value.ValueResolver

Direction

TypeDeclaration.TypeInferer uses PhpParser.Node.Value, so a change to PhpParser.Node.Value can break TypeDeclaration.TypeInferer, while a change to TypeDeclaration.TypeInferer can't break PhpParser.Node.Value.

Position

Below the diagonal: TypeDeclaration.TypeInferer uses a module listed above it, which is the healthy direction.

27→25 TypeDeclaration.TypeInferer uses Php80.NodeAnalyzer✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer uses a type in Php80.NodeAnalyzer.

The types involved

• Rector.TypeDeclaration.TypeInferer.AssignToPropertyTypeInferer → Rector.Php80.NodeAnalyzer.PhpAttributeAnalyzer

Direction

TypeDeclaration.TypeInferer uses Php80.NodeAnalyzer, so a change to Php80.NodeAnalyzer can break TypeDeclaration.TypeInferer, while a change to TypeDeclaration.TypeInferer can't break Php80.NodeAnalyzer.

Position

Below the diagonal: TypeDeclaration.TypeInferer uses a module listed above it, which is the healthy direction.

27→28 TypeDeclaration.TypeInferer uses TypeDeclaration.NodeAnalyzer part of a loop✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer uses a type in TypeDeclaration.NodeAnalyzer.

The types involved

• Rector.TypeDeclaration.TypeInferer.SilentVoidResolver → Rector.TypeDeclaration.NodeAnalyzer.NeverFuncCallAnalyzer

Direction

TypeDeclaration.TypeInferer uses TypeDeclaration.NodeAnalyzer, so a change to TypeDeclaration.NodeAnalyzer can break TypeDeclaration.TypeInferer, while a change to TypeDeclaration.TypeInferer can't break TypeDeclaration.NodeAnalyzer.

Position

Above the diagonal, so it is part of a loop. Neither module can be changed, tested or released on its own until one of these dependencies is removed.

27→30 TypeDeclaration.TypeInferer uses NodeAnalyzer part of a loop✕

Connections

2 pairs of types, where a type in TypeDeclaration.TypeInferer uses a type in NodeAnalyzer.

The types involved

• Rector.TypeDeclaration.TypeInferer.AssignToPropertyTypeInferer → Rector.NodeAnalyzer.ExprAnalyzer
• Rector.TypeDeclaration.TypeInferer.AssignToPropertyTypeInferer → Rector.NodeAnalyzer.PropertyFetchAnalyzer

Direction

TypeDeclaration.TypeInferer uses NodeAnalyzer, so a change to NodeAnalyzer can break TypeDeclaration.TypeInferer, while a change to TypeDeclaration.TypeInferer can't break NodeAnalyzer.

Position

Above the diagonal, so it is part of a loop. Neither module can be changed, tested or released on its own until one of these dependencies is removed.

28→4 TypeDeclaration.NodeAnalyzer uses NodeTypeResolver.PHPStan.Type✕

Connections

1 pair of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in NodeTypeResolver.PHPStan.Type.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.CallTypesResolver → Rector.NodeTypeResolver.PHPStan.Type.TypeFactory

Direction

TypeDeclaration.NodeAnalyzer uses NodeTypeResolver.PHPStan.Type, so a change to NodeTypeResolver.PHPStan.Type can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break NodeTypeResolver.PHPStan.Type.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

28→8 TypeDeclaration.NodeAnalyzer uses StaticTypeMapper✕

Connections

4 pairs of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in StaticTypeMapper.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.ArrayCallbackParamTypeResolver → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.NodeAnalyzer.ClassMethodParamTypeCompleter → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.NodeAnalyzer.SetUpAssignedPropertyTyper → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.NodeAnalyzer.StrictTypeSafetyChecker → Rector.StaticTypeMapper.StaticTypeMapper

Direction

TypeDeclaration.NodeAnalyzer uses StaticTypeMapper, so a change to StaticTypeMapper can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break StaticTypeMapper.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

28→10 TypeDeclaration.NodeAnalyzer uses BetterPhpDocParser.PhpDocInfo✕

Connections

4 pairs of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in BetterPhpDocParser.PhpDocInfo.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.AutowiredClassMethodOrPropertyAnalyzer → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.TypeDeclaration.NodeAnalyzer.SetUpAssignedPropertyTyper → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.TypeDeclaration.NodeAnalyzer.SetUpAssignedPropertyTyper → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.TypeDeclaration.NodeAnalyzer.StrictReturnNewArrayResolver → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory

Direction

TypeDeclaration.NodeAnalyzer uses BetterPhpDocParser.PhpDocInfo, so a change to BetterPhpDocParser.PhpDocInfo can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break BetterPhpDocParser.PhpDocInfo.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

28→11 TypeDeclaration.NodeAnalyzer uses NodeNameResolver✕

Connections

5 pairs of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in NodeNameResolver.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.ArrayCallbackParamTypeResolver → Rector.NodeNameResolver.NodeNameResolver
• Rector.TypeDeclaration.NodeAnalyzer.ClassMethodAndPropertyAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.TypeDeclaration.NodeAnalyzer.ParamAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.TypeDeclaration.NodeAnalyzer.SetUpAssignedPropertyTyper → Rector.NodeNameResolver.NodeNameResolver
• Rector.TypeDeclaration.NodeAnalyzer.StrictReturnNewArrayResolver → Rector.NodeNameResolver.NodeNameResolver

Direction

TypeDeclaration.NodeAnalyzer uses NodeNameResolver, so a change to NodeNameResolver can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break NodeNameResolver.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

28→12 TypeDeclaration.NodeAnalyzer uses Comments.NodeDocBlock✕

Connections

1 pair of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in Comments.NodeDocBlock.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.SetUpAssignedPropertyTyper → Rector.Comments.NodeDocBlock.DocBlockUpdater

Direction

TypeDeclaration.NodeAnalyzer uses Comments.NodeDocBlock, so a change to Comments.NodeDocBlock can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break Comments.NodeDocBlock.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

28→13 TypeDeclaration.NodeAnalyzer uses NodeTypeResolver✕

Connections

5 pairs of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in NodeTypeResolver.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.ArrayCallbackParamTypeResolver → Rector.NodeTypeResolver.NodeTypeResolver
• Rector.TypeDeclaration.NodeAnalyzer.CallTypesResolver → Rector.NodeTypeResolver.NodeTypeResolver
• Rector.TypeDeclaration.NodeAnalyzer.NeverFuncCallAnalyzer → Rector.NodeTypeResolver.NodeTypeResolver
• Rector.TypeDeclaration.NodeAnalyzer.StrictReturnNewArrayResolver → Rector.NodeTypeResolver.NodeTypeResolver
• Rector.TypeDeclaration.NodeAnalyzer.StrictTypeSafetyChecker → Rector.NodeTypeResolver.NodeTypeResolver

Direction

TypeDeclaration.NodeAnalyzer uses NodeTypeResolver, so a change to NodeTypeResolver can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break NodeTypeResolver.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

28→14 TypeDeclaration.NodeAnalyzer uses PhpParser.Node✕

Connections

5 pairs of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in PhpParser.Node.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.DeclareStrictTypeFinder → Rector.PhpParser.Node.FileNode
• Rector.TypeDeclaration.NodeAnalyzer.SetUpAssignedPropertyTyper → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.NodeAnalyzer.StrictReturnNewArrayResolver → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.NodeAnalyzer.StrictTypeSafetyChecker → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.NodeAnalyzer.StrictTypeSafetyChecker → Rector.PhpParser.Node.FileNode

Direction

TypeDeclaration.NodeAnalyzer uses PhpParser.Node, so a change to PhpParser.Node can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break PhpParser.Node.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

28→16 TypeDeclaration.NodeAnalyzer uses BetterPhpDocParser.PhpDocManipulator✕

Connections

1 pair of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in BetterPhpDocParser.PhpDocManipulator.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.StrictReturnNewArrayResolver → Rector.BetterPhpDocParser.PhpDocManipulator.PhpDocTypeChanger

Direction

TypeDeclaration.NodeAnalyzer uses BetterPhpDocParser.PhpDocManipulator, so a change to BetterPhpDocParser.PhpDocManipulator can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break BetterPhpDocParser.PhpDocManipulator.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

28→18 TypeDeclaration.NodeAnalyzer uses Reflection✕

Connections

1 pair of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in Reflection.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.StrictTypeSafetyChecker → Rector.Reflection.ReflectionResolver

Direction

TypeDeclaration.NodeAnalyzer uses Reflection, so a change to Reflection can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break Reflection.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

28→22 TypeDeclaration.NodeAnalyzer uses PhpParser.Comparing✕

Connections

2 pairs of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in PhpParser.Comparing.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.StrictReturnNewArrayResolver → Rector.PhpParser.Comparing.NodeComparator
• Rector.TypeDeclaration.NodeAnalyzer.TypeNodeUnwrapper → Rector.PhpParser.Comparing.NodeComparator

Direction

TypeDeclaration.NodeAnalyzer uses PhpParser.Comparing, so a change to PhpParser.Comparing can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break PhpParser.Comparing.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

28→23 TypeDeclaration.NodeAnalyzer uses PhpParser.Node.Value✕

Connections

1 pair of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in PhpParser.Node.Value.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.JMSTypeAnalyzer → Rector.PhpParser.Node.Value.ValueResolver

Direction

TypeDeclaration.NodeAnalyzer uses PhpParser.Node.Value, so a change to PhpParser.Node.Value can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break PhpParser.Node.Value.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

28→25 TypeDeclaration.NodeAnalyzer uses Php80.NodeAnalyzer✕

Connections

2 pairs of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in Php80.NodeAnalyzer.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.AutowiredClassMethodOrPropertyAnalyzer → Rector.Php80.NodeAnalyzer.PhpAttributeAnalyzer
• Rector.TypeDeclaration.NodeAnalyzer.JMSTypeAnalyzer → Rector.Php80.NodeAnalyzer.PhpAttributeAnalyzer

Direction

TypeDeclaration.NodeAnalyzer uses Php80.NodeAnalyzer, so a change to Php80.NodeAnalyzer can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break Php80.NodeAnalyzer.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

28→27 TypeDeclaration.NodeAnalyzer uses TypeDeclaration.TypeInferer✕

Connections

2 pairs of types, where a type in TypeDeclaration.NodeAnalyzer uses a type in TypeDeclaration.TypeInferer.

The types involved

• Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer → Rector.TypeDeclaration.TypeInferer.SilentVoidResolver
• Rector.TypeDeclaration.NodeAnalyzer.StrictReturnNewArrayResolver → Rector.TypeDeclaration.TypeInferer.ReturnTypeInferer

Direction

TypeDeclaration.NodeAnalyzer uses TypeDeclaration.TypeInferer, so a change to TypeDeclaration.TypeInferer can break TypeDeclaration.NodeAnalyzer, while a change to TypeDeclaration.NodeAnalyzer can't break TypeDeclaration.TypeInferer.

Position

Below the diagonal: TypeDeclaration.NodeAnalyzer uses a module listed above it, which is the healthy direction.

29→5 NodeManipulator uses Php✕

Connections

1 pair of types, where a type in NodeManipulator uses a type in Php.

The types involved

• Rector.NodeManipulator.ClassDependencyManipulator → Rector.Php.PhpVersionProvider

Direction

NodeManipulator uses Php, so a change to Php can break NodeManipulator, while a change to NodeManipulator can't break Php.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→6 NodeManipulator uses PhpDocParser.NodeTraverser✕

Connections

3 pairs of types, where a type in NodeManipulator uses a type in PhpDocParser.NodeTraverser.

The types involved

• Rector.NodeManipulator.ClassMethodPropertyFetchManipulator → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser
• Rector.NodeManipulator.PropertyFetchAssignManipulator → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser
• Rector.NodeManipulator.StmtsManipulator → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser

Direction

NodeManipulator uses PhpDocParser.NodeTraverser, so a change to PhpDocParser.NodeTraverser can break NodeManipulator, while a change to NodeManipulator can't break PhpDocParser.NodeTraverser.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→10 NodeManipulator uses BetterPhpDocParser.PhpDocInfo✕

Connections

2 pairs of types, where a type in NodeManipulator uses a type in BetterPhpDocParser.PhpDocInfo.

The types involved

• Rector.NodeManipulator.PropertyManipulator → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.NodeManipulator.PropertyManipulator → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory

Direction

NodeManipulator uses BetterPhpDocParser.PhpDocInfo, so a change to BetterPhpDocParser.PhpDocInfo can break NodeManipulator, while a change to NodeManipulator can't break BetterPhpDocParser.PhpDocInfo.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→11 NodeManipulator uses NodeNameResolver✕

Connections

10 pairs of types, where a type in NodeManipulator uses a type in NodeNameResolver.

The types involved

• Rector.NodeManipulator.AssignManipulator → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeManipulator.ClassConstManipulator → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeManipulator.ClassDependencyManipulator → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeManipulator.ClassManipulator → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeManipulator.ClassMethodAssignManipulator → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeManipulator.ClassMethodManipulator → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeManipulator.ClassMethodPropertyFetchManipulator → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeManipulator.FunctionLikeManipulator → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeManipulator.PropertyFetchAssignManipulator → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeManipulator.PropertyManipulator → Rector.NodeNameResolver.NodeNameResolver

Direction

NodeManipulator uses NodeNameResolver, so a change to NodeNameResolver can break NodeManipulator, while a change to NodeManipulator can't break NodeNameResolver.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→13 NodeManipulator uses NodeTypeResolver✕

Connections

2 pairs of types, where a type in NodeManipulator uses a type in NodeTypeResolver.

The types involved

• Rector.NodeManipulator.ClassConstManipulator → Rector.NodeTypeResolver.NodeTypeResolver
• Rector.NodeManipulator.PropertyManipulator → Rector.NodeTypeResolver.NodeTypeResolver

Direction

NodeManipulator uses NodeTypeResolver, so a change to NodeTypeResolver can break NodeManipulator, while a change to NodeManipulator can't break NodeTypeResolver.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→14 NodeManipulator uses PhpParser.Node✕

Connections

8 pairs of types, where a type in NodeManipulator uses a type in PhpParser.Node.

The types involved

• Rector.NodeManipulator.AssignManipulator → Rector.PhpParser.Node.BetterNodeFinder
• Rector.NodeManipulator.BinaryOpManipulator → Rector.PhpParser.Node.AssignAndBinaryMap
• Rector.NodeManipulator.ClassConstManipulator → Rector.PhpParser.Node.BetterNodeFinder
• Rector.NodeManipulator.ClassDependencyManipulator → Rector.PhpParser.Node.NodeFactory
• Rector.NodeManipulator.ClassInsertManipulator → Rector.PhpParser.Node.NodeFactory
• Rector.NodeManipulator.ClassMethodAssignManipulator → Rector.PhpParser.Node.NodeFactory
• Rector.NodeManipulator.PropertyManipulator → Rector.PhpParser.Node.BetterNodeFinder
• Rector.NodeManipulator.StmtsManipulator → Rector.PhpParser.Node.BetterNodeFinder

Direction

NodeManipulator uses PhpParser.Node, so a change to PhpParser.Node can break NodeManipulator, while a change to NodeManipulator can't break PhpParser.Node.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→18 NodeManipulator uses Reflection✕

Connections

2 pairs of types, where a type in NodeManipulator uses a type in Reflection.

The types involved

• Rector.NodeManipulator.ClassDependencyManipulator → Rector.Reflection.ReflectionResolver
• Rector.NodeManipulator.ClassMethodManipulator → Rector.Reflection.ReflectionResolver

Direction

NodeManipulator uses Reflection, so a change to Reflection can break NodeManipulator, while a change to NodeManipulator can't break Reflection.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→21 NodeManipulator uses PhpParser✕

Connections

3 pairs of types, where a type in NodeManipulator uses a type in PhpParser.

The types involved

• Rector.NodeManipulator.ClassConstManipulator → Rector.PhpParser.AstResolver
• Rector.NodeManipulator.ClassDependencyManipulator → Rector.PhpParser.AstResolver
• Rector.NodeManipulator.PropertyManipulator → Rector.PhpParser.AstResolver

Direction

NodeManipulator uses PhpParser, so a change to PhpParser can break NodeManipulator, while a change to NodeManipulator can't break PhpParser.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→22 NodeManipulator uses PhpParser.Comparing✕

Connections

2 pairs of types, where a type in NodeManipulator uses a type in PhpParser.Comparing.

The types involved

• Rector.NodeManipulator.IfManipulator → Rector.PhpParser.Comparing.NodeComparator
• Rector.NodeManipulator.StmtsManipulator → Rector.PhpParser.Comparing.NodeComparator

Direction

NodeManipulator uses PhpParser.Comparing, so a change to PhpParser.Comparing can break NodeManipulator, while a change to NodeManipulator can't break PhpParser.Comparing.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→23 NodeManipulator uses PhpParser.Node.Value✕

Connections

2 pairs of types, where a type in NodeManipulator uses a type in PhpParser.Node.Value.

The types involved

• Rector.NodeManipulator.FuncCallManipulator → Rector.PhpParser.Node.Value.ValueResolver
• Rector.NodeManipulator.IfManipulator → Rector.PhpParser.Node.Value.ValueResolver

Direction

NodeManipulator uses PhpParser.Node.Value, so a change to PhpParser.Node.Value can break NodeManipulator, while a change to NodeManipulator can't break PhpParser.Node.Value.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→24 NodeManipulator uses DeadCode.NodeAnalyzer✕

Connections

1 pair of types, where a type in NodeManipulator uses a type in DeadCode.NodeAnalyzer.

The types involved

• Rector.NodeManipulator.StmtsManipulator → Rector.DeadCode.NodeAnalyzer.ExprUsedInNodeAnalyzer

Direction

NodeManipulator uses DeadCode.NodeAnalyzer, so a change to DeadCode.NodeAnalyzer can break NodeManipulator, while a change to NodeManipulator can't break DeadCode.NodeAnalyzer.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→25 NodeManipulator uses Php80.NodeAnalyzer✕

Connections

2 pairs of types, where a type in NodeManipulator uses a type in Php80.NodeAnalyzer.

The types involved

• Rector.NodeManipulator.PropertyManipulator → Rector.Php80.NodeAnalyzer.PhpAttributeAnalyzer
• Rector.NodeManipulator.PropertyManipulator → Rector.Php80.NodeAnalyzer.PromotedPropertyResolver

Direction

NodeManipulator uses Php80.NodeAnalyzer, so a change to Php80.NodeAnalyzer can break NodeManipulator, while a change to NodeManipulator can't break Php80.NodeAnalyzer.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→26 NodeManipulator uses PhpParser.NodeFinder✕

Connections

1 pair of types, where a type in NodeManipulator uses a type in PhpParser.NodeFinder.

The types involved

• Rector.NodeManipulator.PropertyManipulator → Rector.PhpParser.NodeFinder.PropertyFetchFinder

Direction

NodeManipulator uses PhpParser.NodeFinder, so a change to PhpParser.NodeFinder can break NodeManipulator, while a change to NodeManipulator can't break PhpParser.NodeFinder.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→28 NodeManipulator uses TypeDeclaration.NodeAnalyzer✕

Connections

1 pair of types, where a type in NodeManipulator uses a type in TypeDeclaration.NodeAnalyzer.

The types involved

• Rector.NodeManipulator.ClassDependencyManipulator → Rector.TypeDeclaration.NodeAnalyzer.AutowiredClassMethodOrPropertyAnalyzer

Direction

NodeManipulator uses TypeDeclaration.NodeAnalyzer, so a change to TypeDeclaration.NodeAnalyzer can break NodeManipulator, while a change to NodeManipulator can't break TypeDeclaration.NodeAnalyzer.

Position

Below the diagonal: NodeManipulator uses a module listed above it, which is the healthy direction.

29→30 NodeManipulator uses NodeAnalyzer part of a loop✕

Connections

4 pairs of types, where a type in NodeManipulator uses a type in NodeAnalyzer.

The types involved

• Rector.NodeManipulator.AssignManipulator → Rector.NodeAnalyzer.PropertyFetchAnalyzer
• Rector.NodeManipulator.ClassDependencyManipulator → Rector.NodeAnalyzer.PropertyPresenceChecker
• Rector.NodeManipulator.PropertyFetchAssignManipulator → Rector.NodeAnalyzer.PropertyFetchAnalyzer
• Rector.NodeManipulator.PropertyManipulator → Rector.NodeAnalyzer.PropertyFetchAnalyzer

Direction

NodeManipulator uses NodeAnalyzer, so a change to NodeAnalyzer can break NodeManipulator, while a change to NodeManipulator can't break NodeAnalyzer.

Position

Above the diagonal, so it is part of a loop. Neither module can be changed, tested or released on its own until one of these dependencies is removed.

30→6 NodeAnalyzer uses PhpDocParser.NodeTraverser✕

Connections

2 pairs of types, where a type in NodeAnalyzer uses a type in PhpDocParser.NodeTraverser.

The types involved

• Rector.NodeAnalyzer.ParamAnalyzer → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser
• Rector.NodeAnalyzer.TerminatedNodeAnalyzer → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser

Direction

NodeAnalyzer uses PhpDocParser.NodeTraverser, so a change to PhpDocParser.NodeTraverser can break NodeAnalyzer, while a change to NodeAnalyzer can't break PhpDocParser.NodeTraverser.

Position

Below the diagonal: NodeAnalyzer uses a module listed above it, which is the healthy direction.

30→10 NodeAnalyzer uses BetterPhpDocParser.PhpDocInfo✕

Connections

1 pair of types, where a type in NodeAnalyzer uses a type in BetterPhpDocParser.PhpDocInfo.

The types involved

• Rector.NodeAnalyzer.DoctrineEntityAnalyzer → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory

Direction

NodeAnalyzer uses BetterPhpDocParser.PhpDocInfo, so a change to BetterPhpDocParser.PhpDocInfo can break NodeAnalyzer, while a change to NodeAnalyzer can't break BetterPhpDocParser.PhpDocInfo.

Position

Below the diagonal: NodeAnalyzer uses a module listed above it, which is the healthy direction.

30→11 NodeAnalyzer uses NodeNameResolver✕

Connections

8 pairs of types, where a type in NodeAnalyzer uses a type in NodeNameResolver.

The types involved

• Rector.NodeAnalyzer.ArgsAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeAnalyzer.BinaryOpAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeAnalyzer.CompactFuncCallAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeAnalyzer.ExprAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeAnalyzer.MagicClassMethodAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeAnalyzer.ParamAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeAnalyzer.PropertyFetchAnalyzer → Rector.NodeNameResolver.NodeNameResolver
• Rector.NodeAnalyzer.PropertyPresenceChecker → Rector.NodeNameResolver.NodeNameResolver

Direction

NodeAnalyzer uses NodeNameResolver, so a change to NodeNameResolver can break NodeAnalyzer, while a change to NodeAnalyzer can't break NodeNameResolver.

Position

Below the diagonal: NodeAnalyzer uses a module listed above it, which is the healthy direction.

30→13 NodeAnalyzer uses NodeTypeResolver✕

Connections

2 pairs of types, where a type in NodeAnalyzer uses a type in NodeTypeResolver.

The types involved

• Rector.NodeAnalyzer.PropertyAnalyzer → Rector.NodeTypeResolver.NodeTypeResolver
• Rector.NodeAnalyzer.PropertyFetchAnalyzer → Rector.NodeTypeResolver.NodeTypeResolver

Direction

NodeAnalyzer uses NodeTypeResolver, so a change to NodeTypeResolver can break NodeAnalyzer, while a change to NodeAnalyzer can't break NodeTypeResolver.

Position

Below the diagonal: NodeAnalyzer uses a module listed above it, which is the healthy direction.

30→14 NodeAnalyzer uses PhpParser.Node✕

Connections

2 pairs of types, where a type in NodeAnalyzer uses a type in PhpParser.Node.

The types involved

• Rector.NodeAnalyzer.ParamAnalyzer → Rector.PhpParser.Node.BetterNodeFinder
• Rector.NodeAnalyzer.PropertyFetchAnalyzer → Rector.PhpParser.Node.BetterNodeFinder

Direction

NodeAnalyzer uses PhpParser.Node, so a change to PhpParser.Node can break NodeAnalyzer, while a change to NodeAnalyzer can't break PhpParser.Node.

Position

Below the diagonal: NodeAnalyzer uses a module listed above it, which is the healthy direction.

30→18 NodeAnalyzer uses Reflection✕

Connections

3 pairs of types, where a type in NodeAnalyzer uses a type in Reflection.

The types involved

• Rector.NodeAnalyzer.CallLikeArgumentNameAdder → Rector.Reflection.ReflectionResolver
• Rector.NodeAnalyzer.PropertyFetchAnalyzer → Rector.Reflection.ReflectionResolver
• Rector.NodeAnalyzer.VariadicAnalyzer → Rector.Reflection.ReflectionResolver

Direction

NodeAnalyzer uses Reflection, so a change to Reflection can break NodeAnalyzer, while a change to NodeAnalyzer can't break Reflection.

Position

Below the diagonal: NodeAnalyzer uses a module listed above it, which is the healthy direction.

30→21 NodeAnalyzer uses PhpParser✕

Connections

1 pair of types, where a type in NodeAnalyzer uses a type in PhpParser.

The types involved

• Rector.NodeAnalyzer.PropertyFetchAnalyzer → Rector.PhpParser.AstResolver

Direction

NodeAnalyzer uses PhpParser, so a change to PhpParser can break NodeAnalyzer, while a change to NodeAnalyzer can't break PhpParser.

Position

Below the diagonal: NodeAnalyzer uses a module listed above it, which is the healthy direction.

30→22 NodeAnalyzer uses PhpParser.Comparing✕

Connections

1 pair of types, where a type in NodeAnalyzer uses a type in PhpParser.Comparing.

The types involved

• Rector.NodeAnalyzer.ParamAnalyzer → Rector.PhpParser.Comparing.NodeComparator

Direction

NodeAnalyzer uses PhpParser.Comparing, so a change to PhpParser.Comparing can break NodeAnalyzer, while a change to NodeAnalyzer can't break PhpParser.Comparing.

Position

Below the diagonal: NodeAnalyzer uses a module listed above it, which is the healthy direction.

30→25 NodeAnalyzer uses Php80.NodeAnalyzer✕

Connections

1 pair of types, where a type in NodeAnalyzer uses a type in Php80.NodeAnalyzer.

The types involved

• Rector.NodeAnalyzer.PropertyPresenceChecker → Rector.Php80.NodeAnalyzer.PromotedPropertyResolver

Direction

NodeAnalyzer uses Php80.NodeAnalyzer, so a change to Php80.NodeAnalyzer can break NodeAnalyzer, while a change to NodeAnalyzer can't break Php80.NodeAnalyzer.

Position

Below the diagonal: NodeAnalyzer uses a module listed above it, which is the healthy direction.

30→29 NodeAnalyzer uses NodeManipulator✕

Connections

1 pair of types, where a type in NodeAnalyzer uses a type in NodeManipulator.

The types involved

• Rector.NodeAnalyzer.ParamAnalyzer → Rector.NodeManipulator.FuncCallManipulator

Direction

NodeAnalyzer uses NodeManipulator, so a change to NodeManipulator can break NodeAnalyzer, while a change to NodeAnalyzer can't break NodeManipulator.

Position

Below the diagonal: NodeAnalyzer uses a module listed above it, which is the healthy direction.

31→3 Application uses FileSystem✕

Connections

2 pairs of types, where a type in Application uses a type in FileSystem.

The types involved

• Rector.Application.ApplicationFileProcessor → Rector.FileSystem.FilesFinder
• Rector.Application.FileProcessor → Rector.FileSystem.FilePathHelper

Direction

Application uses FileSystem, so a change to FileSystem can break Application, while a change to Application can't break FileSystem.

Position

Below the diagonal: Application uses a module listed above it, which is the healthy direction.

31→6 Application uses PhpDocParser.NodeTraverser✕

Connections

1 pair of types, where a type in Application uses a type in PhpDocParser.NodeTraverser.

The types involved

• Rector.Application.ChangedNodeScopeRefresher → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser

Direction

Application uses PhpDocParser.NodeTraverser, so a change to PhpDocParser.NodeTraverser can break Application, while a change to Application can't break PhpDocParser.NodeTraverser.

Position

Below the diagonal: Application uses a module listed above it, which is the healthy direction.

31→13 Application uses NodeTypeResolver✕

Connections

1 pair of types, where a type in Application uses a type in NodeTypeResolver.

The types involved

• Rector.Application.FileProcessor → Rector.NodeTypeResolver.NodeScopeAndMetadataDecorator

Direction

Application uses NodeTypeResolver, so a change to NodeTypeResolver can break Application, while a change to Application can't break NodeTypeResolver.

Position

Below the diagonal: Application uses a module listed above it, which is the healthy direction.

31→17 Application uses PhpParser.Printer✕

Connections

1 pair of types, where a type in Application uses a type in PhpParser.Printer.

The types involved

• Rector.Application.FileProcessor → Rector.PhpParser.Printer.BetterStandardPrinter

Direction

Application uses PhpParser.Printer, so a change to PhpParser.Printer can break Application, while a change to Application can't break PhpParser.Printer.

Position

Below the diagonal: Application uses a module listed above it, which is the healthy direction.

31→19 Application uses ValueObject.Application✕

Connections

3 pairs of types, where a type in Application uses a type in ValueObject.Application.

The types involved

• Rector.Application.ApplicationFileProcessor → Rector.ValueObject.Application.File
• Rector.Application.FileProcessor → Rector.ValueObject.Application.File
• Rector.Application.RectorRegistry → Rector.ValueObject.Application.File

Direction

Application uses ValueObject.Application, so a change to ValueObject.Application can break Application, while a change to Application can't break ValueObject.Application.

Position

Below the diagonal: Application uses a module listed above it, which is the healthy direction.

31→30 Application uses NodeAnalyzer✕

Connections

1 pair of types, where a type in Application uses a type in NodeAnalyzer.

The types involved

• Rector.Application.ChangedNodeScopeRefresher → Rector.NodeAnalyzer.ScopeAnalyzer

Direction

Application uses NodeAnalyzer, so a change to NodeAnalyzer can break Application, while a change to Application can't break NodeAnalyzer.

Position

Below the diagonal: Application uses a module listed above it, which is the healthy direction.

32→4 TypeDeclaration.TypeInferer.PropertyTypeInferer uses NodeTypeResolver.PHPStan.Type✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer.PropertyTypeInferer uses a type in NodeTypeResolver.PHPStan.Type.

The types involved

• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.TrustedClassMethodPropertyTypeInferer → Rector.NodeTypeResolver.PHPStan.Type.TypeFactory

Direction

TypeDeclaration.TypeInferer.PropertyTypeInferer uses NodeTypeResolver.PHPStan.Type, so a change to NodeTypeResolver.PHPStan.Type can break TypeDeclaration.TypeInferer.PropertyTypeInferer, while a change to TypeDeclaration.TypeInferer.PropertyTypeInferer can't break NodeTypeResolver.PHPStan.Type.

Position

Below the diagonal: TypeDeclaration.TypeInferer.PropertyTypeInferer uses a module listed above it, which is the healthy direction.

32→6 TypeDeclaration.TypeInferer.PropertyTypeInferer uses PhpDocParser.NodeTraverser✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer.PropertyTypeInferer uses a type in PhpDocParser.NodeTraverser.

The types involved

• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.TrustedClassMethodPropertyTypeInferer → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser

Direction

TypeDeclaration.TypeInferer.PropertyTypeInferer uses PhpDocParser.NodeTraverser, so a change to PhpDocParser.NodeTraverser can break TypeDeclaration.TypeInferer.PropertyTypeInferer, while a change to TypeDeclaration.TypeInferer.PropertyTypeInferer can't break PhpDocParser.NodeTraverser.

Position

Below the diagonal: TypeDeclaration.TypeInferer.PropertyTypeInferer uses a module listed above it, which is the healthy direction.

32→8 TypeDeclaration.TypeInferer.PropertyTypeInferer uses StaticTypeMapper✕

Connections

2 pairs of types, where a type in TypeDeclaration.TypeInferer.PropertyTypeInferer uses a type in StaticTypeMapper.

The types involved

• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.SetterTypeDeclarationPropertyTypeInferer → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.TrustedClassMethodPropertyTypeInferer → Rector.StaticTypeMapper.StaticTypeMapper

Direction

TypeDeclaration.TypeInferer.PropertyTypeInferer uses StaticTypeMapper, so a change to StaticTypeMapper can break TypeDeclaration.TypeInferer.PropertyTypeInferer, while a change to TypeDeclaration.TypeInferer.PropertyTypeInferer can't break StaticTypeMapper.

Position

Below the diagonal: TypeDeclaration.TypeInferer.PropertyTypeInferer uses a module listed above it, which is the healthy direction.

32→11 TypeDeclaration.TypeInferer.PropertyTypeInferer uses NodeNameResolver✕

Connections

4 pairs of types, where a type in TypeDeclaration.TypeInferer.PropertyTypeInferer uses a type in NodeNameResolver.

The types involved

• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.AllAssignNodePropertyTypeInferer → Rector.NodeNameResolver.NodeNameResolver
• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.GetterTypeDeclarationPropertyTypeInferer → Rector.NodeNameResolver.NodeNameResolver
• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.SetterTypeDeclarationPropertyTypeInferer → Rector.NodeNameResolver.NodeNameResolver
• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.TrustedClassMethodPropertyTypeInferer → Rector.NodeNameResolver.NodeNameResolver

Direction

TypeDeclaration.TypeInferer.PropertyTypeInferer uses NodeNameResolver, so a change to NodeNameResolver can break TypeDeclaration.TypeInferer.PropertyTypeInferer, while a change to TypeDeclaration.TypeInferer.PropertyTypeInferer can't break NodeNameResolver.

Position

Below the diagonal: TypeDeclaration.TypeInferer.PropertyTypeInferer uses a module listed above it, which is the healthy direction.

32→13 TypeDeclaration.TypeInferer.PropertyTypeInferer uses NodeTypeResolver✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer.PropertyTypeInferer uses a type in NodeTypeResolver.

The types involved

• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.TrustedClassMethodPropertyTypeInferer → Rector.NodeTypeResolver.NodeTypeResolver

Direction

TypeDeclaration.TypeInferer.PropertyTypeInferer uses NodeTypeResolver, so a change to NodeTypeResolver can break TypeDeclaration.TypeInferer.PropertyTypeInferer, while a change to TypeDeclaration.TypeInferer.PropertyTypeInferer can't break NodeTypeResolver.

Position

Below the diagonal: TypeDeclaration.TypeInferer.PropertyTypeInferer uses a module listed above it, which is the healthy direction.

32→14 TypeDeclaration.TypeInferer.PropertyTypeInferer uses PhpParser.Node✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer.PropertyTypeInferer uses a type in PhpParser.Node.

The types involved

• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.AllAssignNodePropertyTypeInferer → Rector.PhpParser.Node.BetterNodeFinder

Direction

TypeDeclaration.TypeInferer.PropertyTypeInferer uses PhpParser.Node, so a change to PhpParser.Node can break TypeDeclaration.TypeInferer.PropertyTypeInferer, while a change to TypeDeclaration.TypeInferer.PropertyTypeInferer can't break PhpParser.Node.

Position

Below the diagonal: TypeDeclaration.TypeInferer.PropertyTypeInferer uses a module listed above it, which is the healthy direction.

32→19 TypeDeclaration.TypeInferer.PropertyTypeInferer uses ValueObject.Application✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer.PropertyTypeInferer uses a type in ValueObject.Application.

The types involved

• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.AllAssignNodePropertyTypeInferer → Rector.ValueObject.Application.File

Direction

TypeDeclaration.TypeInferer.PropertyTypeInferer uses ValueObject.Application, so a change to ValueObject.Application can break TypeDeclaration.TypeInferer.PropertyTypeInferer, while a change to TypeDeclaration.TypeInferer.PropertyTypeInferer can't break ValueObject.Application.

Position

Below the diagonal: TypeDeclaration.TypeInferer.PropertyTypeInferer uses a module listed above it, which is the healthy direction.

32→21 TypeDeclaration.TypeInferer.PropertyTypeInferer uses PhpParser✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer.PropertyTypeInferer uses a type in PhpParser.

The types involved

• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.AllAssignNodePropertyTypeInferer → Rector.PhpParser.AstResolver

Direction

TypeDeclaration.TypeInferer.PropertyTypeInferer uses PhpParser, so a change to PhpParser can break TypeDeclaration.TypeInferer.PropertyTypeInferer, while a change to TypeDeclaration.TypeInferer.PropertyTypeInferer can't break PhpParser.

Position

Below the diagonal: TypeDeclaration.TypeInferer.PropertyTypeInferer uses a module listed above it, which is the healthy direction.

32→27 TypeDeclaration.TypeInferer.PropertyTypeInferer uses TypeDeclaration.TypeInferer✕

Connections

2 pairs of types, where a type in TypeDeclaration.TypeInferer.PropertyTypeInferer uses a type in TypeDeclaration.TypeInferer.

The types involved

• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.AllAssignNodePropertyTypeInferer → Rector.TypeDeclaration.TypeInferer.AssignToPropertyTypeInferer
• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.TrustedClassMethodPropertyTypeInferer → Rector.TypeDeclaration.TypeInferer.AssignToPropertyTypeInferer

Direction

TypeDeclaration.TypeInferer.PropertyTypeInferer uses TypeDeclaration.TypeInferer, so a change to TypeDeclaration.TypeInferer can break TypeDeclaration.TypeInferer.PropertyTypeInferer, while a change to TypeDeclaration.TypeInferer.PropertyTypeInferer can't break TypeDeclaration.TypeInferer.

Position

Below the diagonal: TypeDeclaration.TypeInferer.PropertyTypeInferer uses a module listed above it, which is the healthy direction.

32→28 TypeDeclaration.TypeInferer.PropertyTypeInferer uses TypeDeclaration.NodeAnalyzer✕

Connections

2 pairs of types, where a type in TypeDeclaration.TypeInferer.PropertyTypeInferer uses a type in TypeDeclaration.NodeAnalyzer.

The types involved

• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.GetterTypeDeclarationPropertyTypeInferer → Rector.TypeDeclaration.NodeAnalyzer.ClassMethodAndPropertyAnalyzer
• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.SetterTypeDeclarationPropertyTypeInferer → Rector.TypeDeclaration.NodeAnalyzer.ClassMethodAndPropertyAnalyzer

Direction

TypeDeclaration.TypeInferer.PropertyTypeInferer uses TypeDeclaration.NodeAnalyzer, so a change to TypeDeclaration.NodeAnalyzer can break TypeDeclaration.TypeInferer.PropertyTypeInferer, while a change to TypeDeclaration.TypeInferer.PropertyTypeInferer can't break TypeDeclaration.NodeAnalyzer.

Position

Below the diagonal: TypeDeclaration.TypeInferer.PropertyTypeInferer uses a module listed above it, which is the healthy direction.

32→29 TypeDeclaration.TypeInferer.PropertyTypeInferer uses NodeManipulator✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer.PropertyTypeInferer uses a type in NodeManipulator.

The types involved

• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.TrustedClassMethodPropertyTypeInferer → Rector.NodeManipulator.ClassMethodPropertyFetchManipulator

Direction

TypeDeclaration.TypeInferer.PropertyTypeInferer uses NodeManipulator, so a change to NodeManipulator can break TypeDeclaration.TypeInferer.PropertyTypeInferer, while a change to TypeDeclaration.TypeInferer.PropertyTypeInferer can't break NodeManipulator.

Position

Below the diagonal: TypeDeclaration.TypeInferer.PropertyTypeInferer uses a module listed above it, which is the healthy direction.

32→30 TypeDeclaration.TypeInferer.PropertyTypeInferer uses NodeAnalyzer✕

Connections

1 pair of types, where a type in TypeDeclaration.TypeInferer.PropertyTypeInferer uses a type in NodeAnalyzer.

The types involved

• Rector.TypeDeclaration.TypeInferer.PropertyTypeInferer.TrustedClassMethodPropertyTypeInferer → Rector.NodeAnalyzer.ParamAnalyzer

Direction

TypeDeclaration.TypeInferer.PropertyTypeInferer uses NodeAnalyzer, so a change to NodeAnalyzer can break TypeDeclaration.TypeInferer.PropertyTypeInferer, while a change to TypeDeclaration.TypeInferer.PropertyTypeInferer can't break NodeAnalyzer.

Position

Below the diagonal: TypeDeclaration.TypeInferer.PropertyTypeInferer uses a module listed above it, which is the healthy direction.

33→2 Rector uses Contract.Rector✕

Connections

2 pairs of types, where a type in Rector uses a type in Contract.Rector.

The types involved

• Rector.Rector.AbstractRector → Rector.Contract.Rector.RectorInterface
• Rector.Rector.RectorRunner → Rector.Contract.Rector.RectorInterface

Direction

Rector uses Contract.Rector, so a change to Contract.Rector can break Rector, while a change to Rector can't break Contract.Rector.

Position

Below the diagonal: Rector uses a module listed above it, which is the healthy direction.

33→6 Rector uses PhpDocParser.NodeTraverser✕

Connections

1 pair of types, where a type in Rector uses a type in PhpDocParser.NodeTraverser.

The types involved

• Rector.Rector.AbstractRector → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser

Direction

Rector uses PhpDocParser.NodeTraverser, so a change to PhpDocParser.NodeTraverser can break Rector, while a change to Rector can't break PhpDocParser.NodeTraverser.

Position

Below the diagonal: Rector uses a module listed above it, which is the healthy direction.

33→11 Rector uses NodeNameResolver✕

Connections

1 pair of types, where a type in Rector uses a type in NodeNameResolver.

The types involved

• Rector.Rector.AbstractRector → Rector.NodeNameResolver.NodeNameResolver

Direction

Rector uses NodeNameResolver, so a change to NodeNameResolver can break Rector, while a change to Rector can't break NodeNameResolver.

Position

Below the diagonal: Rector uses a module listed above it, which is the healthy direction.

33→13 Rector uses NodeTypeResolver✕

Connections

1 pair of types, where a type in Rector uses a type in NodeTypeResolver.

The types involved

• Rector.Rector.AbstractRector → Rector.NodeTypeResolver.NodeTypeResolver

Direction

Rector uses NodeTypeResolver, so a change to NodeTypeResolver can break Rector, while a change to Rector can't break NodeTypeResolver.

Position

Below the diagonal: Rector uses a module listed above it, which is the healthy direction.

33→14 Rector uses PhpParser.Node✕

Connections

1 pair of types, where a type in Rector uses a type in PhpParser.Node.

The types involved

• Rector.Rector.AbstractRector → Rector.PhpParser.Node.NodeFactory

Direction

Rector uses PhpParser.Node, so a change to PhpParser.Node can break Rector, while a change to Rector can't break PhpParser.Node.

Position

Below the diagonal: Rector uses a module listed above it, which is the healthy direction.

33→19 Rector uses ValueObject.Application✕

Connections

2 pairs of types, where a type in Rector uses a type in ValueObject.Application.

The types involved

• Rector.Rector.AbstractRector → Rector.ValueObject.Application.File
• Rector.Rector.RectorRunner → Rector.ValueObject.Application.File

Direction

Rector uses ValueObject.Application, so a change to ValueObject.Application can break Rector, while a change to Rector can't break ValueObject.Application.

Position

Below the diagonal: Rector uses a module listed above it, which is the healthy direction.

33→22 Rector uses PhpParser.Comparing✕

Connections

1 pair of types, where a type in Rector uses a type in PhpParser.Comparing.

The types involved

• Rector.Rector.AbstractRector → Rector.PhpParser.Comparing.NodeComparator

Direction

Rector uses PhpParser.Comparing, so a change to PhpParser.Comparing can break Rector, while a change to Rector can't break PhpParser.Comparing.

Position

Below the diagonal: Rector uses a module listed above it, which is the healthy direction.

33→31 Rector uses Application✕

Connections

1 pair of types, where a type in Rector uses a type in Application.

The types involved

• Rector.Rector.RectorRunner → Rector.Application.ChangedNodeScopeRefresher

Direction

Rector uses Application, so a change to Application can break Rector, while a change to Rector can't break Application.

Position

Below the diagonal: Rector uses a module listed above it, which is the healthy direction.

34→1 CodeQuality.Rector.If_ uses Configuration.Deprecation.Contract✕

Connections

5 pairs of types, where a type in CodeQuality.Rector.If_ uses a type in Configuration.Deprecation.Contract.

The types involved

• Rector.CodeQuality.Rector.If_.CombineIfRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface
• Rector.CodeQuality.Rector.If_.ExplicitBoolCompareRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface
• Rector.CodeQuality.Rector.If_.ObjectExplicitBoolCompareRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface
• Rector.CodeQuality.Rector.If_.ShortenElseIfRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface
• Rector.CodeQuality.Rector.If_.SimplifyIfElseToTernaryRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface

Direction

CodeQuality.Rector.If_ uses Configuration.Deprecation.Contract, so a change to Configuration.Deprecation.Contract can break CodeQuality.Rector.If_, while a change to CodeQuality.Rector.If_ can't break Configuration.Deprecation.Contract.

Position

Below the diagonal: CodeQuality.Rector.If_ uses a module listed above it, which is the healthy direction.

34→7 CodeQuality.Rector.If_ uses RuleDoc✕

Connections

12 pairs of types, where a type in CodeQuality.Rector.If_ uses a type in RuleDoc.

The types involved

• Rector.CodeQuality.Rector.If_.ArrayExplicitBoolCompareRector → Rector.RuleDoc.RuleDefinition
• Rector.CodeQuality.Rector.If_.CombineIfRector → Rector.RuleDoc.RuleDefinition
• Rector.CodeQuality.Rector.If_.CompleteMissingIfElseBracketRector → Rector.RuleDoc.RuleDefinition
• Rector.CodeQuality.Rector.If_.ConsecutiveNullCompareReturnsToNullCoalesceQueueRector → Rector.RuleDoc.RuleDefinition
• Rector.CodeQuality.Rector.If_.ExplicitBoolCompareRector → Rector.RuleDoc.RuleDefinition
• Rector.CodeQuality.Rector.If_.ExplicitNullableObjectInstanceRector → Rector.RuleDoc.RuleDefinition
• Rector.CodeQuality.Rector.If_.ObjectExplicitBoolCompareRector → Rector.RuleDoc.RuleDefinition
• Rector.CodeQuality.Rector.If_.ShortenElseIfRector → Rector.RuleDoc.RuleDefinition
• Rector.CodeQuality.Rector.If_.SimplifyIfElseToTernaryRector → Rector.RuleDoc.RuleDefinition
• Rector.CodeQuality.Rector.If_.SimplifyIfNotNullReturnRector → Rector.RuleDoc.RuleDefinition
• Rector.CodeQuality.Rector.If_.SimplifyIfNullableReturnRector → Rector.RuleDoc.RuleDefinition
• Rector.CodeQuality.Rector.If_.SimplifyIfReturnBoolRector → Rector.RuleDoc.RuleDefinition

Direction

CodeQuality.Rector.If_ uses RuleDoc, so a change to RuleDoc can break CodeQuality.Rector.If_, while a change to CodeQuality.Rector.If_ can't break RuleDoc.

Position

Below the diagonal: CodeQuality.Rector.If_ uses a module listed above it, which is the healthy direction.

34→9 CodeQuality.Rector.If_ uses VersionBonding.Contract✕

Connections

1 pair of types, where a type in CodeQuality.Rector.If_ uses a type in VersionBonding.Contract.

The types involved

• Rector.CodeQuality.Rector.If_.ConsecutiveNullCompareReturnsToNullCoalesceQueueRector → Rector.VersionBonding.Contract.MinPhpVersionInterface

Direction

CodeQuality.Rector.If_ uses VersionBonding.Contract, so a change to VersionBonding.Contract can break CodeQuality.Rector.If_, while a change to CodeQuality.Rector.If_ can't break VersionBonding.Contract.

Position

Below the diagonal: CodeQuality.Rector.If_ uses a module listed above it, which is the healthy direction.

34→14 CodeQuality.Rector.If_ uses PhpParser.Node✕

Connections

1 pair of types, where a type in CodeQuality.Rector.If_ uses a type in PhpParser.Node.

The types involved

• Rector.CodeQuality.Rector.If_.ExplicitNullableObjectInstanceRector → Rector.PhpParser.Node.NullableObjectToInstanceofFactory

Direction

CodeQuality.Rector.If_ uses PhpParser.Node, so a change to PhpParser.Node can break CodeQuality.Rector.If_, while a change to CodeQuality.Rector.If_ can't break PhpParser.Node.

Position

Below the diagonal: CodeQuality.Rector.If_ uses a module listed above it, which is the healthy direction.

34→17 CodeQuality.Rector.If_ uses PhpParser.Printer✕

Connections

1 pair of types, where a type in CodeQuality.Rector.If_ uses a type in PhpParser.Printer.

The types involved

• Rector.CodeQuality.Rector.If_.SimplifyIfReturnBoolRector → Rector.PhpParser.Printer.BetterStandardPrinter

Direction

CodeQuality.Rector.If_ uses PhpParser.Printer, so a change to PhpParser.Printer can break CodeQuality.Rector.If_, while a change to CodeQuality.Rector.If_ can't break PhpParser.Printer.

Position

Below the diagonal: CodeQuality.Rector.If_ uses a module listed above it, which is the healthy direction.

34→20 CodeQuality.Rector.If_ uses DeadCode.PhpDoc.TagRemover✕

Connections

1 pair of types, where a type in CodeQuality.Rector.If_ uses a type in DeadCode.PhpDoc.TagRemover.

The types involved

• Rector.CodeQuality.Rector.If_.SimplifyIfNullableReturnRector → Rector.DeadCode.PhpDoc.TagRemover.VarTagRemover

Direction

CodeQuality.Rector.If_ uses DeadCode.PhpDoc.TagRemover, so a change to DeadCode.PhpDoc.TagRemover can break CodeQuality.Rector.If_, while a change to CodeQuality.Rector.If_ can't break DeadCode.PhpDoc.TagRemover.

Position

Below the diagonal: CodeQuality.Rector.If_ uses a module listed above it, which is the healthy direction.

34→23 CodeQuality.Rector.If_ uses PhpParser.Node.Value✕

Connections

5 pairs of types, where a type in CodeQuality.Rector.If_ uses a type in PhpParser.Node.Value.

The types involved

• Rector.CodeQuality.Rector.If_.ConsecutiveNullCompareReturnsToNullCoalesceQueueRector → Rector.PhpParser.Node.Value.ValueResolver
• Rector.CodeQuality.Rector.If_.ExplicitNullableObjectInstanceRector → Rector.PhpParser.Node.Value.ValueResolver
• Rector.CodeQuality.Rector.If_.SimplifyIfNotNullReturnRector → Rector.PhpParser.Node.Value.ValueResolver
• Rector.CodeQuality.Rector.If_.SimplifyIfNullableReturnRector → Rector.PhpParser.Node.Value.ValueResolver
• Rector.CodeQuality.Rector.If_.SimplifyIfReturnBoolRector → Rector.PhpParser.Node.Value.ValueResolver

Direction

CodeQuality.Rector.If_ uses PhpParser.Node.Value, so a change to PhpParser.Node.Value can break CodeQuality.Rector.If_, while a change to CodeQuality.Rector.If_ can't break PhpParser.Node.Value.

Position

Below the diagonal: CodeQuality.Rector.If_ uses a module listed above it, which is the healthy direction.

34→29 CodeQuality.Rector.If_ uses NodeManipulator✕

Connections

3 pairs of types, where a type in CodeQuality.Rector.If_ uses a type in NodeManipulator.

The types involved

• Rector.CodeQuality.Rector.If_.ConsecutiveNullCompareReturnsToNullCoalesceQueueRector → Rector.NodeManipulator.IfManipulator
• Rector.CodeQuality.Rector.If_.SimplifyIfNotNullReturnRector → Rector.NodeManipulator.IfManipulator
• Rector.CodeQuality.Rector.If_.SimplifyIfNullableReturnRector → Rector.NodeManipulator.IfManipulator

Direction

CodeQuality.Rector.If_ uses NodeManipulator, so a change to NodeManipulator can break CodeQuality.Rector.If_, while a change to CodeQuality.Rector.If_ can't break NodeManipulator.

Position

Below the diagonal: CodeQuality.Rector.If_ uses a module listed above it, which is the healthy direction.

34→33 CodeQuality.Rector.If_ uses Rector✕

Connections

12 pairs of types, where a type in CodeQuality.Rector.If_ uses a type in Rector.

The types involved

• Rector.CodeQuality.Rector.If_.ArrayExplicitBoolCompareRector → Rector.Rector.AbstractRector
• Rector.CodeQuality.Rector.If_.CombineIfRector → Rector.Rector.AbstractRector
• Rector.CodeQuality.Rector.If_.CompleteMissingIfElseBracketRector → Rector.Rector.AbstractRector
• Rector.CodeQuality.Rector.If_.ConsecutiveNullCompareReturnsToNullCoalesceQueueRector → Rector.Rector.AbstractRector
• Rector.CodeQuality.Rector.If_.ExplicitBoolCompareRector → Rector.Rector.AbstractRector
• Rector.CodeQuality.Rector.If_.ExplicitNullableObjectInstanceRector → Rector.Rector.AbstractRector
• Rector.CodeQuality.Rector.If_.ObjectExplicitBoolCompareRector → Rector.Rector.AbstractRector
• Rector.CodeQuality.Rector.If_.ShortenElseIfRector → Rector.Rector.AbstractRector
• Rector.CodeQuality.Rector.If_.SimplifyIfElseToTernaryRector → Rector.Rector.AbstractRector
• Rector.CodeQuality.Rector.If_.SimplifyIfNotNullReturnRector → Rector.Rector.AbstractRector
• Rector.CodeQuality.Rector.If_.SimplifyIfNullableReturnRector → Rector.Rector.AbstractRector
• Rector.CodeQuality.Rector.If_.SimplifyIfReturnBoolRector → Rector.Rector.AbstractRector

Direction

CodeQuality.Rector.If_ uses Rector, so a change to Rector can break CodeQuality.Rector.If_, while a change to CodeQuality.Rector.If_ can't break Rector.

Position

Below the diagonal: CodeQuality.Rector.If_ uses a module listed above it, which is the healthy direction.

35→1 DeadCode.Rector.ClassMethod uses Configuration.Deprecation.Contract✕

Connections

2 pairs of types, where a type in DeadCode.Rector.ClassMethod uses a type in Configuration.Deprecation.Contract.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveDuplicatedReturnSelfDocblockRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface
• Rector.DeadCode.Rector.ClassMethod.RemoveParentDelegatingConstructorRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface

Direction

DeadCode.Rector.ClassMethod uses Configuration.Deprecation.Contract, so a change to Configuration.Deprecation.Contract can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break Configuration.Deprecation.Contract.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→7 DeadCode.Rector.ClassMethod uses RuleDoc✕

Connections

20 pairs of types, where a type in DeadCode.Rector.ClassMethod uses a type in RuleDoc.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveArgumentFromDefaultParentCallRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveDuplicatedReturnSelfDocblockRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveEmptyClassMethodRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveMixedDocblockOverruledByNativeTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveNullTagValueNodeRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveParentDelegatingClassMethodRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveParentDelegatingConstructorRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveReturnTagIncompatibleWithNativeTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveTestsOverriddenPrivateMethodParameterRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedConstructorParamRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPrivateMethodParameterRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPrivateMethodRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPromotedPropertyRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPublicMethodParameterRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessAssignFromPropertyPromotionRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessParamTagRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessReturnExprInConstructRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessReturnTagRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessUnionReturnDocblockRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.ClassMethod.RemoveVoidDocblockFromMagicMethodRector → Rector.RuleDoc.RuleDefinition

Direction

DeadCode.Rector.ClassMethod uses RuleDoc, so a change to RuleDoc can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break RuleDoc.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→8 DeadCode.Rector.ClassMethod uses StaticTypeMapper✕

Connections

3 pairs of types, where a type in DeadCode.Rector.ClassMethod uses a type in StaticTypeMapper.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveParentDelegatingClassMethodRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.DeadCode.Rector.ClassMethod.RemoveReturnTagIncompatibleWithNativeTypeRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessUnionReturnDocblockRector → Rector.StaticTypeMapper.StaticTypeMapper

Direction

DeadCode.Rector.ClassMethod uses StaticTypeMapper, so a change to StaticTypeMapper can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break StaticTypeMapper.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→9 DeadCode.Rector.ClassMethod uses VersionBonding.Contract✕

Connections

2 pairs of types, where a type in DeadCode.Rector.ClassMethod uses a type in VersionBonding.Contract.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPromotedPropertyRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessUnionReturnDocblockRector → Rector.VersionBonding.Contract.MinPhpVersionInterface

Direction

DeadCode.Rector.ClassMethod uses VersionBonding.Contract, so a change to VersionBonding.Contract can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break VersionBonding.Contract.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→10 DeadCode.Rector.ClassMethod uses BetterPhpDocParser.PhpDocInfo✕

Connections

13 pairs of types, where a type in DeadCode.Rector.ClassMethod uses a type in BetterPhpDocParser.PhpDocInfo.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveEmptyClassMethodRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.DeadCode.Rector.ClassMethod.RemoveMixedDocblockOverruledByNativeTypeRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.DeadCode.Rector.ClassMethod.RemoveMixedDocblockOverruledByNativeTypeRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.DeadCode.Rector.ClassMethod.RemoveNullTagValueNodeRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.DeadCode.Rector.ClassMethod.RemoveNullTagValueNodeRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.DeadCode.Rector.ClassMethod.RemoveParentDelegatingClassMethodRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.DeadCode.Rector.ClassMethod.RemoveReturnTagIncompatibleWithNativeTypeRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.DeadCode.Rector.ClassMethod.RemoveReturnTagIncompatibleWithNativeTypeRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPromotedPropertyRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessParamTagRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessReturnTagRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessUnionReturnDocblockRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.DeadCode.Rector.ClassMethod.RemoveVoidDocblockFromMagicMethodRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory

Direction

DeadCode.Rector.ClassMethod uses BetterPhpDocParser.PhpDocInfo, so a change to BetterPhpDocParser.PhpDocInfo can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break BetterPhpDocParser.PhpDocInfo.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→12 DeadCode.Rector.ClassMethod uses Comments.NodeDocBlock✕

Connections

7 pairs of types, where a type in DeadCode.Rector.ClassMethod uses a type in Comments.NodeDocBlock.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveMixedDocblockOverruledByNativeTypeRector → Rector.Comments.NodeDocBlock.DocBlockUpdater
• Rector.DeadCode.Rector.ClassMethod.RemoveNullTagValueNodeRector → Rector.Comments.NodeDocBlock.DocBlockUpdater
• Rector.DeadCode.Rector.ClassMethod.RemoveReturnTagIncompatibleWithNativeTypeRector → Rector.Comments.NodeDocBlock.DocBlockUpdater
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPromotedPropertyRector → Rector.Comments.NodeDocBlock.DocBlockUpdater
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessReturnTagRector → Rector.Comments.NodeDocBlock.DocBlockUpdater
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessUnionReturnDocblockRector → Rector.Comments.NodeDocBlock.DocBlockUpdater
• Rector.DeadCode.Rector.ClassMethod.RemoveVoidDocblockFromMagicMethodRector → Rector.Comments.NodeDocBlock.DocBlockUpdater

Direction

DeadCode.Rector.ClassMethod uses Comments.NodeDocBlock, so a change to Comments.NodeDocBlock can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break Comments.NodeDocBlock.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→14 DeadCode.Rector.ClassMethod uses PhpParser.Node✕

Connections

2 pairs of types, where a type in DeadCode.Rector.ClassMethod uses a type in PhpParser.Node.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPrivateMethodRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPromotedPropertyRector → Rector.PhpParser.Node.BetterNodeFinder

Direction

DeadCode.Rector.ClassMethod uses PhpParser.Node, so a change to PhpParser.Node can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break PhpParser.Node.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→15 DeadCode.Rector.ClassMethod uses Privatization.NodeManipulator✕

Connections

1 pair of types, where a type in DeadCode.Rector.ClassMethod uses a type in Privatization.NodeManipulator.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPromotedPropertyRector → Rector.Privatization.NodeManipulator.VisibilityManipulator

Direction

DeadCode.Rector.ClassMethod uses Privatization.NodeManipulator, so a change to Privatization.NodeManipulator can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break Privatization.NodeManipulator.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→16 DeadCode.Rector.ClassMethod uses BetterPhpDocParser.PhpDocManipulator✕

Connections

1 pair of types, where a type in DeadCode.Rector.ClassMethod uses a type in BetterPhpDocParser.PhpDocManipulator.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPromotedPropertyRector → Rector.BetterPhpDocParser.PhpDocManipulator.PhpDocTagRemover

Direction

DeadCode.Rector.ClassMethod uses BetterPhpDocParser.PhpDocManipulator, so a change to BetterPhpDocParser.PhpDocManipulator can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break BetterPhpDocParser.PhpDocManipulator.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→18 DeadCode.Rector.ClassMethod uses Reflection✕

Connections

4 pairs of types, where a type in DeadCode.Rector.ClassMethod uses a type in Reflection.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveArgumentFromDefaultParentCallRector → Rector.Reflection.ReflectionResolver
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedConstructorParamRector → Rector.Reflection.ReflectionResolver
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPrivateMethodRector → Rector.Reflection.ReflectionResolver
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPromotedPropertyRector → Rector.Reflection.ReflectionResolver

Direction

DeadCode.Rector.ClassMethod uses Reflection, so a change to Reflection can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break Reflection.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→20 DeadCode.Rector.ClassMethod uses DeadCode.PhpDoc.TagRemover✕

Connections

2 pairs of types, where a type in DeadCode.Rector.ClassMethod uses a type in DeadCode.PhpDoc.TagRemover.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveUselessParamTagRector → Rector.DeadCode.PhpDoc.TagRemover.ParamTagRemover
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessReturnTagRector → Rector.DeadCode.PhpDoc.TagRemover.ReturnTagRemover

Direction

DeadCode.Rector.ClassMethod uses DeadCode.PhpDoc.TagRemover, so a change to DeadCode.PhpDoc.TagRemover can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break DeadCode.PhpDoc.TagRemover.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→23 DeadCode.Rector.ClassMethod uses PhpParser.Node.Value✕

Connections

1 pair of types, where a type in DeadCode.Rector.ClassMethod uses a type in PhpParser.Node.Value.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveArgumentFromDefaultParentCallRector → Rector.PhpParser.Node.Value.ValueResolver

Direction

DeadCode.Rector.ClassMethod uses PhpParser.Node.Value, so a change to PhpParser.Node.Value can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break PhpParser.Node.Value.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→24 DeadCode.Rector.ClassMethod uses DeadCode.NodeAnalyzer✕

Connections

3 pairs of types, where a type in DeadCode.Rector.ClassMethod uses a type in DeadCode.NodeAnalyzer.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveEmptyClassMethodRector → Rector.DeadCode.NodeAnalyzer.IsClassMethodUsedAnalyzer
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPrivateMethodRector → Rector.DeadCode.NodeAnalyzer.IsClassMethodUsedAnalyzer
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPromotedPropertyRector → Rector.DeadCode.NodeAnalyzer.PropertyWriteonlyAnalyzer

Direction

DeadCode.Rector.ClassMethod uses DeadCode.NodeAnalyzer, so a change to DeadCode.NodeAnalyzer can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break DeadCode.NodeAnalyzer.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→25 DeadCode.Rector.ClassMethod uses Php80.NodeAnalyzer✕

Connections

1 pair of types, where a type in DeadCode.Rector.ClassMethod uses a type in Php80.NodeAnalyzer.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPublicMethodParameterRector → Rector.Php80.NodeAnalyzer.PhpAttributeAnalyzer

Direction

DeadCode.Rector.ClassMethod uses Php80.NodeAnalyzer, so a change to Php80.NodeAnalyzer can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break Php80.NodeAnalyzer.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→26 DeadCode.Rector.ClassMethod uses PhpParser.NodeFinder✕

Connections

1 pair of types, where a type in DeadCode.Rector.ClassMethod uses a type in PhpParser.NodeFinder.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPromotedPropertyRector → Rector.PhpParser.NodeFinder.PropertyFetchFinder

Direction

DeadCode.Rector.ClassMethod uses PhpParser.NodeFinder, so a change to PhpParser.NodeFinder can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break PhpParser.NodeFinder.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→29 DeadCode.Rector.ClassMethod uses NodeManipulator✕

Connections

1 pair of types, where a type in DeadCode.Rector.ClassMethod uses a type in NodeManipulator.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveEmptyClassMethodRector → Rector.NodeManipulator.ClassMethodManipulator

Direction

DeadCode.Rector.ClassMethod uses NodeManipulator, so a change to NodeManipulator can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break NodeManipulator.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→30 DeadCode.Rector.ClassMethod uses NodeAnalyzer✕

Connections

5 pairs of types, where a type in DeadCode.Rector.ClassMethod uses a type in NodeAnalyzer.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveArgumentFromDefaultParentCallRector → Rector.NodeAnalyzer.ArgsAnalyzer
• Rector.DeadCode.Rector.ClassMethod.RemoveArgumentFromDefaultParentCallRector → Rector.NodeAnalyzer.ExprAnalyzer
• Rector.DeadCode.Rector.ClassMethod.RemoveEmptyClassMethodRector → Rector.NodeAnalyzer.ParamAnalyzer
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPublicMethodParameterRector → Rector.NodeAnalyzer.MagicClassMethodAnalyzer
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessReturnExprInConstructRector → Rector.NodeAnalyzer.ExprAnalyzer

Direction

DeadCode.Rector.ClassMethod uses NodeAnalyzer, so a change to NodeAnalyzer can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break NodeAnalyzer.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

35→33 DeadCode.Rector.ClassMethod uses Rector✕

Connections

20 pairs of types, where a type in DeadCode.Rector.ClassMethod uses a type in Rector.

The types involved

• Rector.DeadCode.Rector.ClassMethod.RemoveArgumentFromDefaultParentCallRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveDuplicatedReturnSelfDocblockRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveEmptyClassMethodRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveMixedDocblockOverruledByNativeTypeRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveNullTagValueNodeRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveParentDelegatingClassMethodRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveParentDelegatingConstructorRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveReturnTagIncompatibleWithNativeTypeRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveTestsOverriddenPrivateMethodParameterRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedConstructorParamRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPrivateMethodParameterRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPrivateMethodRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPromotedPropertyRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveUnusedPublicMethodParameterRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessAssignFromPropertyPromotionRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessParamTagRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessReturnExprInConstructRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessReturnTagRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveUselessUnionReturnDocblockRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.ClassMethod.RemoveVoidDocblockFromMagicMethodRector → Rector.Rector.AbstractRector

Direction

DeadCode.Rector.ClassMethod uses Rector, so a change to Rector can break DeadCode.Rector.ClassMethod, while a change to DeadCode.Rector.ClassMethod can't break Rector.

Position

Below the diagonal: DeadCode.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

36→5 DeadCode.Rector.If_ uses Php✕

Connections

2 pairs of types, where a type in DeadCode.Rector.If_ uses a type in Php.

The types involved

• Rector.DeadCode.Rector.If_.RemoveOverriddenAssignBeforeIfElseRector → Rector.Php.ReservedKeywordAnalyzer
• Rector.DeadCode.Rector.If_.RemoveUnusedNonEmptyArrayBeforeForeachRector → Rector.Php.ReservedKeywordAnalyzer

Direction

DeadCode.Rector.If_ uses Php, so a change to Php can break DeadCode.Rector.If_, while a change to DeadCode.Rector.If_ can't break Php.

Position

Below the diagonal: DeadCode.Rector.If_ uses a module listed above it, which is the healthy direction.

36→7 DeadCode.Rector.If_ uses RuleDoc✕

Connections

9 pairs of types, where a type in DeadCode.Rector.If_ uses a type in RuleDoc.

The types involved

• Rector.DeadCode.Rector.If_.ReduceAlwaysFalseIfOrRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.If_.RemoveAlwaysTrueIfConditionRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.If_.RemoveDeadIfBlockRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.If_.RemoveDeadInstanceOfRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.If_.RemoveOverriddenAssignBeforeIfElseRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.If_.RemoveTypedPropertyDeadInstanceOfRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.If_.RemoveUnusedNonEmptyArrayBeforeForeachRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.If_.SimplifyIfElseWithSameContentRector → Rector.RuleDoc.RuleDefinition
• Rector.DeadCode.Rector.If_.UnwrapFutureCompatibleIfPhpVersionRector → Rector.RuleDoc.RuleDefinition

Direction

DeadCode.Rector.If_ uses RuleDoc, so a change to RuleDoc can break DeadCode.Rector.If_, while a change to DeadCode.Rector.If_ can't break RuleDoc.

Position

Below the diagonal: DeadCode.Rector.If_ uses a module listed above it, which is the healthy direction.

36→14 DeadCode.Rector.If_ uses PhpParser.Node✕

Connections

2 pairs of types, where a type in DeadCode.Rector.If_ uses a type in PhpParser.Node.

The types involved

• Rector.DeadCode.Rector.If_.RemoveAlwaysTrueIfConditionRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.DeadCode.Rector.If_.RemoveOverriddenAssignBeforeIfElseRector → Rector.PhpParser.Node.BetterNodeFinder

Direction

DeadCode.Rector.If_ uses PhpParser.Node, so a change to PhpParser.Node can break DeadCode.Rector.If_, while a change to DeadCode.Rector.If_ can't break PhpParser.Node.

Position

Below the diagonal: DeadCode.Rector.If_ uses a module listed above it, which is the healthy direction.

36→17 DeadCode.Rector.If_ uses PhpParser.Printer✕

Connections

1 pair of types, where a type in DeadCode.Rector.If_ uses a type in PhpParser.Printer.

The types involved

• Rector.DeadCode.Rector.If_.SimplifyIfElseWithSameContentRector → Rector.PhpParser.Printer.BetterStandardPrinter

Direction

DeadCode.Rector.If_ uses PhpParser.Printer, so a change to PhpParser.Printer can break DeadCode.Rector.If_, while a change to DeadCode.Rector.If_ can't break PhpParser.Printer.

Position

Below the diagonal: DeadCode.Rector.If_ uses a module listed above it, which is the healthy direction.

36→18 DeadCode.Rector.If_ uses Reflection✕

Connections

1 pair of types, where a type in DeadCode.Rector.If_ uses a type in Reflection.

The types involved

• Rector.DeadCode.Rector.If_.RemoveDeadInstanceOfRector → Rector.Reflection.ReflectionResolver

Direction

DeadCode.Rector.If_ uses Reflection, so a change to Reflection can break DeadCode.Rector.If_, while a change to DeadCode.Rector.If_ can't break Reflection.

Position

Below the diagonal: DeadCode.Rector.If_ uses a module listed above it, which is the healthy direction.

36→24 DeadCode.Rector.If_ uses DeadCode.NodeAnalyzer✕

Connections

2 pairs of types, where a type in DeadCode.Rector.If_ uses a type in DeadCode.NodeAnalyzer.

The types involved

• Rector.DeadCode.Rector.If_.ReduceAlwaysFalseIfOrRector → Rector.DeadCode.NodeAnalyzer.SafeLeftTypeBooleanAndOrAnalyzer
• Rector.DeadCode.Rector.If_.RemoveAlwaysTrueIfConditionRector → Rector.DeadCode.NodeAnalyzer.SafeLeftTypeBooleanAndOrAnalyzer

Direction

DeadCode.Rector.If_ uses DeadCode.NodeAnalyzer, so a change to DeadCode.NodeAnalyzer can break DeadCode.Rector.If_, while a change to DeadCode.Rector.If_ can't break DeadCode.NodeAnalyzer.

Position

Below the diagonal: DeadCode.Rector.If_ uses a module listed above it, which is the healthy direction.

36→25 DeadCode.Rector.If_ uses Php80.NodeAnalyzer✕

Connections

1 pair of types, where a type in DeadCode.Rector.If_ uses a type in Php80.NodeAnalyzer.

The types involved

• Rector.DeadCode.Rector.If_.RemoveTypedPropertyDeadInstanceOfRector → Rector.Php80.NodeAnalyzer.PromotedPropertyResolver

Direction

DeadCode.Rector.If_ uses Php80.NodeAnalyzer, so a change to Php80.NodeAnalyzer can break DeadCode.Rector.If_, while a change to DeadCode.Rector.If_ can't break Php80.NodeAnalyzer.

Position

Below the diagonal: DeadCode.Rector.If_ uses a module listed above it, which is the healthy direction.

36→29 DeadCode.Rector.If_ uses NodeManipulator✕

Connections

3 pairs of types, where a type in DeadCode.Rector.If_ uses a type in NodeManipulator.

The types involved

• Rector.DeadCode.Rector.If_.RemoveDeadInstanceOfRector → Rector.NodeManipulator.IfManipulator
• Rector.DeadCode.Rector.If_.RemoveTypedPropertyDeadInstanceOfRector → Rector.NodeManipulator.IfManipulator
• Rector.DeadCode.Rector.If_.RemoveUnusedNonEmptyArrayBeforeForeachRector → Rector.NodeManipulator.IfManipulator

Direction

DeadCode.Rector.If_ uses NodeManipulator, so a change to NodeManipulator can break DeadCode.Rector.If_, while a change to DeadCode.Rector.If_ can't break NodeManipulator.

Position

Below the diagonal: DeadCode.Rector.If_ uses a module listed above it, which is the healthy direction.

36→30 DeadCode.Rector.If_ uses NodeAnalyzer✕

Connections

3 pairs of types, where a type in DeadCode.Rector.If_ uses a type in NodeAnalyzer.

The types involved

• Rector.DeadCode.Rector.If_.RemoveAlwaysTrueIfConditionRector → Rector.NodeAnalyzer.ExprAnalyzer
• Rector.DeadCode.Rector.If_.RemoveOverriddenAssignBeforeIfElseRector → Rector.NodeAnalyzer.VariableAnalyzer
• Rector.DeadCode.Rector.If_.RemoveUnusedNonEmptyArrayBeforeForeachRector → Rector.NodeAnalyzer.PropertyFetchAnalyzer

Direction

DeadCode.Rector.If_ uses NodeAnalyzer, so a change to NodeAnalyzer can break DeadCode.Rector.If_, while a change to DeadCode.Rector.If_ can't break NodeAnalyzer.

Position

Below the diagonal: DeadCode.Rector.If_ uses a module listed above it, which is the healthy direction.

36→33 DeadCode.Rector.If_ uses Rector✕

Connections

9 pairs of types, where a type in DeadCode.Rector.If_ uses a type in Rector.

The types involved

• Rector.DeadCode.Rector.If_.ReduceAlwaysFalseIfOrRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.If_.RemoveAlwaysTrueIfConditionRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.If_.RemoveDeadIfBlockRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.If_.RemoveDeadInstanceOfRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.If_.RemoveOverriddenAssignBeforeIfElseRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.If_.RemoveTypedPropertyDeadInstanceOfRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.If_.RemoveUnusedNonEmptyArrayBeforeForeachRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.If_.SimplifyIfElseWithSameContentRector → Rector.Rector.AbstractRector
• Rector.DeadCode.Rector.If_.UnwrapFutureCompatibleIfPhpVersionRector → Rector.Rector.AbstractRector

Direction

DeadCode.Rector.If_ uses Rector, so a change to Rector can break DeadCode.Rector.If_, while a change to DeadCode.Rector.If_ can't break Rector.

Position

Below the diagonal: DeadCode.Rector.If_ uses a module listed above it, which is the healthy direction.

37→2 Php80.Rector.Class_ uses Contract.Rector✕

Connections

2 pairs of types, where a type in Php80.Rector.Class_ uses a type in Contract.Rector.

The types involved

• Rector.Php80.Rector.Class_.AnnotationToAttributeRector → Rector.Contract.Rector.ConfigurableRectorInterface
• Rector.Php80.Rector.Class_.ClassPropertyAssignToConstructorPromotionRector → Rector.Contract.Rector.ConfigurableRectorInterface

Direction

Php80.Rector.Class_ uses Contract.Rector, so a change to Contract.Rector can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break Contract.Rector.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→7 Php80.Rector.Class_ uses RuleDoc✕

Connections

3 pairs of types, where a type in Php80.Rector.Class_ uses a type in RuleDoc.

The types involved

• Rector.Php80.Rector.Class_.AnnotationToAttributeRector → Rector.RuleDoc.RuleDefinition
• Rector.Php80.Rector.Class_.ClassPropertyAssignToConstructorPromotionRector → Rector.RuleDoc.RuleDefinition
• Rector.Php80.Rector.Class_.StringableForToStringRector → Rector.RuleDoc.RuleDefinition

Direction

Php80.Rector.Class_ uses RuleDoc, so a change to RuleDoc can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break RuleDoc.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→8 Php80.Rector.Class_ uses StaticTypeMapper✕

Connections

1 pair of types, where a type in Php80.Rector.Class_ uses a type in StaticTypeMapper.

The types involved

• Rector.Php80.Rector.Class_.ClassPropertyAssignToConstructorPromotionRector → Rector.StaticTypeMapper.StaticTypeMapper

Direction

Php80.Rector.Class_ uses StaticTypeMapper, so a change to StaticTypeMapper can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break StaticTypeMapper.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→9 Php80.Rector.Class_ uses VersionBonding.Contract✕

Connections

3 pairs of types, where a type in Php80.Rector.Class_ uses a type in VersionBonding.Contract.

The types involved

• Rector.Php80.Rector.Class_.AnnotationToAttributeRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.Php80.Rector.Class_.ClassPropertyAssignToConstructorPromotionRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.Php80.Rector.Class_.StringableForToStringRector → Rector.VersionBonding.Contract.MinPhpVersionInterface

Direction

Php80.Rector.Class_ uses VersionBonding.Contract, so a change to VersionBonding.Contract can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break VersionBonding.Contract.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→10 Php80.Rector.Class_ uses BetterPhpDocParser.PhpDocInfo✕

Connections

4 pairs of types, where a type in Php80.Rector.Class_ uses a type in BetterPhpDocParser.PhpDocInfo.

The types involved

• Rector.Php80.Rector.Class_.AnnotationToAttributeRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.Php80.Rector.Class_.AnnotationToAttributeRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.Php80.Rector.Class_.ClassPropertyAssignToConstructorPromotionRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.Php80.Rector.Class_.ClassPropertyAssignToConstructorPromotionRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory

Direction

Php80.Rector.Class_ uses BetterPhpDocParser.PhpDocInfo, so a change to BetterPhpDocParser.PhpDocInfo can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break BetterPhpDocParser.PhpDocInfo.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→12 Php80.Rector.Class_ uses Comments.NodeDocBlock✕

Connections

1 pair of types, where a type in Php80.Rector.Class_ uses a type in Comments.NodeDocBlock.

The types involved

• Rector.Php80.Rector.Class_.AnnotationToAttributeRector → Rector.Comments.NodeDocBlock.DocBlockUpdater

Direction

Php80.Rector.Class_ uses Comments.NodeDocBlock, so a change to Comments.NodeDocBlock can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break Comments.NodeDocBlock.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→14 Php80.Rector.Class_ uses PhpParser.Node✕

Connections

1 pair of types, where a type in Php80.Rector.Class_ uses a type in PhpParser.Node.

The types involved

• Rector.Php80.Rector.Class_.ClassPropertyAssignToConstructorPromotionRector → Rector.PhpParser.Node.BetterNodeFinder

Direction

Php80.Rector.Class_ uses PhpParser.Node, so a change to PhpParser.Node can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break PhpParser.Node.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→16 Php80.Rector.Class_ uses BetterPhpDocParser.PhpDocManipulator✕

Connections

1 pair of types, where a type in Php80.Rector.Class_ uses a type in BetterPhpDocParser.PhpDocManipulator.

The types involved

• Rector.Php80.Rector.Class_.AnnotationToAttributeRector → Rector.BetterPhpDocParser.PhpDocManipulator.PhpDocTagRemover

Direction

Php80.Rector.Class_ uses BetterPhpDocParser.PhpDocManipulator, so a change to BetterPhpDocParser.PhpDocManipulator can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break BetterPhpDocParser.PhpDocManipulator.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→18 Php80.Rector.Class_ uses Reflection✕

Connections

1 pair of types, where a type in Php80.Rector.Class_ uses a type in Reflection.

The types involved

• Rector.Php80.Rector.Class_.ClassPropertyAssignToConstructorPromotionRector → Rector.Reflection.ReflectionResolver

Direction

Php80.Rector.Class_ uses Reflection, so a change to Reflection can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break Reflection.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→23 Php80.Rector.Class_ uses PhpParser.Node.Value✕

Connections

1 pair of types, where a type in Php80.Rector.Class_ uses a type in PhpParser.Node.Value.

The types involved

• Rector.Php80.Rector.Class_.ClassPropertyAssignToConstructorPromotionRector → Rector.PhpParser.Node.Value.ValueResolver

Direction

Php80.Rector.Class_ uses PhpParser.Node.Value, so a change to PhpParser.Node.Value can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break PhpParser.Node.Value.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→25 Php80.Rector.Class_ uses Php80.NodeAnalyzer✕

Connections

2 pairs of types, where a type in Php80.Rector.Class_ uses a type in Php80.NodeAnalyzer.

The types involved

• Rector.Php80.Rector.Class_.AnnotationToAttributeRector → Rector.Php80.NodeAnalyzer.PhpAttributeAnalyzer
• Rector.Php80.Rector.Class_.ClassPropertyAssignToConstructorPromotionRector → Rector.Php80.NodeAnalyzer.PromotedPropertyCandidateResolver

Direction

Php80.Rector.Class_ uses Php80.NodeAnalyzer, so a change to Php80.NodeAnalyzer can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break Php80.NodeAnalyzer.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→27 Php80.Rector.Class_ uses TypeDeclaration.TypeInferer✕

Connections

2 pairs of types, where a type in Php80.Rector.Class_ uses a type in TypeDeclaration.TypeInferer.

The types involved

• Rector.Php80.Rector.Class_.StringableForToStringRector → Rector.TypeDeclaration.TypeInferer.ReturnTypeInferer
• Rector.Php80.Rector.Class_.StringableForToStringRector → Rector.TypeDeclaration.TypeInferer.SilentVoidResolver

Direction

Php80.Rector.Class_ uses TypeDeclaration.TypeInferer, so a change to TypeDeclaration.TypeInferer can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break TypeDeclaration.TypeInferer.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→30 Php80.Rector.Class_ uses NodeAnalyzer✕

Connections

2 pairs of types, where a type in Php80.Rector.Class_ uses a type in NodeAnalyzer.

The types involved

• Rector.Php80.Rector.Class_.ClassPropertyAssignToConstructorPromotionRector → Rector.NodeAnalyzer.ParamAnalyzer
• Rector.Php80.Rector.Class_.StringableForToStringRector → Rector.NodeAnalyzer.ClassAnalyzer

Direction

Php80.Rector.Class_ uses NodeAnalyzer, so a change to NodeAnalyzer can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break NodeAnalyzer.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

37→33 Php80.Rector.Class_ uses Rector✕

Connections

3 pairs of types, where a type in Php80.Rector.Class_ uses a type in Rector.

The types involved

• Rector.Php80.Rector.Class_.AnnotationToAttributeRector → Rector.Rector.AbstractRector
• Rector.Php80.Rector.Class_.ClassPropertyAssignToConstructorPromotionRector → Rector.Rector.AbstractRector
• Rector.Php80.Rector.Class_.StringableForToStringRector → Rector.Rector.AbstractRector

Direction

Php80.Rector.Class_ uses Rector, so a change to Rector can break Php80.Rector.Class_, while a change to Php80.Rector.Class_ can't break Rector.

Position

Below the diagonal: Php80.Rector.Class_ uses a module listed above it, which is the healthy direction.

38→1 TypeDeclaration.Rector.ClassMethod uses Configuration.Deprecation.Contract✕

Connections

8 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in Configuration.Deprecation.Contract.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddParamStringTypeFromSprintfUseRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnArrayDocblockBasedOnArrayMapRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ArrayParamTypeByMethodCallTypeRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ObjectParamTypeByMethodCallTypeRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ParamTypeByMethodCallTypeRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ParamTypeByParentCallTypeRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ScalarParamTypeByMethodCallTypeRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface
• Rector.TypeDeclaration.Rector.ClassMethod.StrictStringParamConcatRector → Rector.Configuration.Deprecation.Contract.DeprecatedInterface

Direction

TypeDeclaration.Rector.ClassMethod uses Configuration.Deprecation.Contract, so a change to Configuration.Deprecation.Contract can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break Configuration.Deprecation.Contract.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→2 TypeDeclaration.Rector.ClassMethod uses Contract.Rector✕

Connections

2 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in Contract.Rector.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeDeclarationRector → Rector.Contract.Rector.ConfigurableRectorInterface
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeDeclarationRector → Rector.Contract.Rector.ConfigurableRectorInterface

Direction

TypeDeclaration.Rector.ClassMethod uses Contract.Rector, so a change to Contract.Rector can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break Contract.Rector.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→4 TypeDeclaration.Rector.ClassMethod uses NodeTypeResolver.PHPStan.Type✕

Connections

5 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in NodeTypeResolver.PHPStan.Type.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeFromPropertyTypeRector → Rector.NodeTypeResolver.PHPStan.Type.TypeFactory
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromReturnNewRector → Rector.NodeTypeResolver.PHPStan.Type.TypeFactory
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictConstantReturnRector → Rector.NodeTypeResolver.PHPStan.Type.TypeFactory
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedPropertyRector → Rector.NodeTypeResolver.PHPStan.Type.TypeFactory
• Rector.TypeDeclaration.Rector.ClassMethod.StrictArrayParamDimFetchRector → Rector.NodeTypeResolver.PHPStan.Type.TypeFactory

Direction

TypeDeclaration.Rector.ClassMethod uses NodeTypeResolver.PHPStan.Type, so a change to NodeTypeResolver.PHPStan.Type can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break NodeTypeResolver.PHPStan.Type.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→5 TypeDeclaration.Rector.ClassMethod uses Php✕

Connections

6 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in Php.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeDeclarationRector → Rector.Php.PhpVersionProvider
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeDeclarationBasedOnParentClassMethodRector → Rector.Php.PhpVersionProvider
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeDeclarationRector → Rector.Php.PhpVersionProvider
• Rector.TypeDeclaration.Rector.ClassMethod.KnownMagicClassMethodTypeRector → Rector.Php.PhpVersionProvider
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictFluentReturnRector → Rector.Php.PhpVersionProvider
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedCallRector → Rector.Php.PhpVersionProvider

Direction

TypeDeclaration.Rector.ClassMethod uses Php, so a change to Php can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break Php.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→6 TypeDeclaration.Rector.ClassMethod uses PhpDocParser.NodeTraverser✕

Connections

1 pair of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in PhpDocParser.NodeTraverser.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeFromPropertyTypeRector → Rector.PhpDocParser.NodeTraverser.SimpleCallableNodeTraverser

Direction

TypeDeclaration.Rector.ClassMethod uses PhpDocParser.NodeTraverser, so a change to PhpDocParser.NodeTraverser can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break PhpDocParser.NodeTraverser.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→7 TypeDeclaration.Rector.ClassMethod uses RuleDoc✕

Connections

47 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in RuleDoc. Showing 25 of them; the rest are in namespace-graph.json in this report's bundle.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddMethodCallBasedStrictParamTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamArrayDocblockBasedOnCallableNativeFuncCallRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamFromDimFetchKeyUseRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamStringTypeFromSprintfUseRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeBasedOnPHPUnitDataProviderRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeDeclarationRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeFromPropertyTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnArrayDocblockBasedOnArrayMapRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnDocblockForScalarArrayFromAssignsRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeDeclarationBasedOnParentClassMethodRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeDeclarationRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeFromTryCatchTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.AddVoidReturnTypeWhereNoReturnRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.ArrayParamTypeByMethodCallTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstAndStrictReturnsRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstReturnsRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanStrictReturnsRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.KnownMagicClassMethodTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.NarrowBoolDocblockReturnTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.NarrowObjectReturnTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.NumericReturnTypeFromStrictReturnsRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.NumericReturnTypeFromStrictScalarReturnsRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.ObjectParamTypeByMethodCallTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.ParamTypeByMethodCallTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.ClassMethod.ParamTypeByParentCallTypeRector → Rector.RuleDoc.RuleDefinition

Direction

TypeDeclaration.Rector.ClassMethod uses RuleDoc, so a change to RuleDoc can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break RuleDoc.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→8 TypeDeclaration.Rector.ClassMethod uses StaticTypeMapper✕

Connections

14 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in StaticTypeMapper.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddParamArrayDocblockBasedOnCallableNativeFuncCallRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamFromDimFetchKeyUseRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeBasedOnPHPUnitDataProviderRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeDeclarationRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeFromPropertyTypeRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeDeclarationBasedOnParentClassMethodRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeDeclarationRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeFromTryCatchTypeRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.NarrowObjectReturnTypeRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromGetRepositoryDocblockRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromReturnNewRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictConstantReturnRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedCallRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedPropertyRector → Rector.StaticTypeMapper.StaticTypeMapper

Direction

TypeDeclaration.Rector.ClassMethod uses StaticTypeMapper, so a change to StaticTypeMapper can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break StaticTypeMapper.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→9 TypeDeclaration.Rector.ClassMethod uses VersionBonding.Contract✕

Connections

28 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in VersionBonding.Contract. Showing 25 of them; the rest are in namespace-graph.json in this report's bundle.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeFromPropertyTypeRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeDeclarationBasedOnParentClassMethodRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.AddVoidReturnTypeWhereNoReturnRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstAndStrictReturnsRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstReturnsRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanStrictReturnsRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.KnownMagicClassMethodTypeRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.NumericReturnTypeFromStrictReturnsRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.NumericReturnTypeFromStrictScalarReturnsRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.PrivateMethodReturnTypeFromStrictNewArrayRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnNeverTypeRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnNullableTypeRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromMockObjectRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromReturnCastRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromReturnDirectArrayRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromReturnNewRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictConstantReturnRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictFluentReturnRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictNativeCallRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictNewArrayRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictParamRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedCallRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedPropertyRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromSymfonySerializerRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnUnionTypeRector → Rector.VersionBonding.Contract.MinPhpVersionInterface

Direction

TypeDeclaration.Rector.ClassMethod uses VersionBonding.Contract, so a change to VersionBonding.Contract can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break VersionBonding.Contract.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→10 TypeDeclaration.Rector.ClassMethod uses BetterPhpDocParser.PhpDocInfo✕

Connections

7 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in BetterPhpDocParser.PhpDocInfo.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddParamArrayDocblockBasedOnCallableNativeFuncCallRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamArrayDocblockBasedOnCallableNativeFuncCallRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnDocblockForScalarArrayFromAssignsRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.TypeDeclaration.Rector.ClassMethod.NarrowBoolDocblockReturnTypeRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.TypeDeclaration.Rector.ClassMethod.NarrowObjectReturnTypeRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromGetRepositoryDocblockRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromGetRepositoryDocblockRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory

Direction

TypeDeclaration.Rector.ClassMethod uses BetterPhpDocParser.PhpDocInfo, so a change to BetterPhpDocParser.PhpDocInfo can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break BetterPhpDocParser.PhpDocInfo.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→12 TypeDeclaration.Rector.ClassMethod uses Comments.NodeDocBlock✕

Connections

3 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in Comments.NodeDocBlock.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.NarrowBoolDocblockReturnTypeRector → Rector.Comments.NodeDocBlock.DocBlockUpdater
• Rector.TypeDeclaration.Rector.ClassMethod.NarrowObjectReturnTypeRector → Rector.Comments.NodeDocBlock.DocBlockUpdater
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromGetRepositoryDocblockRector → Rector.Comments.NodeDocBlock.DocBlockUpdater

Direction

TypeDeclaration.Rector.ClassMethod uses Comments.NodeDocBlock, so a change to Comments.NodeDocBlock can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break Comments.NodeDocBlock.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→14 TypeDeclaration.Rector.ClassMethod uses PhpParser.Node✕

Connections

17 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in PhpParser.Node.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnDocblockForScalarArrayFromAssignsRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeFromTryCatchTypeRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstAndStrictReturnsRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstReturnsRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanStrictReturnsRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.NarrowObjectReturnTypeRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.NumericReturnTypeFromStrictReturnsRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.NumericReturnTypeFromStrictScalarReturnsRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromGetRepositoryDocblockRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromMockObjectRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromReturnNewRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictConstantReturnRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedCallRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedPropertyRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.StrictArrayParamDimFetchRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.StringReturnTypeFromStrictScalarReturnsRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.ClassMethod.StringReturnTypeFromStrictStringReturnsRector → Rector.PhpParser.Node.BetterNodeFinder

Direction

TypeDeclaration.Rector.ClassMethod uses PhpParser.Node, so a change to PhpParser.Node can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break PhpParser.Node.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→16 TypeDeclaration.Rector.ClassMethod uses BetterPhpDocParser.PhpDocManipulator✕

Connections

2 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in BetterPhpDocParser.PhpDocManipulator.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddParamArrayDocblockBasedOnCallableNativeFuncCallRector → Rector.BetterPhpDocParser.PhpDocManipulator.PhpDocTypeChanger
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnDocblockForScalarArrayFromAssignsRector → Rector.BetterPhpDocParser.PhpDocManipulator.PhpDocTypeChanger

Direction

TypeDeclaration.Rector.ClassMethod uses BetterPhpDocParser.PhpDocManipulator, so a change to BetterPhpDocParser.PhpDocManipulator can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break BetterPhpDocParser.PhpDocManipulator.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→18 TypeDeclaration.Rector.ClassMethod uses Reflection✕

Connections

6 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in Reflection.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeDeclarationRector → Rector.Reflection.ReflectionResolver
• Rector.TypeDeclaration.Rector.ClassMethod.AddVoidReturnTypeWhereNoReturnRector → Rector.Reflection.ClassModifierChecker
• Rector.TypeDeclaration.Rector.ClassMethod.NarrowObjectReturnTypeRector → Rector.Reflection.ReflectionResolver
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromReturnNewRector → Rector.Reflection.ReflectionResolver
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictFluentReturnRector → Rector.Reflection.ReflectionResolver
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedPropertyRector → Rector.Reflection.ReflectionResolver

Direction

TypeDeclaration.Rector.ClassMethod uses Reflection, so a change to Reflection can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break Reflection.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→23 TypeDeclaration.Rector.ClassMethod uses PhpParser.Node.Value✕

Connections

4 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in PhpParser.Node.Value.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstAndStrictReturnsRector → Rector.PhpParser.Node.Value.ValueResolver
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstReturnsRector → Rector.PhpParser.Node.Value.ValueResolver
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanStrictReturnsRector → Rector.PhpParser.Node.Value.ValueResolver
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromSymfonySerializerRector → Rector.PhpParser.Node.Value.ValueResolver

Direction

TypeDeclaration.Rector.ClassMethod uses PhpParser.Node.Value, so a change to PhpParser.Node.Value can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break PhpParser.Node.Value.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→26 TypeDeclaration.Rector.ClassMethod uses PhpParser.NodeFinder✕

Connections

1 pair of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in PhpParser.NodeFinder.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddMethodCallBasedStrictParamTypeRector → Rector.PhpParser.NodeFinder.LocalMethodCallFinder

Direction

TypeDeclaration.Rector.ClassMethod uses PhpParser.NodeFinder, so a change to PhpParser.NodeFinder can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break PhpParser.NodeFinder.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→27 TypeDeclaration.Rector.ClassMethod uses TypeDeclaration.TypeInferer✕

Connections

5 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in TypeDeclaration.TypeInferer.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddVoidReturnTypeWhereNoReturnRector → Rector.TypeDeclaration.TypeInferer.SilentVoidResolver
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnNullableTypeRector → Rector.TypeDeclaration.TypeInferer.ReturnTypeInferer
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromReturnDirectArrayRector → Rector.TypeDeclaration.TypeInferer.ReturnTypeInferer
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictFluentReturnRector → Rector.TypeDeclaration.TypeInferer.ReturnTypeInferer
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedCallRector → Rector.TypeDeclaration.TypeInferer.ReturnTypeInferer

Direction

TypeDeclaration.Rector.ClassMethod uses TypeDeclaration.TypeInferer, so a change to TypeDeclaration.TypeInferer can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break TypeDeclaration.TypeInferer.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→28 TypeDeclaration.Rector.ClassMethod uses TypeDeclaration.NodeAnalyzer✕

Connections

19 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in TypeDeclaration.NodeAnalyzer.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddMethodCallBasedStrictParamTypeRector → Rector.TypeDeclaration.NodeAnalyzer.CallTypesResolver
• Rector.TypeDeclaration.Rector.ClassMethod.AddMethodCallBasedStrictParamTypeRector → Rector.TypeDeclaration.NodeAnalyzer.ClassMethodParamTypeCompleter
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnDocblockForScalarArrayFromAssignsRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeFromTryCatchTypeRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstAndStrictReturnsRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstReturnsRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanStrictReturnsRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.NumericReturnTypeFromStrictReturnsRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.NumericReturnTypeFromStrictScalarReturnsRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.PrivateMethodReturnTypeFromStrictNewArrayRector → Rector.TypeDeclaration.NodeAnalyzer.StrictReturnNewArrayResolver
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromMockObjectRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromReturnNewRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictConstantReturnRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictNewArrayRector → Rector.TypeDeclaration.NodeAnalyzer.StrictReturnNewArrayResolver
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedCallRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedCallRector → Rector.TypeDeclaration.NodeAnalyzer.TypeNodeUnwrapper
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromStrictTypedPropertyRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.StringReturnTypeFromStrictScalarReturnsRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.StringReturnTypeFromStrictStringReturnsRector → Rector.TypeDeclaration.NodeAnalyzer.ReturnAnalyzer

Direction

TypeDeclaration.Rector.ClassMethod uses TypeDeclaration.NodeAnalyzer, so a change to TypeDeclaration.NodeAnalyzer can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break TypeDeclaration.NodeAnalyzer.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→30 TypeDeclaration.Rector.ClassMethod uses NodeAnalyzer✕

Connections

5 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in NodeAnalyzer.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeFromPropertyTypeRector → Rector.NodeAnalyzer.PropertyFetchAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstAndStrictReturnsRector → Rector.NodeAnalyzer.ExprAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanStrictReturnsRector → Rector.NodeAnalyzer.ExprAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromReturnNewRector → Rector.NodeAnalyzer.ClassAnalyzer
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnTypeFromSymfonySerializerRector → Rector.NodeAnalyzer.ArgsAnalyzer

Direction

TypeDeclaration.Rector.ClassMethod uses NodeAnalyzer, so a change to NodeAnalyzer can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break NodeAnalyzer.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

38→33 TypeDeclaration.Rector.ClassMethod uses Rector✕

Connections

44 pairs of types, where a type in TypeDeclaration.Rector.ClassMethod uses a type in Rector. Showing 25 of them; the rest are in namespace-graph.json in this report's bundle.

The types involved

• Rector.TypeDeclaration.Rector.ClassMethod.AbstractParamTypeByMethodCallTypeRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddMethodCallBasedStrictParamTypeRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamArrayDocblockBasedOnCallableNativeFuncCallRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamFromDimFetchKeyUseRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamStringTypeFromSprintfUseRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeBasedOnPHPUnitDataProviderRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeDeclarationRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddParamTypeFromPropertyTypeRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnArrayDocblockBasedOnArrayMapRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnDocblockForScalarArrayFromAssignsRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeDeclarationBasedOnParentClassMethodRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeDeclarationRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddReturnTypeFromTryCatchTypeRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.AddVoidReturnTypeWhereNoReturnRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstAndStrictReturnsRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanConstReturnsRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.BoolReturnTypeFromBooleanStrictReturnsRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.KnownMagicClassMethodTypeRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.NarrowBoolDocblockReturnTypeRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.NarrowObjectReturnTypeRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.NumericReturnTypeFromStrictReturnsRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.NumericReturnTypeFromStrictScalarReturnsRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.ParamTypeByParentCallTypeRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.PrivateMethodReturnTypeFromStrictNewArrayRector → Rector.Rector.AbstractRector
• Rector.TypeDeclaration.Rector.ClassMethod.ReturnNeverTypeRector → Rector.Rector.AbstractRector

Direction

TypeDeclaration.Rector.ClassMethod uses Rector, so a change to Rector can break TypeDeclaration.Rector.ClassMethod, while a change to TypeDeclaration.Rector.ClassMethod can't break Rector.

Position

Below the diagonal: TypeDeclaration.Rector.ClassMethod uses a module listed above it, which is the healthy direction.

39→7 TypeDeclaration.Rector.Class_ uses RuleDoc✕

Connections

12 pairs of types, where a type in TypeDeclaration.Rector.Class_ uses a type in RuleDoc.

The types involved

• Rector.TypeDeclaration.Rector.Class_.AddTestsVoidReturnTypeWhereNoReturnRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.Class_.ChildDoctrineRepositoryClassTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.Class_.MergeDateTimePropertyTypeDeclarationRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.Class_.ObjectTypedPropertyFromJMSSerializerAttributeTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.Class_.PropertyTypeFromStrictSetterGetterRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.Class_.ReturnTypeFromStrictTernaryRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.Class_.ScalarTypedPropertyFromJMSSerializerAttributeTypeRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromContainerGetSetUpRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromCreateMockAssignRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromDocblockSetUpDefinedRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromGetRepositorySetUpRector → Rector.RuleDoc.RuleDefinition
• Rector.TypeDeclaration.Rector.Class_.TypedStaticPropertyInBehatContextRector → Rector.RuleDoc.RuleDefinition

Direction

TypeDeclaration.Rector.Class_ uses RuleDoc, so a change to RuleDoc can break TypeDeclaration.Rector.Class_, while a change to TypeDeclaration.Rector.Class_ can't break RuleDoc.

Position

Below the diagonal: TypeDeclaration.Rector.Class_ uses a module listed above it, which is the healthy direction.

39→8 TypeDeclaration.Rector.Class_ uses StaticTypeMapper✕

Connections

4 pairs of types, where a type in TypeDeclaration.Rector.Class_ uses a type in StaticTypeMapper.

The types involved

• Rector.TypeDeclaration.Rector.Class_.PropertyTypeFromStrictSetterGetterRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.Class_.ReturnTypeFromStrictTernaryRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromCreateMockAssignRector → Rector.StaticTypeMapper.StaticTypeMapper
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromDocblockSetUpDefinedRector → Rector.StaticTypeMapper.StaticTypeMapper

Direction

TypeDeclaration.Rector.Class_ uses StaticTypeMapper, so a change to StaticTypeMapper can break TypeDeclaration.Rector.Class_, while a change to TypeDeclaration.Rector.Class_ can't break StaticTypeMapper.

Position

Below the diagonal: TypeDeclaration.Rector.Class_ uses a module listed above it, which is the healthy direction.

39→9 TypeDeclaration.Rector.Class_ uses VersionBonding.Contract✕

Connections

10 pairs of types, where a type in TypeDeclaration.Rector.Class_ uses a type in VersionBonding.Contract.

The types involved

• Rector.TypeDeclaration.Rector.Class_.AddTestsVoidReturnTypeWhereNoReturnRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.Class_.MergeDateTimePropertyTypeDeclarationRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.Class_.ObjectTypedPropertyFromJMSSerializerAttributeTypeRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.Class_.PropertyTypeFromStrictSetterGetterRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.Class_.ReturnTypeFromStrictTernaryRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.Class_.ScalarTypedPropertyFromJMSSerializerAttributeTypeRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromContainerGetSetUpRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromCreateMockAssignRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromDocblockSetUpDefinedRector → Rector.VersionBonding.Contract.MinPhpVersionInterface
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromGetRepositorySetUpRector → Rector.VersionBonding.Contract.MinPhpVersionInterface

Direction

TypeDeclaration.Rector.Class_ uses VersionBonding.Contract, so a change to VersionBonding.Contract can break TypeDeclaration.Rector.Class_, while a change to TypeDeclaration.Rector.Class_ can't break VersionBonding.Contract.

Position

Below the diagonal: TypeDeclaration.Rector.Class_ uses a module listed above it, which is the healthy direction.

39→10 TypeDeclaration.Rector.Class_ uses BetterPhpDocParser.PhpDocInfo✕

Connections

5 pairs of types, where a type in TypeDeclaration.Rector.Class_ uses a type in BetterPhpDocParser.PhpDocInfo.

The types involved

• Rector.TypeDeclaration.Rector.Class_.ChildDoctrineRepositoryClassTypeRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.TypeDeclaration.Rector.Class_.MergeDateTimePropertyTypeDeclarationRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromDocblockSetUpDefinedRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfo
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromDocblockSetUpDefinedRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory
• Rector.TypeDeclaration.Rector.Class_.TypedStaticPropertyInBehatContextRector → Rector.BetterPhpDocParser.PhpDocInfo.PhpDocInfoFactory

Direction

TypeDeclaration.Rector.Class_ uses BetterPhpDocParser.PhpDocInfo, so a change to BetterPhpDocParser.PhpDocInfo can break TypeDeclaration.Rector.Class_, while a change to TypeDeclaration.Rector.Class_ can't break BetterPhpDocParser.PhpDocInfo.

Position

Below the diagonal: TypeDeclaration.Rector.Class_ uses a module listed above it, which is the healthy direction.

39→12 TypeDeclaration.Rector.Class_ uses Comments.NodeDocBlock✕

Connections

3 pairs of types, where a type in TypeDeclaration.Rector.Class_ uses a type in Comments.NodeDocBlock.

The types involved

• Rector.TypeDeclaration.Rector.Class_.ChildDoctrineRepositoryClassTypeRector → Rector.Comments.NodeDocBlock.DocBlockUpdater
• Rector.TypeDeclaration.Rector.Class_.MergeDateTimePropertyTypeDeclarationRector → Rector.Comments.NodeDocBlock.DocBlockUpdater
• Rector.TypeDeclaration.Rector.Class_.TypedPropertyFromDocblockSetUpDefinedRector → Rector.Comments.NodeDocBlock.DocBlockUpdater

Direction

TypeDeclaration.Rector.Class_ uses Comments.NodeDocBlock, so a change to Comments.NodeDocBlock can break TypeDeclaration.Rector.Class_, while a change to TypeDeclaration.Rector.Class_ can't break Comments.NodeDocBlock.

Position

Below the diagonal: TypeDeclaration.Rector.Class_ uses a module listed above it, which is the healthy direction.

39→14 TypeDeclaration.Rector.Class_ uses PhpParser.Node✕

Connections

2 pairs of types, where a type in TypeDeclaration.Rector.Class_ uses a type in PhpParser.Node.

The types involved

• Rector.TypeDeclaration.Rector.Class_.PropertyTypeFromStrictSetterGetterRector → Rector.PhpParser.Node.BetterNodeFinder
• Rector.TypeDeclaration.Rector.Class_.ReturnTypeFromStrictTernaryRector → Rector.PhpParser.Node.BetterNodeFinder

Direction

TypeDeclaration.Rector.Class_ uses PhpParser.Node, so a change to PhpParser.Node can break TypeDeclaration.Rector.Class_, while a change to TypeDeclaration.Rector.Class_ can't break PhpParser.Node.

Position

Below the diagonal: TypeDeclaration.Rector.Class_ uses a module listed above it, which is the healthy direction.

39→18 TypeDeclaration.Rector.Class_ uses Reflection✕

Connections

2 pairs of types, where a type in TypeDeclaration.Rector.Class_ uses a type in Reflection.

The types involved

• Rector.TypeDeclaration.Rector.Class_.PropertyTypeFromStrictSetterGetterRector → Rector.Reflection.ReflectionResolver
• Rector.TypeDeclaration.Rector.Class_.ScalarTypedPropertyFromJMSSerializerAttributeTypeRector → Rector.Reflection.ReflectionResolver

Direction

TypeDeclaration.Rector.Class_ uses Reflection, so a change to Reflection can break TypeDeclaration.Rector.Class_, while a change to TypeDeclaration.Rector.Class_ can't break Reflection.

Position

Below the diagonal: TypeDeclaration.Rector.Class_ uses a module listed above it, which is the healthy direction.

39→20 TypeDeclaration.Rector.Class_ uses DeadCode.PhpDoc.TagRemover✕

Connections

1 pair of types, where a type in TypeDeclaration.Rector.Class_ uses a type in DeadCode.PhpDoc.TagRemover.

The types involved

• Rector.TypeDeclaration.Rector.Class_.TypedStaticPropertyInBehatContextRector → Rector.DeadCode.PhpDoc.TagRemover.VarTagRemover

Direction

TypeDeclaration.Rector.Class_ uses DeadCode.PhpDoc.TagRemover, so a change to DeadCode.PhpDoc.TagRemover can break TypeDeclaration.Rector.Class_, while a change to TypeDeclaration.Rector.Class_ can't break DeadCode.PhpDoc.TagRemover.

Position

Below the diagonal: TypeDeclaration.Rector.Class_ uses a module listed above it, which is the healthy direction.