From 7f6b8e0172623d94cdbf5265e8ee056b422a46e3 Mon Sep 17 00:00:00 2001
From: Brown <github@muglug.com>
Date: Sun, 26 Jul 2020 10:12:53 -0400
Subject: [PATCH] Consolidate internal annotation tests

---
 tests/InternalAnnotationTest.php      | 549 ++++++++++++++++++++++++
 tests/PsalmInternalAnnotationTest.php | 575 --------------------------
 2 files changed, 549 insertions(+), 575 deletions(-)
 delete mode 100644 tests/PsalmInternalAnnotationTest.php

diff --git a/tests/InternalAnnotationTest.php b/tests/InternalAnnotationTest.php
index fc9f0c9ef..d8441cf2e 100644
--- a/tests/InternalAnnotationTest.php
+++ b/tests/InternalAnnotationTest.php
@@ -257,6 +257,282 @@ class InternalAnnotationTest extends TestCase
                         }
                     }',
             ],
+            'psalmInternalMethodWithCall' => [
+                '<?php
+                    namespace A\B {
+                        class Foo {
+                            /**
+                             * @internal
+                             * @psalm-internal A\B
+                             */
+                            public static function barBar(): void {
+                            }
+                        }
+                    }
+
+                    namespace A\B\C {
+                        class Bat {
+                            public function batBat() : void {
+                                \A\B\Foo::barBar();
+                            }
+                        }
+                    }',
+            ],
+            'internalMethodWithCallWithCaseMisMatched' => [
+                '<?php
+                    namespace A\B {
+                        class Foo {
+                            /**
+                             * @internal
+                             * @psalm-internal A\B
+                             */
+                            public static function barBar(): void {
+                            }
+                        }
+                    }
+
+                    namespace a\b\c {
+                        class Bat {
+                            public function batBat() : void {
+                                \A\B\Foo::barBar();
+                            }
+                        }
+                    }',
+            ],
+            'internalToClassMethodWithCallSameNamespace' => [
+                '<?php
+                    namespace A\B {
+                        class Foo {
+                            /**
+                             * @internal
+                             * @psalm-internal A\B
+                             */
+                            public static function barBar(): void {
+                            }
+
+                            public static function foo(): void {
+                                self::barBar();
+                            }
+                        }
+                    }',
+            ],
+            'psalmInternalClassWithStaticCall' => [
+                '<?php
+                    namespace A\B {
+                        /**
+                         * @internal
+                         * @psalm-internal A
+                         */
+                        class Foo {
+                            public static function barBar(): void {
+                            }
+                        }
+                    }
+
+                    namespace A\B\C {
+                        class Bat {
+                            public function batBat() : void {
+                                \A\B\Foo::barBar();
+                            }
+                        }
+                    }',
+            ],
+            'psalmInternalClassWithInstanceCall' => [
+                '<?php
+                    namespace A\B {
+                        /**
+                         * @internal
+                         * @psalm-internal A\B
+                         */
+                        class Foo {
+                            public function barBar(): void {
+                            }
+                        }
+
+                        function getFoo(): Foo {
+                            return new Foo();
+                        }
+                    }
+
+                    namespace A\B\C {
+                        class Bat {
+                            public function batBat(\A\B\Foo $instance): void {
+                                \A\B\getFoo()->barBar();
+                            }
+                        }
+                    }',
+            ],
+            'psalmInternalClassWithPropertyFetch' => [
+                '<?php
+                    namespace A\B {
+                        /**
+                         * @internal
+                         * @psalm-internal A\B
+                         */
+                        class Foo {
+                            public int $barBar = 0;
+                        }
+
+                        function getFoo(): Foo {
+                            return new Foo();
+                        }
+                    }
+
+                    namespace A\B\C {
+                        class Bat {
+                            public function batBat(\A\B\Foo $instance): void {
+                                \A\B\getFoo()->barBar;
+                            }
+                        }
+                    }',
+            ],
+            'psalmInternalClassExtendingNamespaceWithStaticCall' => [
+                '<?php
+                    namespace A {
+                        /**
+                         * @internal
+                         * @psalm-internal A
+                         */
+                        class Foo extends \B\Foo {
+                            public function __construct() {
+                                parent::__construct();
+                            }
+                            public static function barBar(): void {
+                            }
+                        }
+                    }
+
+                    namespace B {
+                        class Foo {
+                            public function __construct() {
+                                static::barBar();
+                            }
+
+                            public static function barBar(): void {
+                            }
+                        }
+                    }',
+            ],
+            'psalmInternalClassWithNew' => [
+                '<?php
+                    namespace A\B {
+                        /**
+                         * @internal
+                         * @psalm-internal A\B
+                         */
+                        class Foo { }
+                    }
+
+                    namespace A\B\C {
+                        class Bat {
+                            public function batBat() : void {
+                                $a = new \A\B\Foo();
+                            }
+                        }
+                    }',
+            ],
+            'psalmInternalClassWithInstanceOf' => [
+                '<?php
+                    namespace A\B {
+                        interface Bar {};
+
+                        /**
+                         * @internal
+                         * @psalm-internal A\B
+                         */
+                        class Foo { }
+                    }
+
+                    namespace A\B\C {
+                        class Bat {
+                            public function batBat(\A\B\Bar $bar) : void {
+                                $bar instanceOf \A\B\Foo;
+                            }
+                        }
+                    }',
+            ],
+            'psalmInternalClassWithExtends' => [
+                '<?php
+                    namespace A\B {
+                        /**
+                         * @internal
+                         * @psalm-internal A\B
+                         */
+                        class Foo { }
+                    }
+
+                    namespace A\B\C {
+                        class Bar extends \A\B\Foo {}
+                    }',
+            ],
+            'psalmInternalPropertyGet' => [
+                '<?php
+                    namespace A\B {
+                        class Foo {
+                            /**
+                             * @internal
+                             * @psalm-internal A\B
+                             * @var ?int
+                             */
+                            public $foo;
+                        }
+                    }
+
+                    namespace A\B\C {
+                        class Bat {
+                            public function batBat() : void {
+                                echo (new \A\B\Foo)->foo;
+                            }
+                        }
+                    }',
+            ],
+            'psalmInternalPropertySet' => [
+                '<?php
+                    namespace A\B {
+                        class Foo {
+                            /**
+                             * @internal
+                             * @psalm-internal A\B
+                             * @var ?int
+                             */
+                            public $foo;
+                        }
+                    }
+                    namespace A\B\C {
+                        class Bat {
+                            public function batBat() : void {
+                                $a = new \A\B\Foo;
+                                $a->foo = 5;
+                            }
+                        }
+                    }',
+            ],
+            'psalmInternalMethodInTraitWithCall' => [
+                '<?php
+                    namespace A {
+                        /**
+                         * @internal
+                         * @psalm-internal A
+                         */
+                        trait T {
+                            public static function barBar(): void {
+                            }
+                        }
+
+                        class Foo {
+                            use T;
+
+                        }
+                    }
+
+                    namespace B {
+                        class Bat {
+                            public function batBat() : void {
+                                \A\Foo::barBar();
+                            }
+                        }
+                    }',
+            ],
         ];
     }
 
