Remove deprecated arguments

Argument creation was deprecated on the method tag. This is now removed.

tests/integration/InterpretingDocBlocksTest.php

@@ -217,14 +217,13 @@ DOC;
             [
                 new Method(
                     'setInteger',
-                    [],
+                    [
+                        new MethodParameter('integer', new Integer())
+                    ],
                     new Void_(),
                     false,
                     new Description(''),
                     false,
-                    [
-                        new MethodParameter('integer', new Integer())
-                    ]
                 ),
             ],
             $docblock->getTags()

tests/integration/TypedTagsTest.php

@@ -75,7 +75,7 @@ DOCBLOCK;
 
         $this->assertInstanceOf(Method::class, $phpdoc->getTags()[0]);
         $this->assertEquals($expectedType, $phpdoc->getTags()[0]->getReturnType());
-        $this->assertEquals($expectedType, $phpdoc->getTags()[0]->getParameters()[0]->getType());
+        $this->assertEquals($expectedType, current($phpdoc->getTags()[0]->getParameters())->getType());
     }
 
     /** @dataProvider invalidFormatsProvider */

tests/unit/DocBlock/Tags/Factory/MethodFactoryTest.php

@@ -56,7 +56,6 @@ final class MethodFactoryTest extends TagFactoryTestCase
                     true,
                     new Description(''),
                     false,
-                    []
                 ),
             ],
             [
@@ -68,7 +67,6 @@ final class MethodFactoryTest extends TagFactoryTestCase
                     false,
                     new Description(''),
                     false,
-                    []
                 ),
             ],
             [
@@ -80,82 +78,75 @@ final class MethodFactoryTest extends TagFactoryTestCase
                     false,
                     new Description(''),
                     false,
-                    []
                 ),
             ],
             [
                 '@method myMethod($a)',
                 new Method(
                     'myMethod',
-                    [],
+                    [new MethodParameter('a', new Mixed_())],
                     new Void_(),
                     false,
                     new Description(''),
                     false,
-                    [new MethodParameter('a', new Mixed_())]
                 ),
             ],
             [
                 '@method void setInteger(integer $integer)',
                 new Method(
                     'setInteger',
-                    [],
+                    [new MethodParameter('integer', new Integer())],
                     new Void_(),
                     false,
                     new Description(''),
                     false,
-                    [new MethodParameter('integer', new Integer())]
                 ),
             ],
             [
                 '@method myMethod($a = 1)',
                 new Method(
                     'myMethod',
-                    [],
+                    [new MethodParameter('a', new Mixed_(), false, false, '1')],
                     new Void_(),
                     false,
                     new Description(''),
                     false,
-                    [new MethodParameter('a', new Mixed_(), false, false, '1')]
                 ),
             ],
             [
                 '@method myMethod(int $a = 1)',
                 new Method(
                     'myMethod',
-                    [],
+                    [new MethodParameter('a', new Integer(), false, false, '1')],
                     new Void_(),
                     false,
                     new Description(''),
                     false,
-                    [new MethodParameter('a', new Integer(), false, false, '1')]
                 ),
             ],
             [
                 '@method myMethod(int ...$a)',
                 new Method(
                     'myMethod',
-                    [],
+                    [new MethodParameter('a', new Integer(), false, true)],
                     new Void_(),
                     false,
                     new Description(''),
                     false,
-                    [new MethodParameter('a', new Integer(), false, true)]
                 ),
             ],
             [
                 '@method myMethod(int &$a, string $b)',
                 new Method(
                     'myMethod',
-                    [],
+                    [
+                        new MethodParameter('a', new Integer(), true, false),
+                        new MethodParameter('b', new String_(), false, false),
+                    ],
                     new Void_(),
                     false,
                     new Description(''),
                     false,
-                    [
-                        new MethodParameter('a', new Integer(), true, false),
-                        new MethodParameter('b', new String_(), false, false),
-                    ]
                 ),
             ],
         ];

tests/unit/DocBlock/Tags/MethodTest.php

@@ -15,17 +15,9 @@ namespace phpDocumentor\Reflection\DocBlock\Tags;
 
 use Mockery as m;
 use phpDocumentor\Reflection\DocBlock\Description;
