From 3eb5e3d02806872ae07c2c85080e12ecc83d1164 Mon Sep 17 00:00:00 2001
From: Jephte Clain <Jephte.Clain@univ-reunion.fr>
Date: Wed, 11 Sep 2024 21:05:15 +0400
Subject: [PATCH] modifs.mineures sans commentaires

---
 .idea/php-test-framework.xml |  14 +++
 tests/wip/php/funcTest.php   | 211 ++++++++++++++++++++++++++++++++---
 wip/php/func.php             | 145 +++++++++++++++++++-----
 3 files changed, 327 insertions(+), 43 deletions(-)
 create mode 100644 .idea/php-test-framework.xml

diff --git a/.idea/php-test-framework.xml b/.idea/php-test-framework.xml
new file mode 100644
index 0000000..c092999
--- /dev/null
+++ b/.idea/php-test-framework.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="PhpTestFrameworkVersionCache">
+    <tools_cache>
+      <tool tool_name="PHPUnit">
+        <cache>
+          <versions>
+            <info id="Local/vendor/autoload.php" version="9.6.20" />
+          </versions>
+        </cache>
+      </tool>
+    </tools_cache>
+  </component>
+</project>
\ No newline at end of file
diff --git a/tests/wip/php/funcTest.php b/tests/wip/php/funcTest.php
index 68010a3..540c67c 100644
--- a/tests/wip/php/funcTest.php
+++ b/tests/wip/php/funcTest.php
@@ -225,7 +225,7 @@ namespace nur\sery\wip\php {
       $func = [false, "tmissing"]; self::assertTrue(func::verifix_simple($func, false));
       self::assertSame([false, "tmissing"], $func);
     }
