More fixes

Author: danog

docs

@@ -32,19 +32,19 @@ final class Ast implements BuildMode
 {
     /** @var array<string, array{name: string, type: string}> */
     public array $stored = [];
-    /** @var array<string, true> */
+    /** @var array<string, string> */
     public array $storedNames = [];
     public int $storedFlags = 0;
 
     public ?string $curKey = null;
 
     private array $output = [];
-    private array $outputSchema = [];
     private ?string $needsParent = null;
 
     public function __construct(
         public readonly bool $allowBackrefs,
         public readonly bool $allowUnpacking,
+        private array $outputSchema = []
     ) {
     }
 
@@ -62,6 +62,15 @@ public function getOutput(): string
         return $serialized;
     }
 
+    private static function stringifySchema(string $constructor, array $params): string
+    {
+        $paramsStr = "$constructor ";
+        foreach ($params as $name => $type) {
+            $paramsStr .= "$name:$type ";
+        }
+        $paramsStr .= '= FileSource;';
+        return $paramsStr;
+    }
     public function addNode(TLContext $ctx, ?array $action = null, ?string $why = null): void
     {
         $out = [
@@ -80,24 +89,38 @@ public function addNode(TLContext $ctx, ?array $action = null, ?string $why = nu
 
             $constructor = $action['stored_constructor'];
 
-            $paramsStr = $this->storedFlags ? "$constructor flags:# " : "$constructor ";
-            foreach ($this->stored as $param) {
-                $paramsStr .= "{$param['name']}:{$param['type']} ";
+            $names = $this->storedNames;
+            if ($this->storedFlags) {
+                $names['flags'] = '#';
             }
-            $paramsStr .= '= FileSource;';
-
-            $this->storedFlags = 0;
-            $this->stored = [];
-            $this->storedNames = [];
 
             if (isset($this->outputSchema[$constructor])) {
-                if ($this->outputSchema[$constructor] !== $paramsStr) {
-                    echo("Existing schema for $constructor ({$this->outputSchema[$constructor]}) does not match newly generated schema $paramsStr\n");
+                foreach ($this->outputSchema[$constructor] as $name => $type) {
+                    if (isset($names[$name])) {
+                        if ($names[$name] === $type) {
+                            unset($names[$name]);
+                        } else {
+                            throw new AssertionError("Type mismatch for $constructor.$name: have {$names[$name]}, need $type");
+                        }
+                    } else if (str_starts_with($type, 'flags.')) {
+                        if ($this->storedFlags) {
+                            throw new AssertionError("Have conflicting flag $constructor.$name:$type; new schema is ".self::stringifySchema($constructor, $names));
+                        }
+                    } elseif ($name !== 'flags') {
+                        throw new AssertionError("Missing pre-existing parameter $constructor.$name for $constructor");
+                    }
+                }
+                foreach ($names as $name => $type) {
+                    throw new AssertionError("Leftover parameter $constructor.$name:$type for $constructor");
                 }
             } else {
-                $this->outputSchema[$constructor] = $paramsStr;
+                $this->outputSchema[$constructor] = $names;
             }
 
+
+            $this->storedFlags = 0;
+            $this->stored = [];
+            $this->storedNames = [];
             Assert::null($why);
         } elseif ($why !== null) {
             $out['action'] = ['_' => 'noOp', 'why' => $why];

schemas

@@ -58,7 +58,7 @@ public function getType(TLContext $tl): string
 
     public function build(TLContext $tl): void
     {
-        Assert::eq($this->peer->getType($tl), 'Peer');
+        Assert::eq($this->peer->getType($tl), 'InputPeer');
         Assert::eq($this->id->getType($tl), 'int');
         if ($this->fromScheduled !== null) {
             Assert::eq($this->fromScheduled->getType($tl), 'true');

tools/FileRefExtractor/BuildMode/Ast.php

@@ -160,7 +160,7 @@ public function buildPath(TLContext $tl, string $extractor): array
             if (isset($tl->buildMode->storedNames[$name])) {
                 throw new AssertionError("Need custom name (already have $name) for ".json_encode($this->path));
             }
-            $tl->buildMode->storedNames[$name] = true;
+            $tl->buildMode->storedNames[$name] = $type;
             $tl->buildMode->stored[$serialized] = [
                 'name' => $name,
                 'type' => $type,

tools/FileRefExtractor/Ops/GetMessageOp.php

@@ -43,7 +43,7 @@
         continue;
     }
     $locations[$constructor][] = new GetMessageOp(
-        new CopyOp([[$constructor, 'peer_id']]),
+        new GetInputPeerOp(new Path([[$constructor, 'peer_id']])),
         new CopyOp([[$constructor, 'id']]),
         $constructor === 'message' ? new CopyOp([[$constructor, 'from_scheduled', Path::FLAG_PASSTHROUGH]]) : null,
         'fileSourceMessage',
@@ -493,9 +493,19 @@
     unset($stack[$pos]);
 };
 
+
+$pre = [
+    'fileSourceMessage' => [
+        'flags' => '#',
+        'from_scheduled' => 'flags.0?true',
+        'peer' => 'long',
+        'id' => 'int'
+    ]
+];
+
 $validated = [];
 
-$tmp = new Ast(allowBackrefs: true, allowUnpacking: true);
+$tmp = new Ast(allowBackrefs: true, allowUnpacking: true, outputSchema: $pre);
 foreach (['Document' => 'document', 'Photo' => 'photo'] as $type => $constructor) {
     $stack = [[$constructor, 'file_reference']];
     $stackTypes = [$type => 1];
@@ -583,7 +593,7 @@ static function (array $stack) use ($locations, $TL, $tmp, &$validated, $storyMe
     throw new AssertionError("Leftover ops!");
 }
 
-$output = new Ast(allowBackrefs: true, allowUnpacking: false);
+$output = new Ast(allowBackrefs: true, allowUnpacking: false, outputSchema: $pre);
 foreach ($locations as $constructor => $ops) {
     foreach ($ops as $idx => $op) {
         $op->build(new TLContext($TL, $output, $constructor, $TL->isConstructor($constructor)));