@@ -471,6 +747,279 @@ class InternalAnnotationTest extends TestCase
                     }',
                 'error_message' => 'InternalClass',
             ],
+            'psalmInternalMethodWithCall' => [
+                '<?php
+                    namespace A\B {
+                        class Foo {
+                            /**
+                             * @internal
+                             * @psalm-internal A\B
+                             */
+                            public static function barBar(): void {
+                            }
+                        }
+                    }
+
+                    namespace A\C {
+                        class Bat {
+                            public function batBat(): void {
+                                \A\B\Foo::barBar();
+                            }
+                        }
+                    }',
+                'error_message' => 'The method A\B\Foo::barBar is internal to A\B',
+            ],
+            'psalmInternalToClassMethodWithCall' => [
+                '<?php
+                    namespace A\B {
+                        class Foo {
+                            /**
+                             * @internal
+                             * @psalm-internal A\B\Foo
+                             */
+                            public static function barBar(): void {
+                            }
+                        }
+                    }
+
+                    namespace A\C {
+                        class Bat {
+                            public function batBat(): void {
+                                \A\B\Foo::barBar();
+                            }
+                        }
+                    }',
+                'error_message' => 'The method A\B\Foo::barBar is internal to A\B\Foo',
+            ],
+            'psalmInternalClassWithStaticCall' => [
+                '<?php
+                    namespace A\B {
+                        /**
+                         * @internal
+                         * @psalm-internal A\B
+                         */
+                        class Foo {
+                            public static function barBar(): void {
+                            }
+                        }
+                    }
+
+                    namespace A\C {
+                        class Bat {
+                            public function batBat(): void {
+                                \A\B\Foo::barBar();
+                            }
+                        }
+                    }',
+                'error_message' => 'InternalClass',
+            ],
+            'psalmInternalClassWithPropertyFetch' => [
+                '<?php
+                    namespace A\B {
+                        /**
+                         * @internal
+                         * @psalm-internal A\B
+                         */
+                        class Foo {
+                            public int $barBar = 0;
+                        }
+
+                        function getFoo(): Foo {
+                            return new Foo();
+                        }
+                    }
+
+                    namespace A\C {
+                        class Bat {
+                            public function batBat(): void {
+                                \A\B\getFoo()->barBar;
+                            }
+                        }
+                    }',
+                'error_message' => 'A\B\Foo::$barBar is internal to A\B',
+            ],
+            'psalmInternalClassWithInstanceCall' => [
+                '<?php
+                    namespace A\B {
+                        /**
+                         * @internal
+                         * @psalm-internal A\B
+                         */
+                        class Foo {
+                            public function barBar(): void {
+                            }
+                        }
+
+                        function getFoo(): Foo {
+                            return new Foo();
+                        }
+                    }
+
+                    namespace A\C {
+                        class Bat {
+                            public function batBat(): void {
+                                \A\B\getFoo()->barBar();
+                            }
+                        }
+                    }',
+                'error_message' => 'The method A\B\Foo::barBar is internal to A\B',
+            ],
+            'psalmInternalClassWithNew' => [
+                '<?php
+                    namespace A\B {
+                        /**
+                         * @internal
+                         * @psalm-internal A\B
+                         */
+                        class Foo { }
+                    }
+
+                    namespace A\C {
+                        class Bat {
+                            public function batBat(): void {
+                                $a = new \A\B\Foo();
+                            }
+                        }
+                    }',
+                'error_message' => 'InternalClass',
+            ],
+            'psalmInternalClassWithExtends' => [
+                '<?php
+                    namespace A\B {
+                        /**
+                         * @internal
+                         * @psalm-internal A\B
+                         */
+                        class Foo { }
+                    }
+
+                    namespace A\C {
+                        class Bar extends \A\B\Foo {}
+                    }',
+                'error_message' => 'A\B\Foo is internal to A\B',
+            ],
+            'psalmInternalPropertyGet' => [
+                '<?php
+                    namespace A\B {
+                        class Foo {
+                            /**
+                             * @internal
+                             * @psalm-internal A\B
+                             * @var ?int
+                             */
+                            public $foo;
+                        }
+                    }
+
+                    namespace A\C {
+                        class Bat {
+                            public function batBat() : void {
+                                echo (new \A\B\Foo)->foo;
+                            }
+                        }
+                    }',
+                'error_message' => 'A\B\Foo::$foo is internal to A\B',
+            ],
+            'psalmInternalPropertySet' => [
+                '<?php
+                    namespace A\B {
+                        class Foo {
+                            /**
+                             * @internal
+                             * @psalm-internal A\B
+                             * @var ?int
+                             */
+                            public $foo;
+                        }
+                    }
+                    namespace A\C {
+                        class Bat {
+                            public function batBat() : void {
+                                $a = new \A\B\Foo;
+                                $a->foo = 5;
+                            }
+                        }
+                    }',
+                'error_message' => 'A\B\Foo::$foo is internal to A\B',
+            ],
+            'psalmInternalClassMissingNamespace' => [
+                    '<?php
+
+                    /**
+                      * @internal
+                      * @psalm-internal
+                      */
+                    class Foo {}
+
+                    ',
+                    'error_message' => 'psalm-internal annotation used without specifying namespace',
+            ],
+            'psalmInternalPropertyMissingNamespace' => [
+                '<?php
+                    class Foo {
+                        /**
+                          * @var int
+                          * @internal
+                          * @psalm-internal
+                          */
+                        var $bar;
+                    }
+                    ',
+                'error_message' => 'psalm-internal annotation used without specifying namespace',
+            ],
+            'psalmInternalMethodMissingNamespace' => [
+                '<?php
+                    class Foo {
+                        /**
+                         * @internal
+                         * @psalm-internal
+                         */
+                        function Bar(): void {}
+                    }
+
+                    ',
+                'error_message' => 'psalm-internal annotation used without specifying namespace',
+            ],
+            'psalmInternalClassMissingInternalAnnotation' => [
+                '<?php
+                    namespace A\B {
+                        /**
+                         * @psalm-internal A\B
+                         */
+                        class Foo { }
+                    }
+                    ',
+                'error_message' => 'psalm-internal annotation used without @internal',
+                ],
+            'psalmInternalPropertyMissingInternalAnnotation' => [
+                '<?php
+                    namespace A\B {
+                        class Foo {
+                            /**
+                             * @var int
+                             * @psalm-internal A\B
+                             */
+                             public $foo;
+                        }
+                    }
+                    ',
+                'error_message' => 'psalm-internal annotation used without @internal',
+                ],
+            'psalmInternalFunctionMissingInternalAnnotation' => [
+                '<?php
+                    namespace A\B {
+                        class Foo {
+                            /**
+                             * @psalm-internal A\B
+                             */
+                             public function foo()
+                             {
+                             }
+                        }
+                    }
+                    ',
+                'error_message' => 'psalm-internal annotation used without @internal',
+            ],
         ];
     }
 }