-
+    
     function testStatic() {
       # scalaires
       $func = null; self::assertFalse(func::verifix_static($func, true, $bound));
@@ -347,25 +347,25 @@ namespace nur\sery\wip\php {
       $func = [null, "->tmissing"]; self::assertFalse(func::verifix_static($func, true, $bound));
       $func = [null, "->tmissing"]; self::assertFalse(func::verifix_static($func, false, $bound));
 
-      $func = [false, "tsimple"]; self::assertTrue(func::verifix_static($func, true, $bound));
-      $func = [false, "tsimple"]; self::assertTrue(func::verifix_static($func, false, $bound));
+      $func = [false, "tsimple"]; self::assertFalse(func::verifix_static($func, False, $bound));
+      $func = [false, "tsimple"]; self::assertFalse(func::verifix_static($func, false, $bound));
 
-      $func = [false, 'nur\sery\wip\php\impl\ntsimple']; self::assertFalse(func::verifix_static($func, true, $bound));
+      $func = [false, 'nur\sery\wip\php\impl\ntsimple']; self::assertFalse(func::verifix_static($func, False, $bound));
       $func = [false, 'nur\sery\wip\php\impl\ntsimple']; self::assertFalse(func::verifix_static($func, false, $bound));
 
-      $func = [false, "tmissing"]; self::assertTrue(func::verifix_static($func, true, $bound));
-      $func = [false, "tmissing"]; self::assertTrue(func::verifix_static($func, false, $bound));
+      $func = [false, "tmissing"]; self::assertFalse(func::verifix_static($func, False, $bound));
+      $func = [false, "tmissing"]; self::assertFalse(func::verifix_static($func, false, $bound));
 
-      $func = [false, "::tstatic"]; self::assertTrue(func::verifix_static($func, true, $bound));
-      $func = [false, "::tstatic"]; self::assertTrue(func::verifix_static($func, false, $bound));
+      $func = [false, "::tstatic"]; self::assertFalse(func::verifix_static($func, False, $bound));
+      $func = [false, "::tstatic"]; self::assertFalse(func::verifix_static($func, false, $bound));
 
-      $func = [false, "->tmethod"]; self::assertFalse(func::verifix_static($func, true, $bound));
+      $func = [false, "->tmethod"]; self::assertFalse(func::verifix_static($func, False, $bound));
       $func = [false, "->tmethod"]; self::assertFalse(func::verifix_static($func, false, $bound));
 
-      $func = [false, "::tmissing"]; self::assertTrue(func::verifix_static($func, true, $bound));
-      $func = [false, "::tmissing"]; self::assertTrue(func::verifix_static($func, false, $bound));
+      $func = [false, "::tmissing"]; self::assertFalse(func::verifix_static($func, False, $bound));
+      $func = [false, "::tmissing"]; self::assertFalse(func::verifix_static($func, false, $bound));
 
-      $func = [false, "->tmissing"]; self::assertFalse(func::verifix_static($func, true, $bound));
+      $func = [false, "->tmissing"]; self::assertFalse(func::verifix_static($func, False, $bound));
       $func = [false, "->tmissing"]; self::assertFalse(func::verifix_static($func, false, $bound));
 
       $func = ["", "tsimple"]; self::assertTrue(func::verifix_static($func, true, $bound));
@@ -411,8 +411,193 @@ namespace nur\sery\wip\php {
       $func = [MyClass::class, "->tmissing"]; self::assertFalse(func::verifix_static($func, false, $bound));
     }
 
-    function testStaticResults() {
+    //function testStaticResults() {}
 
+    function testMethod() {
+      # scalaires
+      $func = null; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = null; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = false; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = false; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = ""; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = ""; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = "::"; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = "::"; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = "->"; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = "->"; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = "tsimple"; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = "tsimple"; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = 'nur\sery\wip\php\impl\ntsimple'; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = 'nur\sery\wip\php\impl\ntsimple'; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = 'tmissing'; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = 'tmissing'; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = "::tmethod"; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = "::tmethod"; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = "->tmethod"; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = "->tmethod"; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = "::tmissing"; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = "::tmissing"; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = "->tmissing"; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = "->tmissing"; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = MyClass::class."::tmethod"; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = MyClass::class."::tmethod"; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = MyClass::class."->tmethod"; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = MyClass::class."->tmethod"; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = MyClass::class."::tmissing"; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = MyClass::class."::tmissing"; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = MyClass::class."->tmissing"; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = MyClass::class."->tmissing"; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      # tableaux avec un seul scalaire
+      $func = []; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = []; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [null]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [null]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [false]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [false]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [""]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [""]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = ["::"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = ["::"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = ["->"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = ["->"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = ["tsimple"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = ["tsimple"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = ['nur\sery\wip\php\impl\ntsimple']; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = ['nur\sery\wip\php\impl\ntsimple']; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = ["::tmethod"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = ["::tmethod"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = ["->tmethod"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = ["->tmethod"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = ["::tmissing"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = ["::tmissing"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = ["->tmissing"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = ["->tmissing"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = [MyClass::class."::tmethod"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [MyClass::class."::tmethod"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [MyClass::class."->tmethod"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = [MyClass::class."->tmethod"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = [MyClass::class."::tmissing"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [MyClass::class."::tmissing"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [MyClass::class."->tmissing"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [MyClass::class."->tmissing"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      # tableaux avec deux scalaires
+      $func = [null, "tsimple"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = [null, "tsimple"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = [null, 'nur\sery\wip\php\impl\ntsimple']; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [null, 'nur\sery\wip\php\impl\ntsimple']; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [null, "tmissing"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = [null, "tmissing"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = [null, "::tmethod"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [null, "::tmethod"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [null, "->tmethod"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = [null, "->tmethod"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = [null, "::tmissing"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [null, "::tmissing"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [null, "->tmissing"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = [null, "->tmissing"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = [false, "tsimple"]; self::assertFalse(func::verifix_method($func, False, $bound));
+      $func = [false, "tsimple"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [false, 'nur\sery\wip\php\impl\ntsimple']; self::assertFalse(func::verifix_method($func, False, $bound));
+      $func = [false, 'nur\sery\wip\php\impl\ntsimple']; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [false, "tmissing"]; self::assertFalse(func::verifix_method($func, False, $bound));
+      $func = [false, "tmissing"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [false, "::tmethod"]; self::assertFalse(func::verifix_method($func, False, $bound));
+      $func = [false, "::tmethod"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [false, "->tmethod"]; self::assertFalse(func::verifix_method($func, False, $bound));
+      $func = [false, "->tmethod"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [false, "::tmissing"]; self::assertFalse(func::verifix_method($func, False, $bound));
+      $func = [false, "::tmissing"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [false, "->tmissing"]; self::assertFalse(func::verifix_method($func, False, $bound));
+      $func = [false, "->tmissing"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = ["", "tsimple"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = ["", "tsimple"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = ["", 'nur\sery\wip\php\impl\ntsimple']; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = ["", 'nur\sery\wip\php\impl\ntsimple']; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = ["", "tmissing"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = ["", "tmissing"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = ["", "::tmethod"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = ["", "::tmethod"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = ["", "->tmethod"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = ["", "->tmethod"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = ["", "::tmissing"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = ["", "::tmissing"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = ["", "->tmissing"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = ["", "->tmissing"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = [MyClass::class, "tmethod"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = [MyClass::class, "tmethod"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = [MyClass::class, "::tmethod"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [MyClass::class, "::tmethod"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [MyClass::class, "tmethod"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = [MyClass::class, "tmethod"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = [MyClass::class, "->tmethod"]; self::assertTrue(func::verifix_method($func, true, $bound));
+      $func = [MyClass::class, "->tmethod"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = [MyClass::class, "tmissing"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [MyClass::class, "tmissing"]; self::assertTrue(func::verifix_method($func, false, $bound));
+
+      $func = [MyClass::class, "::tmissing"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [MyClass::class, "::tmissing"]; self::assertFalse(func::verifix_method($func, false, $bound));
+
+      $func = [MyClass::class, "->tmissing"]; self::assertFalse(func::verifix_method($func, true, $bound));
+      $func = [MyClass::class, "->tmissing"]; self::assertTrue(func::verifix_method($func, false, $bound));
     }
+
+    //function testMethodResults() {}
   }
 }
diff --git a/wip/php/func.php b/wip/php/func.php
index ba99f46..004e305 100644
--- a/wip/php/func.php
+++ b/wip/php/func.php
@@ -75,68 +75,69 @@ class func {
     return true;
   }
 
-  private static function parse_class_m(?string $cm, ?string &$c, ?string &$m): bool {
-    if (self::is_invalid($cm) || self::parse_method($cm)) return false;
-    $pos = strpos($cm, "::");
+  private static function parse_class_s(?string $cs, ?string &$c, ?string &$s): bool {
+    if (self::is_invalid($cs) || self::parse_method($cs)) return false;
+    $pos = strpos($cs, "::");
     if ($pos === false) return false;
     if ($pos === 0) return false;
-    $tmpc = substr($cm, 0, $pos);
-    $cm = substr($cm, $pos + 2);
-    if (self::is_nfunction($cm)) return false;
-    [$c, $m] = [$tmpc, cv::vn($cm)];
+    $tmpc = substr($cs, 0, $pos);
+    $cs = substr($cs, $pos + 2);
+    if (self::is_nfunction($cs)) return false;
+    [$c, $s] = [$tmpc, cv::vn($cs)];
     return true;
   }
 
-  private static function parse_c_method(?string $cm, ?string &$c, ?string &$m, ?bool &$bound): bool {
-    if (self::is_invalid($cm) || self::parse_method($cm)) return false;
-    $pos = strpos($cm, "::");
+  private static function parse_c_static(?string $cs, ?string &$c, ?string &$s, ?bool &$bound): bool {
+    if (self::is_invalid($cs) || self::parse_method($cs)) return false;
+    $pos = strpos($cs, "::");
     if ($pos === false) return false;
-    if ($pos == strlen($cm) - 2) return false;
+    if ($pos == strlen($cs) - 2) return false;
     if ($pos > 0) {
-      $tmpc = substr($cm, 0, $pos);
+      $tmpc = substr($cs, 0, $pos);
       $bound = true;
     } else {
       $tmpc = null;
       $bound = false;
     }
-    $cm = substr($cm, $pos + 2);
-    if (self::is_nfunction($cm)) return false;
-    [$c, $m] = [$tmpc, cv::vn($cm)];
+    $cs = substr($cs, $pos + 2);
+    if (self::is_nfunction($cs)) return false;
+    [$c, $s] = [$tmpc, cv::vn($cs)];
     return true;
   }
 
   /**
-   * vérifier que $func est une fonction statique, et la normaliser le cas
-   * échéant. retourner true si c'est une fonction statique, false sinon
+   * vérifier que $func est une méthode statique, et la normaliser le cas
+   * échéant. retourner true si c'est une méthode statique, false sinon
    *
    * les formes suivantes sont supportées (XXX étant null ou n'importe quelle
-   * valeur scalaire de n'importe quel type)
+   * valeur scalaire de n'importe quel type sauf false)
    * - "XXX::function"
    * - ["XXX::function", ...$args]
    * - [XXX, "::function", ...$args]
    * - [XXX, "function", ...$args] c'est la forme normalisée
    *
-   * Si XXX est une classe, la fonction statique est liée. sinon, elle doit être
+   * Si XXX est une classe, la méthode statique est liée. sinon, elle doit être
    * liée à une classe avant d'être utilisée
    *
-   * @param bool $strict vérifier l'inexistence de la classe et l'existence de
-   * la fonction (ne pas uniquement faire une vérification syntaxique)
+   * @param bool $strict vérifier l'existence de la classe et de la méthode si
+   * la méthode est liée (ne pas uniquement faire une vérification syntaxique)
    */
   static function verifix_static(&$func, bool $strict=true, ?bool &$bound=null): bool {
     if (is_string($func)) {
-      if (!self::parse_c_method($func, $c, $f, $bound)) return false;
+      if (!self::parse_c_static($func, $c, $f, $bound)) return false;
       $func = [$c, $f];
     } elseif (is_array($func)) {
       if (!array_key_exists(0, $func)) return false;
       $c = $func[0];
-      if (self::parse_class_m($c, $c, $f)) {
+      if ($c === false) return false;
+      if (self::parse_class_s($c, $c, $f)) {
         $func[0] = $c;
         if ($f !== null) {
           # ["class::method"] --> ["class", "method"]
           array_splice($func, 1, 0, [$f]);
         }
         $bound = true;
-      } elseif (self::parse_c_method($c, $c, $f, $bound)) {
+      } elseif (self::parse_c_static($c, $c, $f, $bound)) {
           # ["::method"] --> [null, "method"]
           array_splice($func, 0, 0, [null]);
           $func[1] = $f;
@@ -149,7 +150,7 @@ class func {
       if (!array_key_exists(1, $func)) return false;
       $f = $func[1];
       if (!is_string($f)) return false;
-      if (self::parse_c_method($f, $rc, $f, $rbound)) {
+      if (self::parse_c_static($f, $rc, $f, $rbound)) {
         if ($rc !== null && $c === null) {
           $c = $rc;
           $bound = $rbound;
@@ -170,16 +171,100 @@ class func {
     return true;
   }
 
-  static function verifix_method(&$func): bool {
+  private static function parse_class_m(?string $cm, ?string &$c, ?string &$m): bool {
+    if (self::is_invalid($cm) || self::parse_static($cm)) return false;
+    $pos = strpos($cm, "->");
+    if ($pos === false) return false;
+    if ($pos === 0) return false;
+    $tmpc = substr($cm, 0, $pos);
+    $cm = substr($cm, $pos + 2);
+    if (self::is_nfunction($cm)) return false;
+    [$c, $m] = [$tmpc, cv::vn($cm)];
+    return true;
+  }
+
+  private static function parse_c_method(?string $cm, ?string &$c, ?string &$m, ?bool &$bound): bool {
+    if (self::is_invalid($cm) || self::parse_static($cm)) return false;
+    $pos = strpos($cm, "->");
+    if ($pos === false) return false;
+    if ($pos == strlen($cm) - 2) return false;
+    if ($pos > 0) {
+      $tmpc = substr($cm, 0, $pos);
+      $bound = true;
+    } else {
+      $tmpc = null;
+      $bound = false;
+    }
+    $cm = substr($cm, $pos + 2);
+    if (self::is_nfunction($cm)) return false;
+    [$c, $m] = [$tmpc, cv::vn($cm)];
+    return true;
+  }
+
+  /**
+   * vérifier que $func est une méthode non statique, et la normaliser le cas
+   * échéant. retourner true si c'est une méthode non statique, false sinon
+   *
+   * les formes suivantes sont supportées (XXX étant null ou n'importe quelle
+   * valeur scalaire de n'importe quel type sauf false)
+   * - "XXX->function"
+   * - ["XXX->function", ...$args]
+   * - [XXX, "->function", ...$args]
+   * - [XXX, "function", ...$args] c'est la forme normalisée
+   *
+   * Si XXX est une classe, la méthode est liée. sinon, elle doit être liée à un
+   * objet avant d'être utilisée
+   *
+   * @param bool $strict vérifier l'existence de la classe et de la méthode si
+   * la méthode est liée (ne pas uniquement faire une vérification syntaxique)
+   */
+  static function verifix_method(&$func, bool $strict=true, ?bool &$bound=null): bool {
     if (is_string($func)) {
-      
-      return true;
+      if (!self::parse_c_method($func, $c, $f, $bound)) return false;
+      $func = [$c, $f];
     } elseif (is_array($func)) {
-      
-      return true;
+      if (!array_key_exists(0, $func)) return false;
+      $c = $func[0];
+      if ($c === false) return false;
+      if (self::parse_class_m($c, $c, $f)) {
+        $func[0] = $c;
+        if ($f !== null) {
+          # ["class->method"] --> ["class", "method"]
+          array_splice($func, 1, 0, [$f]);
+        }
+        $bound = true;
+      } elseif (self::parse_c_method($c, $c, $f, $bound)) {
+        # ["->method"] --> [null, "method"]
+        array_splice($func, 0, 0, [null]);
+        $func[1] = $f;
+      } else {
+        if (self::is_invalid($c)) $c = null;
+        $func[0] = $c;
+        $bound = is_string($c);
+      }
+      #
+      if (!array_key_exists(1, $func)) return false;
+      $f = $func[1];
+      if (!is_string($f)) return false;
+      if (self::parse_c_method($f, $rc, $f, $rbound)) {
+        if ($rc !== null && $c === null) {
+          $c = $rc;
+          $bound = $rbound;
+        }
+      } elseif (self::is_invalid($f)) {
+        return false;
+      } elseif (self::is_nfunction($f)) {
+        return false;
+      } elseif (self::parse_static($f)) {
+        return false;
+      } elseif (self::parse_method($f)) {
+      }
+      $func[1] = $f;
     } else {
       return false;
     }
+    if ($strict && $bound && !method_exists($c, $f)) return false;
+    return true;
   }
   
   static function verifix_cons(&$func): bool {