Add tests for 'from' syntax and its usage in various contexts

Author: str

Zend/tests/use_from_as_function_name.phpt

@@ -0,0 +1,17 @@
+--TEST--
+`from` remains usable as function name (soft keyword)
+--FILE--
+<?php
+
+namespace Test;
+
+function from(): void
+{
+    echo "ok\n";
+}
+
+from();
+
+?>
+--EXPECT--
+ok

Zend/tests/use_from_as_method_name.phpt

@@ -0,0 +1,18 @@
+--TEST--
+use-from: method name 'from' remains valid
+--FILE--
+<?php
+namespace DBTest;
+
+class DB {
+    public function from($table) {
+        echo "from->{$table}\n";
+    }
+}
+
+$db = new DB();
+$db->from('users');
+
+?>
+--EXPECT--
+from->users

Zend/tests/use_from_group.phpt

@@ -0,0 +1,40 @@
+--TEST--
+Grouped 'from' syntax test
+--FILE--
+<?php
+
+namespace My\Full {
+    class ClassA { public static function id(){ return "A"; } }
+    class ClassB { public static function id(){ return "B"; } }
+    class ClassC { public static function id(){ return "C"; } }
+}
+
+namespace {
+    // Grouped form with 'from' after braces
+    use {ClassA, ClassB, ClassC as C} from My\Full;
+    echo ClassA::id() . "\n";
+    echo ClassB::id() . "\n";
+    echo C::id() . "\n";
+
+    // Equivalent grouped form (existing syntax) for comparison
+    use My\Full\{ClassA as A2, ClassB as B2, ClassC as C2};
+    echo A2::id() . "\n";
+    echo B2::id() . "\n";
+    echo C2::id() . "\n";
+
+    // Inline aliases and fully-qualified namespace
+    use {ClassA as AA, ClassB as BB} from \My\Full;
+    echo AA::id() . "\n";
+    echo BB::id() . "\n";
+}
+
+?>
+--EXPECT--
+A
+B
+C
+A
+B
+C
+A
+B

Zend/tests/use_from_manual_examples.phpt

@@ -0,0 +1,102 @@
+--TEST--
+use ... from ... mirrors manual aliasing/importing examples
+--FILE--
+<?php
+
+namespace My\Full;
+
+class Classname {}
+class NSname {}
+
+namespace My\Full\NSname\subns;
+
+function func(): void
+{
+    echo "NSname subns func\n";
+}
+
+namespace some\namespace;
+
+class ClassA {}
+class ClassB {}
+class ClassC {}
+
+function fn_a(): void
+{
+    echo "fn_a\n";
+}
+
+function fn_b(): void
+{
+    echo "fn_b\n";
+}
+
+function fn_c(): void
+{
+    echo "fn_c\n";
+}
+
+const ConstA = "ConstA";
+const ConstB = "ConstB";
+const ConstC = "ConstC";
+
+namespace Mizo\Web\Php;
+
+class WebSite {}
+
+namespace Mizo\Web\JS;
+
+function printTotal(): void
+{
+    echo "printTotal\n";
+}
+
+const BUAIKUM = "BUAIKUM";
+
+namespace foo;
+
+use Classname from My\Full as Another, NSname from My\Full;
+use {ClassA, ClassB, ClassC as C} from some\namespace;
+use function {fn_a, fn_b, fn_c} from some\namespace;
+use const {ConstA, ConstB, ConstC} from some\namespace;
+use {Php\WebSite, function JS\printTotal, const JS\BUAIKUM} from Mizo\Web;
+
+new Another();
+echo "Another OK\n";
+
+NSname\subns\func();
+echo "NSname alias OK\n";
+
+new ClassA();
+new ClassB();
+new C();
+echo "Group classes OK\n";
+
+fn_a();
+fn_b();
+fn_c();
+echo "Group functions OK\n";
+
+echo ConstA, " ", ConstB, " ", ConstC, "\n";
+echo "Group consts OK\n";
+
+new WebSite();
+printTotal();
+echo BUAIKUM, "\n";
+echo "Mixed group OK\n";
+
+?>
+--EXPECT--
+Another OK
+NSname subns func
+NSname alias OK
+Group classes OK
+fn_a
+fn_b
+fn_c
+Group functions OK
+ConstA ConstB ConstC
+Group consts OK
+printTotal
+BUAIKUM
+Mixed group OK

Zend/tests/use_from_mixed_group_equivalence.phpt

