Refactor various files to ensure proper newline at end of file; enhance test cases for optional tuple parameters and lazy callable collections; improve error message assertions in AdvancedEdgeCasesTest.

Author: rcalicdan

src/Internal/Checker/ReturnChecker.php

@@ -199,4 +199,4 @@ private static function resolveConditionalReturnType(
 
         return $returnTypeNode;
     }
-}
+}

src/Internal/DocblockNormalizer.php

@@ -52,4 +52,4 @@ function (array $matches): string {
             $doc
         ) ?? $doc;
     }
-}
+}

src/Internal/ErrorFactory.php

@@ -86,4 +86,4 @@ public static function prepareException(TypeError $e, ?int $line = null): TypeEr
 
         return $e;
     }
-}
+}

src/Wrapper/IterableWrapper.php

@@ -4,7 +4,6 @@
 
 namespace TypePHP\Wrapper;
 
-use ArrayIterator;
 use Generator;
 use PHPStan\PhpDocParser\Ast\Type\ArrayTypeNode;
 use PHPStan\PhpDocParser\Ast\Type\GenericTypeNode;
@@ -144,4 +143,4 @@ private static function wrapGenerator(iterable $iterable, \Closure $typeCheckCal
             yield $key => $value;
         }
     }
-}
+}

tests/Fixtures/Services/ClassUsingAliasedTraitMethod.php

@@ -9,4 +9,4 @@ class ClassUsingAliasedTraitMethod
     use ShiftedLoggerTrait {
         logEvent as recordAuditLog; // Aliases logEvent -> recordAuditLog
     }
-}
+}

tests/Internal/DocblockNormalizerTest.php

@@ -126,4 +126,4 @@
 
         expect(DocblockNormalizer::normalize($doc))->toBe($expected);
     });
-});
+});

tests/RuntimeChecker/GeneratorCheckerTest.php

@@ -50,4 +50,4 @@ function sampleGeneratorFixture(): Generator
             ->and($result->getMessage())->toContain('Generator sent value (TSend)')
         ;
     });
-});
+});

tests/TypeChecking/ArraysAndShapes/ArrayAndListTypesTest.php

@@ -175,6 +175,38 @@ function testReturnKeylessTuple(bool $valid): array
     return [[10, 20], 'bundle'];
 }
 
+/**
+ * Positional Tuple with Optional Trailing Element
+ *
+ * @param array{0: positive-int, 1?: non-empty-string} $tuple
+ */
+function testOptionalTupleParam(array $tuple): bool
+{
+    return true;
+}
+
+describe('Positional Tuples with Optional Trailing Elements (array{0: T1, 1?: T2})', function () {
+    test('accepts tuple when optional trailing element is omitted', function () {
+        expect(testOptionalTupleParam([42]))->toBeTrue();
+    });
+
+    test('accepts tuple when optional trailing element is provided with valid value', function () {
+        expect(testOptionalTupleParam([42, 'Alice']))->toBeTrue();
+    });
+
+    test('throws TypeError when required first tuple item is invalid', function () {
+        expect(fn () => testOptionalTupleParam([-5]))
+            ->toThrow(TypeError::class, "['0'] must be of type positive-int")
+        ;
+    });
+
+    test('throws TypeError when optional second tuple item is provided with invalid value', function () {
+        expect(fn () => testOptionalTupleParam([42, '']))
+            ->toThrow(TypeError::class, "['1'] must be of type non-empty-string")
+        ;
+    });
+});
+
 describe('Class Object Arrays (Dog[])', function () {
     test('accepts array of matching class instances', function () {
         expect(testDogArrayParam([new Dog(), new Dog()]))->toBe(2);
@@ -433,7 +465,8 @@ function testReturnKeylessTuple(bool $valid): array
             ];
 
             expect(fn () => testUnsealedTypedShape($payload))
-                ->toThrow(TypeError::class, "['code'] must be of type string, int (999) given");
+                ->toThrow(TypeError::class, "['code'] must be of type string, int (999) given")
+            ;
         });
     });
 });

tests/TypeChecking/Boundaries/AdvancedEdgeCasesTest.php

@@ -97,16 +97,17 @@ function testNestedConditionalReturn(string $format, mixed $value): mixed
             /** @var GenericCollection<?positive-int> $collection */
             $collection = new GenericCollection();
 
-            expect(fn() => $collection->add(-50))
-                ->toThrow(TypeError::class, 'Argument $item (template T = ?positive-int) must be of type positive-int, negative int (-50) given');
+            expect(fn () => $collection->add(-50))
+                ->toThrow(TypeError::class, 'Argument $item (template T = ?positive-int) must be of type positive-int, negative int (-50) given')
+            ;
         });
     });
 
     describe('Collections of Lazy Callables', function () {
         test('executes and validates a list of lazy callable proxies', function () {
             $formatters = [
-                fn(int $id): string => "id_{$id}",
-                fn(int $id): string => "user#{$id}",
+                fn (int $id): string => "id_{$id}",
+                fn (int $id): string => "user#{$id}",
             ];
 
             $results = processFormatterList($formatters, 42);
@@ -115,28 +116,31 @@ function testNestedConditionalReturn(string $format, mixed $value): mixed
 
         test('throws TypeError when a callable in the collection returns an invalid type', function () {
             $formatters = [
-                fn(int $id): string => "id_{$id}",
-                fn(int $id): string => '',
+                fn (int $id): string => "id_{$id}",
+                fn (int $id): string => '',
             ];
 
-            expect(fn() => processFormatterList($formatters, 42))
-                ->toThrow(TypeError::class, 'Callback $formatters[1] return value must be of type non-empty-string');
+            expect(fn () => processFormatterList($formatters, 42))
+                ->toThrow(TypeError::class, 'Callback $formatters[1] return value must be of type non-empty-string')
+            ;
         });
     });
 
     describe('Multi-Branch Nested Conditional Return Types', function () {
         test('throws TypeError when return value violates nested conditional branch', function () {
-            expect(fn() => testNestedConditionalReturn('float', -5.5))
-                ->toThrow(TypeError::class, 'Return value must be of type positive-float');
+            expect(fn () => testNestedConditionalReturn('float', -5.5))
+                ->toThrow(TypeError::class, 'Return value must be of type positive-float')
+            ;
         });
     });
 
     describe('Trait Method Aliasing (use Trait { old as new; })', function () {
         test('inherits DocBlock contracts when a Trait method is aliased in a class', function () {
             $service = new TypePHP\Tests\Fixtures\Services\ClassUsingAliasedTraitMethod();
 
-            expect(fn() => $service->recordAuditLog(-1, 'audit_ok'))
-                ->toThrow(TypeError::class, 'Argument $level must be of type positive-int');
+            expect(fn () => $service->recordAuditLog(-1, 'audit_ok'))
+                ->toThrow(TypeError::class, 'Argument $level must be of type positive-int')
+            ;
         });
     });
 });