Passed
Pull Request — master (#772)
by Aleksei
10:44 queued 03:40
created
src/Attributes/src/Internal/Instantiator/NamedArgumentsInstantiator.php 2 patches
Spacing   +23 added lines, -23 removed lines patch added patch discarded remove patch
@@ -49,17 +49,17 @@  discard block
 block discarded – undo
49 49
      */
50 50
     public function instantiate(\ReflectionClass $attr, array $arguments, \Reflector $context = null): object
51 51
     {
52
-        if ($this->isNamedArgumentsSupported()) {
53
-            try {
52
+        if ($this->isNamedArgumentsSupported()){
53
+            try{
54 54
                 return $attr->newInstanceArgs($arguments);
55
-            } catch (\Throwable $e) {
55
+            }catch (\Throwable $e){
56 56
                 throw Exception::withLocation($e, $attr->getFileName(), $attr->getStartLine());
57 57
             }
58 58
         }
59 59
 
60 60
         $constructor = $this->getConstructor($attr);
61 61
 
62
-        if ($constructor === null) {
62
+        if ($constructor === null){
63 63
             return $attr->newInstanceWithoutConstructor();
64 64
         }
65 65
 
@@ -78,9 +78,9 @@  discard block
 block discarded – undo
78 78
      */
79 79
     private function resolveParameters(\ReflectionClass $ctx, \ReflectionMethod $constructor, array $arguments): array
80 80
     {
81
-        try {
81
+        try{
82 82
             return $this->doResolveParameters($ctx, $constructor, $arguments);
83
-        } catch (\Throwable $e) {
83
+        }catch (\Throwable $e){
84 84
             throw Exception::withLocation($e, $constructor->getFileName(), $constructor->getStartLine());
85 85
         }
86 86
     }
@@ -92,16 +92,16 @@  discard block
 block discarded – undo
92 92
     {
93 93
         $namedArgsBegin = $this->analyzeKeys($arguments);
94 94
 
95
-        if ($namedArgsBegin === null) {
95
+        if ($namedArgsBegin === null){
96 96
             // Only numeric / positional keys exist.
97 97
             return $arguments;
98 98
         }
99 99
 
100
-        if ($namedArgsBegin === 0) {
100
+        if ($namedArgsBegin === 0){
101 101
             // Only named keys exist.
102 102
             $passed = [];
103 103
             $named = $arguments;
104
-        } else {
104
+        }else{
105 105
             // Numeric/positional keys followed by named keys.
106 106
             // No need to preserve numeric keys.
107 107
             $passed = array_slice($arguments, 0, $namedArgsBegin);
@@ -135,11 +135,11 @@  discard block
 block discarded – undo
135 135
         $arguments = \array_merge($arguments);
136 136
 
137 137
         $i = 0;
138
-        foreach ($arguments as $k => $_) {
139
-            if ($k !== $i) {
138
+        foreach ($arguments as $k => $_){
139
+            if ($k !== $i){
140 140
                 // This must be a string key.
141 141
                 // Any further numeric keys are illegal.
142
-                if (\array_key_exists($i, $arguments)) {
142
+                if (\array_key_exists($i, $arguments)){
143 143
                     throw new \BadMethodCallException(self::ERROR_POSITIONAL_AFTER_NAMED);
144 144
                 }
145 145
                 return $i;
@@ -175,25 +175,25 @@  discard block
 block discarded – undo
175 175
     ): array {
176 176
         // Analyze parameters.
177 177
         $n = count($parameters);
178
-        if ($n > 0 && end($parameters)->isVariadic()) {
178
+        if ($n > 0 && end($parameters)->isVariadic()){
179 179
             $variadicParameter = end($parameters);
180 180
             // Don't include the variadic parameter in the mapping process.
181 181
             --$n;
182
-        } else {
182
+        }else{
183 183
             $variadicParameter = null;
184 184
         }
185 185
 
186 186
         // Process parameters that are not already filled with positional args.
187 187
         // This loop will do nothing if $namedArgsBegin >= $n. That's ok.
188
-        for ($i = $namedArgsBegin; $i < $n; ++$i) {
188
+        for ($i = $namedArgsBegin; $i < $n; ++$i){
189 189
             $parameter = $parameters[$i];
190 190
             $k = $parameter->getName();
191
-            if (array_key_exists($k, $named)) {
191
+            if (array_key_exists($k, $named)){
192 192
                 $passed[] = $named[$k];
193 193
                 unset($named[$k]);
194
-            } elseif ($parameter->isDefaultValueAvailable()) {
194
+            } elseif ($parameter->isDefaultValueAvailable()){
195 195
                 $passed[] = $parameter->getDefaultValue();
196
-            } else {
196
+            }else{
197 197
                 $message = \vsprintf(self::ERROR_ARGUMENT_NOT_PASSED, [
198 198
                     $ctx->getName(),
199 199
                     $parameter->getPosition() + 1,
@@ -204,7 +204,7 @@  discard block
 block discarded – undo
204 204
             }
205 205
         }
206 206
 
207
-        if ($named === []) {
207
+        if ($named === []){
208 208
             // No unknown argument names exist.
209 209
             return $passed;
210 210
         }
@@ -214,11 +214,11 @@  discard block
 block discarded – undo
214 214
         $badArgName = key($named);
215 215
 
216 216
         // Check collision with positional arguments.
217
-        foreach ($parameters as $i => $parameter) {
218
-            if ($i >= $namedArgsBegin) {
217
+        foreach ($parameters as $i => $parameter){
218
+            if ($i >= $namedArgsBegin){
219 219
                 break;
220 220
             }
221
-            if ($parameter->getName() === $badArgName) {
221
+            if ($parameter->getName() === $badArgName){
222 222
                 // The named argument overwrites a positional argument.
223 223
                 $message = \sprintf(self::ERROR_OVERWRITE_ARGUMENT, $badArgName);
224 224
                 throw new \BadMethodCallException($message);
@@ -226,7 +226,7 @@  discard block
 block discarded – undo
226 226
         }
227 227
 
228 228
         // Special handling if a variadic parameter is present.
229
-        if ($variadicParameter !== null) {
229
+        if ($variadicParameter !== null){
230 230
             // The last parameter is variadic.
231 231
             // Since PHP 8+, variadic parameters can consume named arguments.
232 232
             // However, this code only runs if PHP < 8.
Please login to merge, or discard this patch.
Braces   +52 added lines, -23 removed lines patch added patch discarded remove patch
@@ -49,17 +49,22 @@  discard block
 block discarded – undo
49 49
      */
50 50
     public function instantiate(\ReflectionClass $attr, array $arguments, \Reflector $context = null): object
51 51
     {
52
-        if ($this->isNamedArgumentsSupported()) {
53
-            try {
52
+        if ($this->isNamedArgumentsSupported())
53
+        {
54
+            try
55
+            {
54 56
                 return $attr->newInstanceArgs($arguments);
55
-            } catch (\Throwable $e) {
57
+            }
58
+            catch (\Throwable $e)
59
+            {
56 60
                 throw Exception::withLocation($e, $attr->getFileName(), $attr->getStartLine());
57 61
             }
58 62
         }
59 63
 
60 64
         $constructor = $this->getConstructor($attr);
61 65
 
62
-        if ($constructor === null) {
66
+        if ($constructor === null)
67
+        {
63 68
             return $attr->newInstanceWithoutConstructor();
64 69
         }
65 70
 
@@ -78,9 +83,12 @@  discard block
 block discarded – undo
78 83
      */
79 84
     private function resolveParameters(\ReflectionClass $ctx, \ReflectionMethod $constructor, array $arguments): array
80 85
     {
81
-        try {
86
+        try
87
+        {
82 88
             return $this->doResolveParameters($ctx, $constructor, $arguments);
83
-        } catch (\Throwable $e) {
89
+        }
90
+        catch (\Throwable $e)
91
+        {
84 92
             throw Exception::withLocation($e, $constructor->getFileName(), $constructor->getStartLine());
85 93
         }
86 94
     }
@@ -92,16 +100,20 @@  discard block
 block discarded – undo
92 100
     {
93 101
         $namedArgsBegin = $this->analyzeKeys($arguments);
94 102
 
95
-        if ($namedArgsBegin === null) {
103
+        if ($namedArgsBegin === null)
104
+        {
96 105
             // Only numeric / positional keys exist.
97 106
             return $arguments;
98 107
         }
99 108
 
100
-        if ($namedArgsBegin === 0) {
109
+        if ($namedArgsBegin === 0)
110
+        {
101 111
             // Only named keys exist.
102 112
             $passed = [];
103 113
             $named = $arguments;
104
-        } else {
114
+        }
115
+        else
116
+        {
105 117
             // Numeric/positional keys followed by named keys.
106 118
             // No need to preserve numeric keys.
107 119
             $passed = array_slice($arguments, 0, $namedArgsBegin);
@@ -135,11 +147,14 @@  discard block
 block discarded – undo
135 147
         $arguments = \array_merge($arguments);
136 148
 
137 149
         $i = 0;
138
-        foreach ($arguments as $k => $_) {
139
-            if ($k !== $i) {
150
+        foreach ($arguments as $k => $_)
151
+        {
152
+            if ($k !== $i)
153
+            {
140 154
                 // This must be a string key.
141 155
                 // Any further numeric keys are illegal.
142
-                if (\array_key_exists($i, $arguments)) {
156
+                if (\array_key_exists($i, $arguments))
157
+                {
143 158
                     throw new \BadMethodCallException(self::ERROR_POSITIONAL_AFTER_NAMED);
144 159
                 }
145 160
                 return $i;
@@ -175,25 +190,34 @@  discard block
 block discarded – undo
175 190
     ): array {
176 191
         // Analyze parameters.
177 192
         $n = count($parameters);
178
-        if ($n > 0 && end($parameters)->isVariadic()) {
193
+        if ($n > 0 && end($parameters)->isVariadic())
194
+        {
179 195
             $variadicParameter = end($parameters);
180 196
             // Don't include the variadic parameter in the mapping process.
181 197
             --$n;
182
-        } else {
198
+        }
199
+        else
200
+        {
183 201
             $variadicParameter = null;
184 202
         }
185 203
 
186 204
         // Process parameters that are not already filled with positional args.
187 205
         // This loop will do nothing if $namedArgsBegin >= $n. That's ok.
188
-        for ($i = $namedArgsBegin; $i < $n; ++$i) {
206
+        for ($i = $namedArgsBegin; $i < $n; ++$i)
207
+        {
189 208
             $parameter = $parameters[$i];
190 209
             $k = $parameter->getName();
191
-            if (array_key_exists($k, $named)) {
210
+            if (array_key_exists($k, $named))
211
+            {
192 212
                 $passed[] = $named[$k];
193 213
                 unset($named[$k]);
194
-            } elseif ($parameter->isDefaultValueAvailable()) {
214
+            }
215
+            elseif ($parameter->isDefaultValueAvailable())
216
+            {
195 217
                 $passed[] = $parameter->getDefaultValue();
196
-            } else {
218
+            }
219
+            else
220
+            {
197 221
                 $message = \vsprintf(self::ERROR_ARGUMENT_NOT_PASSED, [
198 222
                     $ctx->getName(),
199 223
                     $parameter->getPosition() + 1,
@@ -204,7 +228,8 @@  discard block
 block discarded – undo
204 228
             }
205 229
         }
206 230
 
207
-        if ($named === []) {
231
+        if ($named === [])
232
+        {
208 233
             // No unknown argument names exist.
209 234
             return $passed;
210 235
         }
@@ -214,11 +239,14 @@  discard block
 block discarded – undo
214 239
         $badArgName = key($named);
215 240
 
216 241
         // Check collision with positional arguments.
217
-        foreach ($parameters as $i => $parameter) {
218
-            if ($i >= $namedArgsBegin) {
242
+        foreach ($parameters as $i => $parameter)
243
+        {
244
+            if ($i >= $namedArgsBegin)
245
+            {
219 246
                 break;
220 247
             }
221
-            if ($parameter->getName() === $badArgName) {
248
+            if ($parameter->getName() === $badArgName)
249
+            {
222 250
                 // The named argument overwrites a positional argument.
223 251
                 $message = \sprintf(self::ERROR_OVERWRITE_ARGUMENT, $badArgName);
224 252
                 throw new \BadMethodCallException($message);
@@ -226,7 +254,8 @@  discard block
 block discarded – undo
226 254
         }
227 255
 
228 256
         // Special handling if a variadic parameter is present.
229
-        if ($variadicParameter !== null) {
257
+        if ($variadicParameter !== null)
258
+        {
230 259
             // The last parameter is variadic.
231 260
             // Since PHP 8+, variadic parameters can consume named arguments.
232 261
             // However, this code only runs if PHP < 8.
Please login to merge, or discard this patch.