@@ -0,0 +1,39 @@
+--TEST--
+use-from mixed-group equivalence
+--FILE--
+<?php
+namespace P {
+    class A {
+        public static function who() {
+            echo "A\n";
+        }
+    }
+
+    namespace B {
+        function fn() {
+            echo "B::fn\n";
+        }
+    }
+}
+
+namespace TestFrom {
+    use {A, function B\fn} from P;
+    A::who();
+    fn();
+}
+
+echo "----\n";
+
+namespace TestPrefix {
+    use P\{A, function B\fn};
+    A::who();
+    fn();
+}
+
+?>
+--EXPECT--
+A
+B::fn
+----
+A
+B::fn

Zend/tests/use_from_named_argument.phpt

@@ -0,0 +1,9 @@
+--TEST--
+named argument named 'from' remains usable
+--FILE--
+<?php
+function f($from) { echo $from; }
+f(from: 42);
+?>
+--EXPECT--
+42

Zend/tests/use_from_static_method.phpt

@@ -0,0 +1,11 @@
+--TEST--
+static method named 'from' remains usable
+--FILE--
+<?php
+class C {
+    public static function from($x) { echo $x; }
+}
+C::from(123);
+?>
+--EXPECT--
+123

Zend/tests/use_from_syntax.phpt

@@ -0,0 +1,33 @@
+--TEST--
+use SomeClass from Namespace syntax
+--FILE--
+<?php
+
+namespace Test {
+    class MyClass {
+        public static function greet() {
+            return "Hello from Test\\MyClass";
+        }
+    }
+}
+
+namespace Foo\Bar {
+    class Baz {
+        public static function info() {
+            return "Foo\\Bar\\Baz";
+        }
+    }
+}
+
+namespace {
+    use MyClass from Test;
+    use Baz from Foo\Bar;
+
+    echo MyClass::greet() . "\n";
+    echo Baz::info() . "\n";
+}
+
+?>
+--EXPECT--
+Hello from Test\MyClass
+Foo\Bar\Baz

Zend/tests/use_from_syntax_aliases.phpt

@@ -0,0 +1,35 @@
+--TEST--
+use ... as/alias ordering tests
+--FILE--
+<?php
+
+namespace My\Full {
+    class Classname {
+        public static function whoami() { return "My\\Full\\Classname"; }
+    }
+}
+
+namespace {
+    // 'from' before 'as'
+    use Classname from My\Full as Other;
+    echo Other::whoami() . "\n";
+
+    // 'as' before 'from'
+    use Classname as Other2 from My\Full;
+    echo Other2::whoami() . "\n";
+
+    // Fully-qualified namespace with alias after
+    use Classname from \My\Full as Fully;
+    echo Fully::whoami() . "\n";
+
+    // Fully-qualified namespace with 'as' before 'from'
+    use Classname as Fully2 from \My\Full;
+    echo Fully2::whoami() . "\n";
+}
+
+?>
+--EXPECT--
+My\Full\Classname
+My\Full\Classname
+My\Full\Classname
+My\Full\Classname

Zend/tests/use_from_syntax_comprehensive.phpt

@@ -0,0 +1,58 @@
+--TEST--
+use SomeClass from Namespace - comprehensive test
+--FILE--
+<?php
+
+// Define classes in different namespaces
+namespace Vendor\Package\SubPackage {
+    class MyService {
+        public static function getName() {
+            return "Vendor\\Package\\SubPackage\\MyService";
+        }
+    }
+}
+
+namespace App\Models {
+    class User {
+        public static function getName() {
+            return "App\\Models\\User";
+        }
+    }
+}
+
+namespace Root {
+    class Helper {
+        public static function getName() {
+            return "Root\\Helper";
+        }
+    }
+}
+
+// Use the new "from" syntax
+namespace {
+    // Import with qualified namespace
+    use MyService from Vendor\Package\SubPackage;
+    echo MyService::getName() . "\n";
+
+    // Import with fully-qualified namespace
+    use User from \App\Models;
+    echo User::getName() . "\n";
+
+    // Import from simple namespace
+    use Helper from Root;
+    echo Helper::getName() . "\n";
+
+    // Verify classes work (the full class names exist, not the aliases)
+    echo class_exists('Vendor\\Package\\SubPackage\\MyService') ? "Full class name works\n" : "FAIL\n";
+    echo class_exists('App\\Models\\User') ? "Full class name works\n" : "FAIL\n";
+    echo class_exists('Root\\Helper') ? "Full class name works\n" : "FAIL\n";
+}
+
+?>
+--EXPECT--
+Vendor\Package\SubPackage\MyService
+App\Models\User
+Root\Helper
+Full class name works
+Full class name works
+Full class name works