Ensure there are no conflicts between schemas

Author: danog

schemas

@@ -1,5 +1,8 @@
 boolFalse#bc799737 = Bool;
 boolTrue#997275b5 = Bool;
+true#3fedd339 = True;
+
+vector#1cb5c415 {t:Type} # [ t ] = Vector t;
 
 // Root
 fileReferenceOrigins#ed01a4f1 db_schema:string db_schema_json:string locations:Vector<Location> origins:Vector<Origin> skipped:Vector<SkippedOrigin> actions:Vector<Action> = FileReferenceOrigins;

src/TL_file_ref_map_schema.tl

@@ -44,6 +44,7 @@ final class Ast implements BuildMode
     private ?string $needsParent = null;
 
     public function __construct(
+        private readonly array $blacklistedPredicates,
         public readonly bool $allowUnpacking,
         private array $outputSchema = []
     ) {
@@ -82,14 +83,14 @@ public function finalize(array $outgoingCons, array $incomingCons, string $refMa
                 'stored_constructor' => $cons,
             ];
         }
-        $dbSchema = '';
+        $dbSchema = "boolFalse#bc799737 = Bool;\nboolTrue#997275b5 = Bool;\ntrue#3fedd339 = True;\nvector#1cb5c415 {t:Type} # [ t ] = Vector t;\n\n";
         foreach ($fileIdCons as $cons => $_) {
-            $dbSchema .= self::stringifySchema($cons, ['id' => 'long'], "FileId")."\n";
+            $dbSchema .= $this->stringifySchema($cons, ['id' => 'long'], "FileId")."\n";
         }
         $dbSchema .= "\n";
 
         foreach ($this->outputSchema as $constructor => $params) {
-            $dbSchema .= self::stringifySchema($constructor, $params, "FileSource")."\n";
+            $dbSchema .= $this->stringifySchema($constructor, $params, "FileSource")."\n";
         }
         $dbSchemaJSON = (new TL(null))->toJson($dbSchema);
 
@@ -115,15 +116,25 @@ public function finalize(array $outgoingCons, array $incomingCons, string $refMa
         $s = $s->setOther(['filerefs' => __DIR__ . '/../../../src/TL_file_ref_map_schema.tl']);
         $TL = new TL((new ReflectionClass(MTProto::class))->newInstanceWithoutConstructor());
         $TL->init($s);
+
+        $json = $TL->toJson(__DIR__ . '/../../../src/TL_file_ref_map_schema.tl');
+        foreach ($json['constructors'] as $constructor) {
+            Assert::keyNotExists($this->blacklistedPredicates, $constructor['predicate'], "{$constructor['predicate']} is blacklisted and cannot be used in the schema");
+        }
+        foreach ($json['methods'] as $method) {
+            Assert::keyNotExists($this->blacklistedPredicates, $method['method'], "{$method['method']} is blacklisted and cannot be used in the schema");
+        }
+
         $serialized = $TL->serializeObject(['type' => 'FileReferenceOrigins'], $value, '');
         $valueDe = $TL->deserialize($serialized, ['type' => '', 'connection' => null, 'encrypted' => true]);
         Assert::true($value == $valueDe);
         file_put_contents($refMapFile, $serialized);
         file_put_contents($refMapFileJson, json_encode($valueDe, flags: JSON_THROW_ON_ERROR));
     }
 
-    private static function stringifySchema(string $constructor, array $params, string $cType): string
+    private function stringifySchema(string $constructor, array $params, string $cType): string
     {
+        Assert::keyNotExists($this->blacklistedPredicates, $constructor, "$constructor is blacklisted and cannot be used in the schema");
         $paramsStr = "$constructor ";
         foreach ($params as $name => $type) {
             Assert::notContains($type, 'InputPeer', "$constructor cannot contain InputPeer");
@@ -192,7 +203,7 @@ public function addNode(TLContext $ctx, ?array $action = null, ?string $why = nu
                     }
                 }
                 foreach ($stored as $name => ['type' => $type]) {
-                    throw new AssertionError("Leftover parameter $constructor.$name:$type for ".self::stringifySchema($constructor, $existing, 'FileSource'));
+                    throw new AssertionError("Leftover parameter $constructor.$name:$type for ".$this->stringifySchema($constructor, $existing, 'FileSource'));
                 }
             } else {
                 $types = [];

src/file_ref_map.dat

@@ -52,6 +52,10 @@ public static function generate(int|string $layer, string $inputSchema, string $
         $TL = new TL(null);
         $TL->init($schema);
 
+        $blacklistedPredicates = array_fill_keys(array_column($TL->getConstructors()->by_id, 'predicate'), true)
+            + array_fill_keys(array_column($TL->getMethods()->by_id, 'method'), true);
+        unset($blacklistedPredicates['boolTrue'], $blacklistedPredicates['boolFalse'], $blacklistedPredicates['true'], $blacklistedPredicates['vector']);
+
         $TL = new TLWrapper($TL);
         $locations = [];
         Logger::log("Generating file reference map for layer $layer...");
@@ -494,7 +498,7 @@ public static function generate(int|string $layer, string $inputSchema, string $
             }
         }
 
-        $tmp = new Ast(allowUnpacking: true, outputSchema: $pre);
+        $tmp = new Ast(blacklistedPredicates: $blacklistedPredicates, allowUnpacking: true, outputSchema: $pre);
         foreach ($incomingCons as $constructor => $_) {
             $type = ucfirst($constructor);
             $stack = [[$constructor, 'file_reference']];
@@ -583,7 +587,7 @@ static function (array $stack) use ($locations, $TL, $tmp, &$validated, $storyMe
             throw new AssertionError("Leftover ops!");
         }
 
-        $output = new Ast(allowUnpacking: false, outputSchema: $pre);
+        $output = new Ast(blacklistedPredicates: $blacklistedPredicates, allowUnpacking: false, outputSchema: $pre);
         foreach ($locations as $constructor => $ops) {
             foreach ($ops as $idx => $op) {
                 $op->build(new TLContext($TL, $output, $constructor, $TL->isConstructor($constructor)));