-use phpDocumentor\Reflection\DocBlock\DescriptionFactory;
-use phpDocumentor\Reflection\Fqsen;
-use phpDocumentor\Reflection\TypeResolver;
-use phpDocumentor\Reflection\Types\Array_;
-use phpDocumentor\Reflection\Types\Compound;
-use phpDocumentor\Reflection\Types\Context;
-use phpDocumentor\Reflection\Types\Integer;
-use phpDocumentor\Reflection\Types\Mixed_;
+use phpDocumentor\Reflection\Exception\CannotCreateTag;
 use phpDocumentor\Reflection\Types\Object_;
 use phpDocumentor\Reflection\Types\String_;
-use phpDocumentor\Reflection\Types\This;
 use phpDocumentor\Reflection\Types\Void_;
 use PHPUnit\Framework\TestCase;
 
@@ -68,8 +60,8 @@ class MethodTest extends TestCase
     public function testIfTagCanBeRenderedUsingDefaultFormatter(): void
     {
         $arguments = [
-            ['name' => 'argument1', 'type' => new String_()],
-            ['name' => 'argument2', 'type' => new Object_()],
+            new MethodParameter('argument1', new String_()),
+            new MethodParameter('argument2', new Object_()),
         ];
 
         $fixture = new Method(
@@ -97,7 +89,7 @@ class MethodTest extends TestCase
         $fixture = new Method('myMethod');
 
         $formatter = m::mock(Formatter::class);
-        $formatter->shouldReceive('format')->with($fixture)->andReturn('Rendered output');
+        $formatter->allows('format')->with($fixture)->andReturns('Rendered output');
 
         $this->assertSame('Rendered output', $fixture->render($formatter));
     }
@@ -122,75 +114,12 @@ class MethodTest extends TestCase
     public function testHasArguments(): void
     {
         $arguments = [
-            ['name' => 'argument1', 'type' => new String_()],
+            new MethodParameter('argument1', new String_()),
         ];
 
         $fixture = new Method('myMethod', $arguments);
 
-        $this->assertSame($arguments, $fixture->getArguments());
-    }
-
-    /**
-     * @covers ::__construct
-     * @covers ::getArguments
-     */
-    public function testArgumentsMayBePassedAsString(): void
-    {
-        $arguments = ['argument1'];
-        $expected  = [
-            ['name' => $arguments[0], 'type' => new Mixed_()],
-        ];
-
-        $fixture = new Method('myMethod', $arguments);
-
-        $this->assertEquals($expected, $fixture->getArguments());
-    }
-
-    /**
-     * @covers ::__construct
-     * @covers ::getArguments
-     */
-    public function testArgumentTypeCanBeInferredAsMixed(): void
-    {
-        $arguments = [['name' => 'argument1']];
-        $expected  = [
-            ['name' => $arguments[0]['name'], 'type' => new Mixed_()],
-        ];
-
-        $fixture = new Method('myMethod', $arguments);
-
-        $this->assertEquals($expected, $fixture->getArguments());
-    }
-
-    /**
-     * @uses   \phpDocumentor\Reflection\DocBlock\Tags\Method::__construct
-     * @uses   \phpDocumentor\Reflection\DocBlock\Tags\Method::getArguments
-     * @uses   \phpDocumentor\Reflection\DocBlock\Description
-     *
-     * @covers ::create
-     */
-    public function testRestArgumentIsParsedAsRegularArg(): void
-    {
-        $expected = [
-            ['name' => 'arg1', 'type' => new Mixed_()],
-            ['name' => 'rest', 'type' => new Mixed_()],
-            ['name' => 'rest2', 'type' => new Array_()],
-        ];
-
-        $descriptionFactory = m::mock(DescriptionFactory::class);
-        $resolver           = new TypeResolver();
-        $context            = new Context('');
-        $description        = new Description('');
-        $descriptionFactory->shouldReceive('create')->with('', $context)->andReturn($description);
-
-        $fixture = Method::create(
-            'void myMethod($arg1, ...$rest, array ... $rest2)',
-            $resolver,
-            $descriptionFactory,
-            $context
-        );
-
-        $this->assertEquals($expected, $fixture->getArguments());
+        $this->assertSame($arguments, $fixture->getParameters());
     }
 
     /**
@@ -257,8 +186,8 @@ class MethodTest extends TestCase
     public function testStringRepresentationIsReturned(): void
     {
         $arguments = [
-            ['name' => 'argument1', 'type' => new String_()],
-            ['name' => 'argument2', 'type' => new Object_()],
+            new MethodParameter('argument1', new String_()),
+            new MethodParameter('argument2', new Object_()),
         ];
         $fixture   = new Method('myMethod', $arguments, new Void_(), true, new Description('My Description'));
 
@@ -284,11 +213,9 @@ class MethodTest extends TestCase
             (string) $fixture
         );
 
-        // ---
-
         $arguments = [
-            ['name' => 'argument1', 'type' => new String_()],
-            ['name' => 'argument2', 'type' => new Object_()],
+            new MethodParameter('argument1', new String_()),
+            new MethodParameter('argument2', new Object_()),
         ];
         $fixture   = new Method('myMethod', $arguments, new Void_(), true);
 
@@ -299,403 +226,11 @@ class MethodTest extends TestCase
     }
 
     /**
-     * @uses \phpDocumentor\Reflection\DocBlock\Tags\Method::<public>
-     * @uses \phpDocumentor\Reflection\DocBlock\DescriptionFactory
-     * @uses \phpDocumentor\Reflection\TypeResolver
-     * @uses \phpDocumentor\Reflection\DocBlock\Description
-     * @uses \phpDocumentor\Reflection\Fqsen
-     * @uses \phpDocumentor\Reflection\Types\Context
-     *
      * @covers ::create
      */
-    public function testFactoryMethod(): void
+    public function testFactoryMethodThrows(): void
     {
-        $descriptionFactory = m::mock(DescriptionFactory::class);
-        $resolver           = new TypeResolver();
-        $context            = new Context('');
-
-        $description       = new Description('My Description');
-        $expectedArguments = [
-            ['name' => 'argument1', 'type' => new String_()],
-            ['name' => 'argument2', 'type' => new Mixed_()],
-        ];
-
-        $descriptionFactory->shouldReceive('create')
-            ->with('My Description', $context)
-            ->andReturn($description);
-
-        $fixture = Method::create(
-            'static void myMethod(string $argument1, $argument2) My Description',
-            $resolver,
-            $descriptionFactory,
-            $context
-        );
-
-        $this->assertSame(
-            'static void myMethod(string $argument1, mixed $argument2) My Description',
-            (string) $fixture
-        );
-        $this->assertSame('myMethod', $fixture->getMethodName());
-        $this->assertEquals($expectedArguments, $fixture->getArguments());
-        $this->assertInstanceOf(Void_::class, $fixture->getReturnType());
-        $this->assertSame($description, $fixture->getDescription());
-        $this->assertFalse($fixture->returnsReference());
-    }
-
-    /**
-     * @uses \phpDocumentor\Reflection\DocBlock\Tags\Method::<public>
-     * @uses \phpDocumentor\Reflection\TypeResolver
-     * @uses \phpDocumentor\Reflection\DocBlock\Description
-     * @uses \phpDocumentor\Reflection\Types\Context
-     *
-     * @covers ::create
-     */
-    public function testReturnTypeThis(): void
-    {
-        $descriptionFactory = m::mock(DescriptionFactory::class);
-        $resolver           = new TypeResolver();
-        $context            = new Context('');
-
-        $description = new Description('');
-
-        $descriptionFactory->shouldReceive('create')->with('', $context)->andReturn($description);
-
-        $fixture = Method::create(
-            'static $this myMethod()',
-            $resolver,
-            $descriptionFactory,
-            $context
-        );
-
-        $this->assertTrue($fixture->isStatic());
-        $this->assertSame('static $this myMethod()', (string) $fixture);
-        $this->assertSame('myMethod', $fixture->getMethodName());
-        $this->assertInstanceOf(This::class, $fixture->getReturnType());
-        $this->assertFalse($fixture->returnsReference());
-    }
-
-    /**
-     * @uses \phpDocumentor\Reflection\DocBlock\Tags\Method::<public>
-     * @uses \phpDocumentor\Reflection\TypeResolver
-     * @uses \phpDocumentor\Reflection\DocBlock\Description
-     * @uses \phpDocumentor\Reflection\Types\Context
-     *
-     * @covers ::create
-     */
-    public function testReturnTypeNoneWithLongMethodName(): void
-    {
-        $descriptionFactory = m::mock(DescriptionFactory::class);
-        $resolver           = new TypeResolver();
-        $context            = new Context('');
-
-        $description = new Description('');
-
-        $descriptionFactory->shouldReceive('create')->with('', $context)->andReturn($description);
-
-        $fixture = Method::create(
-            'myVeryLongMethodName($node)',
-            $resolver,
-            $descriptionFactory,
-            $context
-        );
-
-        $this->assertFalse($fixture->isStatic());
-        $this->assertSame('void myVeryLongMethodName(mixed $node)', (string) $fixture);
-        $this->assertSame('myVeryLongMethodName', $fixture->getMethodName());
-        $this->assertInstanceOf(Void_::class, $fixture->getReturnType());
-        $this->assertFalse($fixture->returnsReference());
-    }
-
-    /**
-     * @return string[][]
-     */
-    public function collectionReturnTypesProvider(): array
-    {
-        return [
-            ['int[]', Array_::class, Integer::class, Compound::class],
-            ['int[][]', Array_::class, Array_::class, Compound::class],
-            ['Object[]', Array_::class, Object_::class, Compound::class],
-            ['array[]', Array_::class, Array_::class, Compound::class],
-        ];
-    }
-
-    /**
-     * @uses         \phpDocumentor\Reflection\DocBlock\Tags\Method::<public>
-     * @uses         \phpDocumentor\Reflection\DocBlock\Description
-     * @uses         \phpDocumentor\Reflection\DocBlock\DescriptionFactory
-     * @uses         \phpDocumentor\Reflection\TypeResolver
-     * @uses         \phpDocumentor\Reflection\Types\Array_
-     * @uses         \phpDocumentor\Reflection\Types\Compound
-     * @uses         \phpDocumentor\Reflection\Types\Integer
-     * @uses         \phpDocumentor\Reflection\Types\Object_
-     *
-     * @dataProvider collectionReturnTypesProvider
-     * @covers ::create
-     */
-    public function testCollectionReturnTypes(
-        string $returnType,
-        string $expectedType,
-        ?string $expectedValueType = null,
-        ?string $expectedKeyType = null
-    ): void {
-        $resolver           = new TypeResolver();
-        $descriptionFactory = m::mock(DescriptionFactory::class);
-        $descriptionFactory->shouldReceive('create')
-            ->with('', null)
-            ->andReturn(new Description(''));
-
-        $fixture    = Method::create("${returnType} myMethod(\$arg)", $resolver, $descriptionFactory);
-        $returnType = $fixture->getReturnType();
-        $this->assertInstanceOf($expectedType, $returnType);
-
-        if (!($returnType instanceof Array_)) {
-            return;
-        }
-
-        $this->assertInstanceOf($expectedValueType, $returnType->getValueType());
-        $this->assertInstanceOf($expectedKeyType, $returnType->getKeyType());
-    }
-
-    /**
-     * @covers ::create
-     */
-    public function testFactoryMethodFailsIfBodyIsEmpty(): void
-    {
-        $this->expectException('InvalidArgumentException');
+        $this->expectException(CannotCreateTag::class);
         Method::create('');
     }
-
-    /**
-     * @covers ::create
-     */
-    public function testFactoryMethodReturnsNullIfBodyIsIncorrect(): void
-    {
-        $this->expectException('InvalidArgumentException');
-        $this->assertNull(Method::create('body('));
-    }
-
-    /**
-     * @covers ::create
-     */
-    public function testFactoryMethodFailsIfResolverIsNull(): void
-    {
-        $this->expectException('InvalidArgumentException');
-        Method::create('body');
-    }
-
-    /**
-     * @covers ::create
-     */
-    public function testFactoryMethodFailsIfDescriptionFactoryIsNull(): void
-    {
-        $this->expectException('InvalidArgumentException');
-        Method::create('body', new TypeResolver());
-    }
-
-    /**
-     * @covers ::__construct
-     */
-    public function testCreationFailsIfBodyIsEmpty(): void
-    {
-        $this->expectException('InvalidArgumentException');
-        new Method('');
-    }
-
-    /**
-     * @covers ::__construct
-     */
-    public function testCreationFailsIfArgumentRecordContainsInvalidEntry(): void
-    {
-        $this->expectException('InvalidArgumentException');
-        new Method('body', [['name' => 'myName', 'unknown' => 'nah']]);
-    }
-
-    /**
-     * @uses \phpDocumentor\Reflection\DocBlock\Tags\Method::<public>
-     * @uses \phpDocumentor\Reflection\DocBlock\DescriptionFactory
-     * @uses \phpDocumentor\Reflection\TypeResolver
-     * @uses \phpDocumentor\Reflection\DocBlock\Description
-     * @uses \phpDocumentor\Reflection\Fqsen
-     * @uses \phpDocumentor\Reflection\Types\Context
-     *
-     * @covers ::create
-     */
-    public function testCreateMethodParenthesisMissing(): void
-    {
-        $descriptionFactory = m::mock(DescriptionFactory::class);
-        $resolver           = new TypeResolver();
-        $context            = new Context('');
-
-        $description = new Description('My Description');
-
-        $descriptionFactory->shouldReceive('create')->with(
-            'My Description',
-            $context
-        )->andReturn($description);
-
-        $fixture = Method::create(
-            'static void myMethod My Description',
-            $resolver,
-            $descriptionFactory,
-            $context
-        );
-
-        $this->assertSame('static void myMethod() My Description', (string) $fixture);
-        $this->assertSame('myMethod', $fixture->getMethodName());
-        $this->assertEquals([], $fixture->getArguments());
-        $this->assertInstanceOf(Void_::class, $fixture->getReturnType());
-        $this->assertSame($description, $fixture->getDescription());
-        $this->assertFalse($fixture->returnsReference());
-    }
-
-    /**
-     * @uses \phpDocumentor\Reflection\DocBlock\Tags\Method::<public>
-     * @uses \phpDocumentor\Reflection\DocBlock\DescriptionFactory
-     * @uses \phpDocumentor\Reflection\TypeResolver
-     * @uses \phpDocumentor\Reflection\DocBlock\Description
-     * @uses \phpDocumentor\Reflection\Fqsen
-     * @uses \phpDocumentor\Reflection\Types\Context
-     *
-     * @covers ::create
-     */
-    public function testCreateMethodEmptyArguments(): void
-    {
-        $descriptionFactory = m::mock(DescriptionFactory::class);
-        $resolver           = new TypeResolver();
-        $context            = new Context('');
-
-        $description = new Description('My Description');
-
-        $descriptionFactory->shouldReceive('create')
-            ->with('My Description', $context)
-            ->andReturn($description);
-
-        $fixture = Method::create(
-            'static void myMethod() My Description',
-            $resolver,
-            $descriptionFactory,
-            $context
-        );
-
-        $this->assertSame('static void myMethod() My Description', (string) $fixture);
-        $this->assertSame('myMethod', $fixture->getMethodName());
-        $this->assertEquals([], $fixture->getArguments());
-        $this->assertInstanceOf(Void_::class, $fixture->getReturnType());
-        $this->assertSame($description, $fixture->getDescription());
-        $this->assertFalse($fixture->returnsReference());
-    }
-
-    /**
-     * @uses \phpDocumentor\Reflection\DocBlock\Tags\Method::<public>
-     * @uses \phpDocumentor\Reflection\DocBlock\DescriptionFactory
-     * @uses \phpDocumentor\Reflection\TypeResolver
-     * @uses \phpDocumentor\Reflection\DocBlock\Description
-     * @uses \phpDocumentor\Reflection\Fqsen
-     * @uses \phpDocumentor\Reflection\Types\Context
-     * @uses \phpDocumentor\Reflection\Types\Void_
-     *
-     * @covers ::create
-     */
-    public function testCreateWithoutReturnType(): void
-    {
-        $descriptionFactory = m::mock(DescriptionFactory::class);
-        $resolver           = new TypeResolver();
-        $context            = new Context('');
-
-        $description = new Description('');
-
-        $descriptionFactory->shouldReceive('create')->with('', $context)->andReturn($description);
-
-        $fixture = Method::create(
-            'myMethod()',
-            $resolver,
-            $descriptionFactory,
-            $context
-        );
-
-        $this->assertSame('void myMethod()', (string) $fixture);
-        $this->assertSame('myMethod', $fixture->getMethodName());
-        $this->assertEquals([], $fixture->getArguments());
-        $this->assertInstanceOf(Void_::class, $fixture->getReturnType());
-        $this->assertSame($description, $fixture->getDescription());
-        $this->assertFalse($fixture->returnsReference());
-    }
-
-    /**
-     * @uses \phpDocumentor\Reflection\DocBlock\Tags\Method::<public>
-     * @uses \phpDocumentor\Reflection\DocBlock\DescriptionFactory
-     * @uses \phpDocumentor\Reflection\TypeResolver
-     * @uses \phpDocumentor\Reflection\DocBlock\Description
-     * @uses \phpDocumentor\Reflection\Fqsen
-     * @uses \phpDocumentor\Reflection\Types\Context
-     * @uses \phpDocumentor\Reflection\Types\Array_
-     * @uses \phpDocumentor\Reflection\Types\Compound
-     * @uses \phpDocumentor\Reflection\Types\Integer
-     * @uses \phpDocumentor\Reflection\Types\Object_
-     *
-     * @covers ::create
-     */
-    public function testCreateWithMixedReturnTypes(): void
-    {
-        $descriptionFactory = m::mock(DescriptionFactory::class);
-        $resolver           = new TypeResolver();
-        $context            = new Context('');
-
-        $descriptionFactory->shouldReceive('create')->andReturn(new Description(''));
-
-        $fixture = Method::create(
-            'MyClass[]|int[] myMethod()',
-            $resolver,
-            $descriptionFactory,
-            $context
-        );
-
-        $this->assertSame('\MyClass[]|int[] myMethod()', (string) $fixture);
-        $this->assertSame('myMethod', $fixture->getMethodName());
-        $this->assertEquals([], $fixture->getArguments());
-
-        $this->assertEquals(
-            new Compound([
-                new Array_(new Object_(new Fqsen('\MyClass'))),
-                new Array_(new Integer()),
-            ]),
-            $fixture->getReturnType()
-        );
-    }
-
-    /**
-     * @uses \phpDocumentor\Reflection\DocBlock\Tags\Method::<public>
-     * @uses \phpDocumentor\Reflection\DocBlock\DescriptionFactory
-     * @uses \phpDocumentor\Reflection\TypeResolver
-     * @uses \phpDocumentor\Reflection\DocBlock\Description
-     * @uses \phpDocumentor\Reflection\Fqsen
-     * @uses \phpDocumentor\Reflection\Types\Context
-     * @uses \phpDocumentor\Reflection\Types\String_
-     *
-     * @covers ::create
-     */
-    public function testCreateWithReference(): void
-    {
-        $descriptionFactory = m::mock(DescriptionFactory::class);
-        $resolver           = new TypeResolver();
-        $context            = new Context('');
-
-        $description = new Description('');
-
-        $descriptionFactory->shouldReceive('create')->with('', $context)->andReturn($description);
-
-        $fixture = Method::create(
-            'string &myMethod()',
-            $resolver,
-            $descriptionFactory,
-            $context
-        );
-
-        $this->assertSame('string &myMethod()', (string) $fixture);
-        $this->assertSame('myMethod', $fixture->getMethodName());
-        $this->assertEquals([], $fixture->getArguments());
-        $this->assertInstanceOf(String_::class, $fixture->getReturnType());
-        $this->assertSame($description, $fixture->getDescription());
-        $this->assertTrue($fixture->returnsReference());
-    }
 }