diff --git a/tests/PsalmInternalAnnotationTest.php b/tests/PsalmInternalAnnotationTest.php
deleted file mode 100644
index 011258189..000000000
--- a/tests/PsalmInternalAnnotationTest.php
+++ /dev/null
@@ -1,575 +0,0 @@
-<?php
-namespace Psalm\Tests;
-
-class PsalmInternalAnnotationTest extends TestCase
-{
-    use Traits\InvalidCodeAnalysisTestTrait;
-    use Traits\ValidCodeAnalysisTestTrait;
-
-    /**
-     * @return iterable<string,array{string,assertions?:array<string,string>,error_levels?:string[]}>
-     */
-    public function providerValidCodeParse()
-    {
-        return [
-            'internalMethodWithCall' => [
-                '<?php
-                    namespace A\B {
-                        class Foo {
-                            /**
-                             * @internal
-                             * @psalm-internal A\B
-                             */
-                            public static function barBar(): void {
-                            }
-                        }
-                    }
-
-                    namespace A\B\C {
-                        class Bat {
-                            public function batBat() : void {
-                                \A\B\Foo::barBar();
-                            }
-                        }
-                    }',
-            ],
-            'internalMethodWithCallWithCaseMisMatched' => [
-                '<?php
-                    namespace A\B {
-                        class Foo {
-                            /**
-                             * @internal
-                             * @psalm-internal A\B
-                             */
-                            public static function barBar(): void {
-                            }
-                        }
-                    }
-
-                    namespace a\b\c {
-                        class Bat {
-                            public function batBat() : void {
-                                \A\B\Foo::barBar();
-                            }
-                        }
-                    }',
-            ],
-            'internalToClassMethodWithCall' => [
-                '<?php
-                    namespace A\B {
-                        class Foo {
-                            /**
-                             * @internal
-                             * @psalm-internal A\B\Foo
-                             */
-                            public static function barBar(): void {
-                            }
-
-                            public static function foo(): void {
-                                self::barBar();
-                            }
-                        }
-                    }',
-            ],
-            'internalClassWithStaticCall' => [
-                '<?php
-                    namespace A\B {
-                        /**
-                         * @internal
-                         * @psalm-internal A
-                         */
-                        class Foo {
-                            public static function barBar(): void {
-                            }
-                        }
-                    }
-
-                    namespace A\B\C {
-                        class Bat {
-                            public function batBat() : void {
-                                \A\B\Foo::barBar();
-                            }
-                        }
-                    }',
-            ],
-            'internalClassWithInstanceCall' => [
-                '<?php
-                    namespace A\B {
-                        /**
-                         * @internal
-                         * @psalm-internal A\B
-                         */
-                        class Foo {
-                            public function barBar(): void {
-                            }
-                        }
-
-                        function getFoo(): Foo {
-                            return new Foo();
-                        }
-                    }
-
-                    namespace A\B\C {
-                        class Bat {
-                            public function batBat(\A\B\Foo $instance): void {
-                                \A\B\getFoo()->barBar();
-                            }
-                        }
-                    }',
-            ],
-            'internalClassWithPropertyFetch' => [
-                '<?php
-                    namespace A\B {
-                        /**
-                         * @internal
-                         * @psalm-internal A\B
-                         */
-                        class Foo {
-                            public int $barBar = 0;
-                        }
-
-                        function getFoo(): Foo {
-                            return new Foo();
-                        }
-                    }
-
-                    namespace A\B\C {
-                        class Bat {
-                            public function batBat(\A\B\Foo $instance): void {
-                                \A\B\getFoo()->barBar;
-                            }
-                        }
-                    }',
-            ],
-            'internalClassExtendingNamespaceWithStaticCall' => [
-                '<?php
-                    namespace A {
-                        /**
-                         * @internal
-                         * @psalm-internal A
-                         */
-                        class Foo extends \B\Foo {
-                            public function __construct() {
-                                parent::__construct();
-                            }
-                            public static function barBar(): void {
-                            }
-                        }
-                    }
-
-                    namespace B {
-                        class Foo {
-                            public function __construct() {
-                                static::barBar();
-                            }
-
-                            public static function barBar(): void {
-                            }
-                        }
-                    }',
-            ],
-            'internalClassWithNew' => [
-                '<?php
-                    namespace A\B {
-                        /**
-                         * @internal
-                         * @psalm-internal A\B
-                         */
-                        class Foo { }
-                    }
-
-                    namespace A\B\C {
-                        class Bat {
-                            public function batBat() : void {
-                                $a = new \A\B\Foo();
-                            }
-                        }
-                    }',
-            ],
-            'internalClassWithInstanceOf' => [
-                '<?php
-                    namespace A\B {
-                        interface Bar {};
-
-                        /**
-                         * @internal
-                         * @psalm-internal A\B
-                         */
-                        class Foo { }
-                    }
-
-                    namespace A\B\C {
-                        class Bat {
-                            public function batBat(\A\B\Bar $bar) : void {
-                                $bar instanceOf \A\B\Foo;
-                            }
-                        }
-                    }',
-            ],
-            'internalClassWithExtends' => [
-                '<?php
-                    namespace A\B {
-                        /**
-                         * @internal
-                         * @psalm-internal A\B
-                         */
-                        class Foo { }
-                    }
-
-                    namespace A\B\C {
-                        class Bar extends \A\B\Foo {}
-                    }',
-            ],
-            'internalPropertyGet' => [
-                '<?php
-                    namespace A\B {
-                        class Foo {
-                            /**
-                             * @internal
-                             * @psalm-internal A\B
-                             * @var ?int
-                             */
-                            public $foo;
-                        }
-                    }
-
-                    namespace A\B\C {
-                        class Bat {
-                            public function batBat() : void {
-                                echo (new \A\B\Foo)->foo;
-                            }
-                        }
-                    }',
-            ],
-            'internalPropertySet' => [
-                '<?php
-                    namespace A\B {
-                        class Foo {
-                            /**
-                             * @internal
-                             * @psalm-internal A\B
-                             * @var ?int
-                             */
-                            public $foo;
-                        }
-                    }
-                    namespace A\B\C {
-                        class Bat {
-                            public function batBat() : void {
-                                $a = new \A\B\Foo;
-                                $a->foo = 5;
-                            }
-                        }
-                    }',
-            ],
-            'internalMethodInTraitWithCall' => [
-                '<?php
-                    namespace A {
-                        /**
-                         * @internal
-                         * @psalm-internal A
-                         */
-                        trait T {
-                            public static function barBar(): void {
-                            }
-                        }
-
-                        class Foo {
-                            use T;
-
-                        }
-                    }
-
-                    namespace B {
-                        class Bat {
-                            public function batBat() : void {
-                                \A\Foo::barBar();
-                            }
-                        }
-                    }',
-            ],
-        ];
-    }
-
-    /**
-     * @return iterable<string,array{string,error_message:string,2?:string[],3?:bool,4?:string}>
-     */
-    public function providerInvalidCodeParse()
-    {
-        return [
-            'internalMethodWithCall' => [
-                '<?php
-                    namespace A\B {
-                        class Foo {
-                            /**
-                             * @internal
-                             * @psalm-internal A\B
-                             */
-                            public static function barBar(): void {
-                            }
-                        }
-                    }
-
-                    namespace A\C {
-                        class Bat {
-                            public function batBat(): void {
-                                \A\B\Foo::barBar();
-                            }
-                        }
-                    }',
-                'error_message' => 'The method A\B\Foo::barBar is internal to A\B',
-            ],
-            'internalToClassMethodWithCall' => [
-                '<?php
-                    namespace A\B {
-                        class Foo {
-                            /**
-                             * @internal
-                             * @psalm-internal A\B\Foo
-                             */
-                            public static function barBar(): void {
-                            }
-                        }
-                    }
-
-                    namespace A\C {
-                        class Bat {
-                            public function batBat(): void {
-                                \A\B\Foo::barBar();
-                            }
-                        }
-                    }',
-                'error_message' => 'The method A\B\Foo::barBar is internal to A\B\Foo',
-            ],
-            'internalClassWithStaticCall' => [
-                '<?php
-                    namespace A\B {
-                        /**
-                         * @internal
-                         * @psalm-internal A\B
-                         */
-                        class Foo {
-                            public static function barBar(): void {
-                            }
-                        }
-                    }
-
-                    namespace A\C {
-                        class Bat {
-                            public function batBat(): void {
-                                \A\B\Foo::barBar();
-                            }
-                        }
-                    }',
-                'error_message' => 'InternalClass',
-            ],
-            'internalClassWithPropertyFetch' => [
-                '<?php
-                    namespace A\B {
-                        /**
-                         * @internal
-                         * @psalm-internal A\B
-                         */
-                        class Foo {
-                            public int $barBar = 0;
-                        }
-
-                        function getFoo(): Foo {
-                            return new Foo();
-                        }
-                    }
-
-                    namespace A\C {
-                        class Bat {
-                            public function batBat(): void {
-                                \A\B\getFoo()->barBar;
-                            }
-                        }
-                    }',
-                'error_message' => 'A\B\Foo::$barBar is internal to A\B',
-            ],
-            'internalClassWithInstanceCall' => [
-                '<?php
-                    namespace A\B {
-                        /**
-                         * @internal
-                         * @psalm-internal A\B
-                         */
-                        class Foo {
-                            public function barBar(): void {
-                            }
-                        }
-
-                        function getFoo(): Foo {
-                            return new Foo();
-                        }
-                    }
-
-                    namespace A\C {
-                        class Bat {
-                            public function batBat(): void {
-                                \A\B\getFoo()->barBar();
-                            }
-                        }
-                    }',
-                'error_message' => 'The method A\B\Foo::barBar is internal to A\B',
-            ],
-            'internalClassWithNew' => [
-                '<?php
-                    namespace A\B {
-                        /**
-                         * @internal
-                         * @psalm-internal A\B
-                         */
-                        class Foo { }
-                    }
-
-                    namespace A\C {
-                        class Bat {
-                            public function batBat(): void {
-                                $a = new \A\B\Foo();
-                            }
-                        }
-                    }',
-                'error_message' => 'InternalClass',
-            ],
-            'internalClassWithExtends' => [
-                '<?php
-                    namespace A\B {
-                        /**
-                         * @internal
-                         * @psalm-internal A\B
-                         */
-                        class Foo { }
-                    }
-
-                    namespace A\C {
-                        class Bar extends \A\B\Foo {}
-                    }',
-                'error_message' => 'A\B\Foo is internal to A\B',
-            ],
-            'internalPropertyGet' => [
-                '<?php
-                    namespace A\B {
-                        class Foo {
-                            /**
-                             * @internal
-                             * @psalm-internal A\B
-                             * @var ?int
-                             */
-                            public $foo;
-                        }
-                    }
-
-                    namespace A\C {
-                        class Bat {
-                            public function batBat() : void {
-                                echo (new \A\B\Foo)->foo;
-                            }
-                        }
-                    }',
-                'error_message' => 'A\B\Foo::$foo is internal to A\B',
-            ],
-            'internalPropertySet' => [
-                '<?php
-                    namespace A\B {
-                        class Foo {
-                            /**
-                             * @internal
-                             * @psalm-internal A\B
-                             * @var ?int
-                             */
-                            public $foo;
-                        }
-                    }
-                    namespace A\C {
-                        class Bat {
-                            public function batBat() : void {
-                                $a = new \A\B\Foo;
-                                $a->foo = 5;
-                            }
-                        }
-                    }',
-                'error_message' => 'A\B\Foo::$foo is internal to A\B',
-            ],
-            'internalClassMissingNamespace' => [
-                    '<?php
-
-                    /**
-                      * @internal
-                      * @psalm-internal
-                      */
-                    class Foo {}
-
-                    ',
-                    'error_message' => 'psalm-internal annotation used without specifying namespace',
-            ],
-            'internalPropertyMissingNamespace' => [
-                '<?php
-                    class Foo {
-                        /**
-                          * @var int
-                          * @internal
-                          * @psalm-internal
-                          */
-                        var $bar;
-                    }
-                    ',
-                'error_message' => 'psalm-internal annotation used without specifying namespace',
-            ],
-            'internalMethodMissingNamespace' => [
-                '<?php
-                    class Foo {
-                        /**
-                         * @internal
-                         * @psalm-internal
-                         */
-                        function Bar(): void {}
-                    }
-
-                    ',
-                'error_message' => 'psalm-internal annotation used without specifying namespace',
-            ],
-            'internalClassMissingInternalAnnotation' => [
-                '<?php
-                    namespace A\B {
-                        /**
-                         * @psalm-internal A\B
-                         */
-                        class Foo { }
-                    }
-                    ',
-                'error_message' => 'psalm-internal annotation used without @internal',
-                ],
-            'internalPropertyMissingInternalAnnotation' => [
-                '<?php
-                    namespace A\B {
-                        class Foo {
-                            /**
-                             * @var int
-                             * @psalm-internal A\B
-                             */
-                             public $foo;
-                        }
-                    }
-                    ',
-                'error_message' => 'psalm-internal annotation used without @internal',
-                ],
-            'internalFunctionMissingInternalAnnotation' => [
-                '<?php
-                    namespace A\B {
-                        class Foo {
-                            /**
-                             * @psalm-internal A\B
-                             */
-                             public function foo()
-                             {
-                             }
-                        }
-                    }
-                    ',
-                'error_message' => 'psalm-internal annotation used without @internal',
-            ],
-        ];
-    }
-}