hey! this is a static git repo viewer. commit diffs, file history, older commits and other revisions won't load without javascript.

you are still able to view source files on branch tips, but the experience is degraded.

yum-mirror/slang

Making it easier to work with shaders

git clone https://git.yummers.dev/yum-mirror/slang

jarcherNVAdd record and replay support for IComponentType2 (#8215)a5e6ddd002025-08-21

1#include "json-consumer.h"
2
3#include "../../core/slang-io.h"
4#include "../../core/slang-string-util.h"
5#include "../util/emum-to-string.h"
6#include "../util/record-utility.h"
7#include "slang.h"
8
9namespace SlangRecord
10{
11#define SANITY_CHECK()  \
12    if (!m_isFileValid) \
13    return
14
15static inline void _writeIndent(Slang::StringBuilder& builder, int indent)
16{
17    for (int i = 0; i < indent; i++)
18    {
19        builder << "  ";
20    }
21}
22
23template<typename T>
24static inline void _writeString(Slang::StringBuilder& builder, int indent, T const& str)
25{
26    _writeIndent(builder, indent);
27    builder << str;
28}
29
30template<typename T, typename U>
31static inline void _writePair(
32    Slang::StringBuilder& builder,
33    int indent,
34    T const& name,
35    U const& value)
36{
37    _writeIndent(builder, indent);
38    builder << name << ": " << value << ",\n";
39}
40
41template<typename T, typename U>
42static inline void _writePairNoComma(
43    Slang::StringBuilder& builder,
44    int indent,
45    T const& name,
46    U const& value)
47{
48    _writeIndent(builder, indent);
49    builder << name << ": " << value << "\n";
50}
51
52class ScopeWritterForKey
53{
54public:
55    ScopeWritterForKey(
56        Slang::StringBuilder* pBuilder,
57        int* pIndent,
58        Slang::String const& keyName,
59        bool isOutterScope = true)
60        : m_pBuilder(pBuilder), m_pIndent(pIndent), m_isOutterScope(isOutterScope)
61    {
62        _writeString((*m_pBuilder), (*m_pIndent), keyName + ": {\n");
63        (*m_pIndent)++;
64    }
65
66    ~ScopeWritterForKey()
67    {
68        (*m_pIndent)--;
69
70        if (m_isOutterScope)
71            _writeString((*m_pBuilder), (*m_pIndent), "}\n");
72        else
73            _writeString((*m_pBuilder), (*m_pIndent), "},\n");
74    }
75
76private:
77    Slang::StringBuilder* m_pBuilder;
78    int* m_pIndent;
79    bool m_isOutterScope;
80};
81
82void CommonInterfaceWriter::getSession(ObjectID objectId, ObjectID outSessionId)
83{
84    Slang::StringBuilder builder;
85    int indent = 0;
86
87    Slang::String functionName = m_className;
88    functionName = functionName + "::getSession";
89
90    {
91        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
92        {
93            _writePair(
94                builder,
95                indent,
96                "this",
97                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
98            _writePairNoComma(
99                builder,
100                indent,
101                "retSession",
102                Slang::StringUtil::makeStringWithFormat("0x%llX", outSessionId));
103        }
104    }
105
106    m_fileStream.write(builder.begin(), builder.getLength());
107    m_fileStream.flush();
108}
109
110void CommonInterfaceWriter::getLayout(
111    ObjectID objectId,
112    SlangInt targetIndex,
113    ObjectID outDiagnosticsId,
114    ObjectID retProgramLayoutId)
115{
116    Slang::StringBuilder builder;
117    int indent = 0;
118
119    Slang::String functionName = m_className;
120    functionName = functionName + "::getLayout";
121
122    {
123        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
124        {
125            _writePair(
126                builder,
127                indent,
128                "this",
129                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
130            _writePair(builder, indent, "targetIndex", targetIndex);
131            _writePair(
132                builder,
133                indent,
134                "outDiagnostics",
135                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
136            _writePairNoComma(
137                builder,
138                indent,
139                "retProgramLayout",
140                Slang::StringUtil::makeStringWithFormat("0x%llX", retProgramLayoutId));
141        }
142    }
143
144    m_fileStream.write(builder.begin(), builder.getLength());
145    m_fileStream.flush();
146}
147
148void CommonInterfaceWriter::getEntryPointCode(
149    ObjectID objectId,
150    SlangInt entryPointIndex,
151    SlangInt targetIndex,
152    ObjectID outCodeId,
153    ObjectID outDiagnosticsId)
154{
155    Slang::StringBuilder builder;
156    int indent = 0;
157
158    Slang::String functionName = m_className;
159    functionName = functionName + "::getEntryPointCode";
160
161    {
162        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
163        {
164            _writePair(
165                builder,
166                indent,
167                "this",
168                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
169            _writePair(builder, indent, "entryPointIndex", entryPointIndex);
170            _writePair(builder, indent, "targetIndex", targetIndex);
171            _writePair(
172                builder,
173                indent,
174                "outCode",
175                Slang::StringUtil::makeStringWithFormat("0x%llX", outCodeId));
176            _writePairNoComma(
177                builder,
178                indent,
179                "outDiagnostics",
180                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
181        }
182    }
183
184    m_fileStream.write(builder.begin(), builder.getLength());
185    m_fileStream.flush();
186}
187
188void CommonInterfaceWriter::getTargetCode(
189    ObjectID objectId,
190    SlangInt targetIndex,
191    ObjectID outCodeId,
192    ObjectID outDiagnosticsId)
193{
194    Slang::StringBuilder builder;
195    int indent = 0;
196
197    Slang::String functionName = m_className;
198    functionName = functionName + "::getTargetCode";
199
200    {
201        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
202        {
203            _writePair(
204                builder,
205                indent,
206                "this",
207                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
208            _writePair(builder, indent, "targetIndex", targetIndex);
209            _writePair(
210                builder,
211                indent,
212                "outCode",
213                Slang::StringUtil::makeStringWithFormat("0x%llX", outCodeId));
214            _writePairNoComma(
215                builder,
216                indent,
217                "outDiagnostics",
218                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
219        }
220    }
221
222    m_fileStream.write(builder.begin(), builder.getLength());
223    m_fileStream.flush();
224}
225
226void CommonInterfaceWriter::getResultAsFileSystem(
227    ObjectID objectId,
228    SlangInt entryPointIndex,
229    SlangInt targetIndex,
230    ObjectID outFileSystemId)
231{
232    Slang::StringBuilder builder;
233    int indent = 0;
234
235    Slang::String functionName = m_className;
236    functionName = functionName + "::getResultAsFileSystem";
237
238    {
239        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
240        {
241            _writePair(
242                builder,
243                indent,
244                "this",
245                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
246            _writePair(builder, indent, "entryPointIndex", entryPointIndex);
247            _writePair(builder, indent, "targetIndex", targetIndex);
248            _writePairNoComma(
249                builder,
250                indent,
251                "outFileSystem",
252                Slang::StringUtil::makeStringWithFormat("0x%llX", outFileSystemId));
253        }
254    }
255
256    m_fileStream.write(builder.begin(), builder.getLength());
257    m_fileStream.flush();
258}
259
260void CommonInterfaceWriter::getEntryPointHash(
261    ObjectID objectId,
262    SlangInt entryPointIndex,
263    SlangInt targetIndex,
264    ObjectID outHashId)
265{
266    Slang::StringBuilder builder;
267    int indent = 0;
268
269    Slang::String functionName = m_className;
270    functionName = functionName + "::getEntryPointHash";
271
272    {
273        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
274        {
275            _writePair(
276                builder,
277                indent,
278                "this",
279                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
280            _writePair(builder, indent, "entryPointIndex", entryPointIndex);
281            _writePair(builder, indent, "targetIndex", targetIndex);
282            _writePairNoComma(
283                builder,
284                indent,
285                "outHash",
286                Slang::StringUtil::makeStringWithFormat("0x%llX", outHashId));
287        }
288    }
289
290    m_fileStream.write(builder.begin(), builder.getLength());
291    m_fileStream.flush();
292}
293
294void CommonInterfaceWriter::specialize(
295    ObjectID objectId,
296    slang::SpecializationArg const* specializationArgs,
297    SlangInt specializationArgCount,
298    ObjectID outSpecializedComponentTypeId,
299    ObjectID outDiagnosticsId)
300{
301    Slang::StringBuilder builder;
302    int indent = 0;
303
304    Slang::String functionName = m_className;
305    functionName = functionName + "::specialize";
306
307    {
308        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
309        {
310            _writePair(
311                builder,
312                indent,
313                "this",
314                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
315            if (specializationArgCount)
316            {
317                ScopeWritterForKey scopeWritterForArgs(
318                    &builder,
319                    &indent,
320                    "specializationArgs",
321                    false);
322                for (int i = 0; i < specializationArgCount; i++)
323                {
324                    bool isLastField = (i == specializationArgCount - 1);
325                    ScopeWritterForKey scopeWritterForArg(
326                        &builder,
327                        &indent,
328                        Slang::StringUtil::makeStringWithFormat("[%d]", i),
329                        isLastField);
330                    {
331                        _writePair(
332                            builder,
333                            indent,
334                            "kind",
335                            SpecializationArgKindToString(specializationArgs[i].kind));
336                        _writePairNoComma(
337                            builder,
338                            indent,
339                            "type",
340                            Slang::StringUtil::makeStringWithFormat(
341                                "0x%llX",
342                                specializationArgs[i].type));
343                    }
344                }
345            }
346            else
347            {
348                _writePair(builder, indent, "specializationArgs", "nullptr");
349            }
350            _writePair(builder, indent, "specializationArgCount", specializationArgCount);
351            _writePair(
352                builder,
353                indent,
354                "outSpecializedComponentType",
355                Slang::StringUtil::makeStringWithFormat("0x%llX", outSpecializedComponentTypeId));
356            _writePairNoComma(
357                builder,
358                indent,
359                "outSpecializedComponentType",
360                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
361        }
362    }
363
364    m_fileStream.write(builder.begin(), builder.getLength());
365    m_fileStream.flush();
366}
367
368void CommonInterfaceWriter::link(
369    ObjectID objectId,
370    ObjectID outLinkedComponentTypeId,
371    ObjectID outDiagnosticsId)
372{
373    Slang::StringBuilder builder;
374    int indent = 0;
375
376    Slang::String functionName = m_className;
377    functionName = functionName + "::link";
378
379    {
380        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
381        {
382            _writePair(
383                builder,
384                indent,
385                "this",
386                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
387            _writePair(
388                builder,
389                indent,
390                "outLinkedComponentType",
391                Slang::StringUtil::makeStringWithFormat("0x%llX", outLinkedComponentTypeId));
392            _writePairNoComma(
393                builder,
394                indent,
395                "outDiagnostics",
396                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
397        }
398    }
399
400    m_fileStream.write(builder.begin(), builder.getLength());
401    m_fileStream.flush();
402}
403
404void CommonInterfaceWriter::getEntryPointHostCallable(
405    ObjectID objectId,
406    int entryPointIndex,
407    int targetIndex,
408    ObjectID outSharedLibraryId,
409    ObjectID outDiagnosticsId)
410{
411    Slang::StringBuilder builder;
412    int indent = 0;
413
414    Slang::String functionName = m_className;
415    functionName = functionName + "::getEntryPointHostCallable";
416
417    {
418        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
419        {
420            _writePair(
421                builder,
422                indent,
423                "this",
424                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
425            _writePair(builder, indent, "entryPointIndex", entryPointIndex);
426            _writePair(builder, indent, "targetIndex", targetIndex);
427            _writePair(
428                builder,
429                indent,
430                "outSharedLibrary",
431                Slang::StringUtil::makeStringWithFormat("0x%llX", outSharedLibraryId));
432            _writePairNoComma(
433                builder,
434                indent,
435                "outDiagnostics",
436                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
437        }
438    }
439
440    m_fileStream.write(builder.begin(), builder.getLength());
441    m_fileStream.flush();
442}
443
444void CommonInterfaceWriter::renameEntryPoint(
445    ObjectID objectId,
446    const char* newName,
447    ObjectID outEntryPointId)
448{
449    Slang::StringBuilder builder;
450    int indent = 0;
451
452    Slang::String functionName = m_className;
453    functionName = functionName + "::renameEntryPoint";
454
455    {
456        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
457        {
458            _writePair(
459                builder,
460                indent,
461                "this",
462                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
463            _writePair(
464                builder,
465                indent,
466                "newName",
467                Slang::StringUtil::makeStringWithFormat(
468                    "\"%s\"",
469                    newName != nullptr ? newName : "nullptr"));
470            _writePairNoComma(
471                builder,
472                indent,
473                "outEntryPoint",
474                Slang::StringUtil::makeStringWithFormat("0x%llX", outEntryPointId));
475        }
476    }
477
478    m_fileStream.write(builder.begin(), builder.getLength());
479    m_fileStream.flush();
480}
481
482void CommonInterfaceWriter::linkWithOptions(
483    ObjectID objectId,
484    ObjectID outLinkedComponentTypeId,
485    uint32_t compilerOptionEntryCount,
486    slang::CompilerOptionEntry* compilerOptionEntries,
487    ObjectID outDiagnosticsId)
488{
489
490    Slang::StringBuilder builder;
491    int indent = 0;
492
493    Slang::String functionName = m_className;
494    functionName = functionName + "::linkWithOptions";
495
496    {
497        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
498        {
499
500            _writePair(
501                builder,
502                indent,
503                "this",
504                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
505            _writePair(builder, indent, "compilerOptionEntryCount", compilerOptionEntryCount);
506
507            JsonConsumer::_writeCompilerOptionEntryHelper(
508                builder,
509                indent,
510                compilerOptionEntries,
511                compilerOptionEntryCount);
512
513            _writePair(
514                builder,
515                indent,
516                "outLinkedComponentType",
517                Slang::StringUtil::makeStringWithFormat("0x%llX", outLinkedComponentTypeId));
518            _writePairNoComma(
519                builder,
520                indent,
521                "outDiagnostics",
522                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
523        }
524    }
525
526    m_fileStream.write(builder.begin(), builder.getLength());
527    m_fileStream.flush();
528}
529
530void CommonInterfaceWriter::getTargetCompileResult(
531    ObjectID objectId,
532    SlangInt targetIndex,
533    ObjectID outCompileResultId,
534    ObjectID outDiagnosticsId)
535{
536    Slang::StringBuilder builder;
537    int indent = 0;
538
539    Slang::String functionName = m_className;
540    functionName = functionName + "::getTargetCompileResult";
541    {
542        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
543        {
544            _writePair(
545                builder,
546                indent,
547                "this",
548                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
549            _writePair(builder, indent, "targetIndex", targetIndex);
550            _writePair(
551                builder,
552                indent,
553                "outCompileResult",
554                Slang::StringUtil::makeStringWithFormat("0x%llX", outCompileResultId));
555            _writePairNoComma(
556                builder,
557                indent,
558                "outDiagnostics",
559                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
560        }
561    }
562
563    m_fileStream.write(builder.begin(), builder.getLength());
564    m_fileStream.flush();
565}
566
567void CommonInterfaceWriter::getEntryPointCompileResult(
568    ObjectID objectId,
569    SlangInt entryPointIndex,
570    SlangInt targetIndex,
571    ObjectID outCompileResultId,
572    ObjectID outDiagnosticsId)
573{
574    Slang::StringBuilder builder;
575    int indent = 0;
576
577    Slang::String functionName = m_className;
578    functionName = functionName + "::getEntryPointCompileResult";
579    {
580        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
581        {
582            _writePair(
583                builder,
584                indent,
585                "this",
586                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
587            _writePair(builder, indent, "entryPointIndex", entryPointIndex);
588            _writePair(builder, indent, "targetIndex", targetIndex);
589            _writePair(
590                builder,
591                indent,
592                "outCompileResult",
593                Slang::StringUtil::makeStringWithFormat("0x%llX", outCompileResultId));
594            _writePairNoComma(
595                builder,
596                indent,
597                "outDiagnostics",
598                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
599        }
600    }
601
602    m_fileStream.write(builder.begin(), builder.getLength());
603    m_fileStream.flush();
604}
605
606void CommonInterfaceWriter::queryInterface(
607    ObjectID objectId,
608    const SlangUUID& guid,
609    ObjectID outInterfaceId)
610{
611    Slang::StringBuilder builder;
612    int indent = 0;
613
614    Slang::String functionName = m_className;
615    functionName = functionName + "::queryInterface";
616    {
617        ScopeWritterForKey scopeWritter(&builder, &indent, functionName);
618        {
619            _writePair(
620                builder,
621                indent,
622                "this",
623                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
624
625            Slang::String guidString = Slang::StringUtil::makeStringWithFormat(
626                "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
627                guid.data1,
628                guid.data2,
629                guid.data3,
630                guid.data4[0],
631                guid.data4[1],
632                guid.data4[2],
633                guid.data4[3],
634                guid.data4[4],
635                guid.data4[5],
636                guid.data4[6],
637                guid.data4[7]);
638            _writePair(builder, indent, "guid", guidString);
639
640            _writePairNoComma(
641                builder,
642                indent,
643                "outInterface",
644                Slang::StringUtil::makeStringWithFormat("0x%llX", outInterfaceId));
645        }
646    }
647
648    m_fileStream.write(builder.begin(), builder.getLength());
649    m_fileStream.flush();
650}
651
652JsonConsumer::JsonConsumer(const Slang::String& filePath)
653{
654    if (!Slang::File::exists(Slang::Path::getParentDirectory(filePath)))
655    {
656        slangRecordLog(
657            LogLevel::Error,
658            "Directory for json file does not exist: %s\n",
659            filePath.getBuffer());
660    }
661
662    Slang::FileMode fileMode = Slang::FileMode::Create;
663    Slang::FileAccess fileAccess = Slang::FileAccess::Write;
664    Slang::FileShare fileShare = Slang::FileShare::None;
665
666    SlangResult res = m_fileStream.init(filePath, fileMode, fileAccess, fileShare);
667
668    if (res != SLANG_OK)
669    {
670        slangRecordLog(LogLevel::Error, "Failed to open file %s\n", filePath.getBuffer());
671    }
672
673    m_isFileValid = true;
674}
675
676void JsonConsumer::_writeCompilerOptionEntryHelper(
677    Slang::StringBuilder& builder,
678    int indent,
679    slang::CompilerOptionEntry* compilerOptionEntries,
680    uint32_t compilerOptionEntryCount,
681    bool isLastField)
682{
683    if (compilerOptionEntryCount)
684    {
685        ScopeWritterForKey scopeWritterForCompilerOptionEntries(
686            &builder,
687            &indent,
688            "compilerOptionEntries",
689            isLastField);
690
691        for (uint32_t j = 0; j < compilerOptionEntryCount; j++)
692        {
693            ScopeWritterForKey scopeWritterForCompileOptionElement(
694                &builder,
695                &indent,
696                Slang::StringUtil::makeStringWithFormat("[%d]\n", j));
697            {
698                _writePair(
699                    builder,
700                    indent,
701                    "name",
702                    CompilerOptionNameToString(compilerOptionEntries[j].name));
703
704                bool isLastEntry = (j == compilerOptionEntryCount - 1);
705                ScopeWritterForKey scopeWritterValue(&builder, &indent, "value", isLastEntry);
706                {
707                    _writePair(
708                        builder,
709                        indent,
710                        "kind",
711                        CompilerOptionValueKindToString(compilerOptionEntries[j].value.kind));
712                    _writePair(
713                        builder,
714                        indent,
715                        "intValue0",
716                        compilerOptionEntries[j].value.intValue0);
717                    _writePair(
718                        builder,
719                        indent,
720                        "intValue1",
721                        compilerOptionEntries[j].value.intValue1);
722                    _writePair(
723                        builder,
724                        indent,
725                        "stringValue0",
726                        compilerOptionEntries[j].value.stringValue0);
727                    _writePairNoComma(
728                        builder,
729                        indent,
730                        "stringValue1",
731                        compilerOptionEntries[j].value.stringValue1);
732                }
733            }
734        }
735    }
736    else
737    {
738        _writePairNoComma(builder, indent, "compilerOptionEntries", "nullptr");
739    }
740}
741
742void JsonConsumer::_writeGlobalSessionDescHelper(
743    Slang::StringBuilder& builder,
744    int indent,
745    SlangGlobalSessionDesc const& desc,
746    Slang::String keyName,
747    bool isLastField)
748{
749    SLANG_UNUSED(isLastField);
750
751    ScopeWritterForKey scopeWritterForGlobalSessionDesc(&builder, &indent, keyName);
752    {
753        _writePair(builder, indent, "structureSize", (uint32_t)desc.structureSize);
754        _writePair(builder, indent, "apiVersion", (uint32_t)desc.apiVersion);
755        _writePair(builder, indent, "minLanguageVersion", (uint32_t)desc.minLanguageVersion);
756        _writePair(builder, indent, "enablGLSL", (uint32_t)desc.enableGLSL);
757    }
758}
759
760void JsonConsumer::_writeSessionDescHelper(
761    Slang::StringBuilder& builder,
762    int indent,
763    slang::SessionDesc const& desc,
764    Slang::String keyName,
765    bool isLastField)
766{
767    ScopeWritterForKey scopeWritterForSessionDesc(&builder, &indent, keyName);
768    {
769        _writePair(builder, indent, "structureSize", (uint32_t)desc.structureSize);
770
771        if (desc.targetCount)
772        {
773            ScopeWritterForKey scopeWritterForTarget(
774                &builder,
775                &indent,
776                Slang::StringUtil::makeStringWithFormat("targets (0x%llX)", desc.targets),
777                isLastField);
778            {
779                for (int i = 0; i < desc.targetCount; i++)
780                {
781                    bool isLastEntry = (i == desc.targetCount - 1);
782                    ScopeWritterForKey scopeWritterForTargetElement(
783                        &builder,
784                        &indent,
785                        Slang::StringUtil::makeStringWithFormat("[%d]", i),
786                        isLastEntry);
787                    {
788                        _writePair(
789                            builder,
790                            indent,
791                            "structureSize",
792                            (uint32_t)desc.targets[i].structureSize);
793                        _writePair(
794                            builder,
795                            indent,
796                            "format",
797                            SlangCompileTargetToString(desc.targets[i].format));
798                        _writePair(
799                            builder,
800                            indent,
801                            "profile",
802                            SlangProfileIDToString(desc.targets[i].profile));
803                        _writePair(
804                            builder,
805                            indent,
806                            "flags",
807                            SlangTargetFlagsToString(desc.targets[i].flags));
808                        _writePair(
809                            builder,
810                            indent,
811                            "floatingPointMode",
812                            SlangFloatingPointModeToString(desc.targets[i].floatingPointMode));
813                        _writePair(
814                            builder,
815                            indent,
816                            "lineDirectiveMode",
817                            SlangLineDirectiveModeToString(desc.targets[i].lineDirectiveMode));
818                        _writePair(
819                            builder,
820                            indent,
821                            "forceGLSLScalarBufferLayout",
822                            (desc.targets[i].floatingPointMode ? "true" : "false"));
823
824                        _writeCompilerOptionEntryHelper(
825                            builder,
826                            indent,
827                            desc.targets[i].compilerOptionEntries,
828                            desc.targets[i].compilerOptionEntryCount);
829                    }
830                }
831            }
832        }
833        else
834        {
835            _writePair(builder, indent, "targets", "nullptr");
836        }
837
838        _writePair(builder, indent, "targetCount", desc.targetCount);
839        _writePair(builder, indent, "flags", SessionFlagsToString(desc.flags));
840        _writePair(
841            builder,
842            indent,
843            "defaultMatrixLayoutMode",
844            SlangMatrixLayoutModeToString(desc.defaultMatrixLayoutMode));
845
846        if (desc.searchPathCount)
847        {
848            ScopeWritterForKey scopeWritterForSearchPath(&builder, &indent, "searchPaths", false);
849            for (int i = 0; i < desc.searchPathCount; i++)
850            {
851                Slang::String searchPath(desc.searchPaths[i]);
852                searchPath = searchPath + ",\n";
853                _writeString(builder, indent, searchPath);
854            }
855        }
856        else
857        {
858            _writePair(builder, indent, "searchPaths", "nullptr");
859        }
860        _writePair(builder, indent, "searchPathCount", desc.searchPathCount);
861
862        if (desc.preprocessorMacroCount)
863        {
864            ScopeWritterForKey scopeWritterForMacro(&builder, &indent, "preprocessorMacros", false);
865            for (int i = 0; i < desc.preprocessorMacroCount; i++)
866            {
867                bool isLastField = (i == desc.preprocessorMacroCount - 1);
868                ScopeWritterForKey scopeWritterForMacroElement(
869                    &builder,
870                    &indent,
871                    Slang::StringUtil::makeStringWithFormat("[%d]", i),
872                    isLastField);
873
874                _writePair(
875                    builder,
876                    indent,
877                    "name",
878                    Slang::StringUtil::makeStringWithFormat(
879                        "\"%s\"",
880                        desc.preprocessorMacros[i].name != nullptr ? desc.preprocessorMacros[i].name
881                                                                   : "nullptr"));
882
883                _writePairNoComma(
884                    builder,
885                    indent,
886                    "value",
887                    Slang::StringUtil::makeStringWithFormat(
888                        "\"%s\"",
889                        desc.preprocessorMacros[i].value != nullptr
890                            ? desc.preprocessorMacros[i].value
891                            : "nullptr"));
892            }
893        }
894        else
895        {
896            _writePair(builder, indent, "preprocessorMacros", "nullptr");
897        }
898        _writePair(builder, indent, "preprocessorMacroCount", desc.preprocessorMacroCount);
899
900        AddressFormat address = reinterpret_cast<AddressFormat>(desc.fileSystem);
901        _writePair(
902            builder,
903            indent,
904            "fileSystem",
905            Slang::StringUtil::makeStringWithFormat("0x%llX", address));
906        _writePair(
907            builder,
908            indent,
909            "enableEffectAnnotations",
910            (desc.enableEffectAnnotations ? "true" : "false"));
911        _writePair(builder, indent, "allowGLSLSyntax", (desc.allowGLSLSyntax ? "true" : "false"));
912        _writePair(builder, indent, "compilerOptionEntryCount", desc.compilerOptionEntryCount);
913        _writeCompilerOptionEntryHelper(
914            builder,
915            indent,
916            desc.compilerOptionEntries,
917            desc.compilerOptionEntryCount);
918    }
919}
920
921void JsonConsumer::CreateGlobalSession(
922    SlangGlobalSessionDesc const& desc,
923    ObjectID outGlobalSessionId)
924{
925    SANITY_CHECK();
926    Slang::StringBuilder builder;
927    int indent = 0;
928
929    {
930        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::createGlobalSession");
931        _writeGlobalSessionDescHelper(builder, indent, desc, "inDesc");
932        _writePairNoComma(
933            builder,
934            indent,
935            "outGlobalSession",
936            Slang::StringUtil::makeStringWithFormat("0x%llX", outGlobalSessionId));
937    }
938
939    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
940    m_fileStream.flush();
941}
942
943void JsonConsumer::IGlobalSession_createSession(
944    ObjectID objectId,
945    slang::SessionDesc const& desc,
946    ObjectID outSessionId)
947{
948    SANITY_CHECK();
949    Slang::StringBuilder builder;
950    int indent = 0;
951
952    {
953        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::createSession");
954        {
955            _writePair(
956                builder,
957                indent,
958                "this",
959                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
960
961            _writeSessionDescHelper(builder, indent, desc, "inDesc");
962
963            _writePairNoComma(
964                builder,
965                indent,
966                "outSession",
967                Slang::StringUtil::makeStringWithFormat("0x%llX", outSessionId));
968        }
969    }
970
971    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
972    m_fileStream.flush();
973}
974
975void JsonConsumer::IGlobalSession_findProfile(ObjectID objectId, char const* name)
976{
977    SANITY_CHECK();
978    Slang::StringBuilder builder;
979    int indent = 0;
980
981    {
982        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::findProfile");
983        {
984            _writePair(
985                builder,
986                indent,
987                "this",
988                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
989            _writePairNoComma(
990                builder,
991                indent,
992                "name",
993                Slang::StringUtil::makeStringWithFormat(
994                    "\"%s\"",
995                    name != nullptr ? name : "nullptr"));
996        }
997    }
998
999    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1000    m_fileStream.flush();
1001}
1002
1003
1004void JsonConsumer::IGlobalSession_setDownstreamCompilerPath(
1005    ObjectID objectId,
1006    SlangPassThrough passThrough,
1007    char const* path)
1008{
1009    SANITY_CHECK();
1010    Slang::StringBuilder builder;
1011    int indent = 0;
1012
1013    {
1014        ScopeWritterForKey scopeWritter(
1015            &builder,
1016            &indent,
1017            "IGlobalSession::setDownstreamCompilerPath");
1018        {
1019            _writePair(
1020                builder,
1021                indent,
1022                "this",
1023                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1024            _writePair(builder, indent, "passThrough", SlangPassThroughToString(passThrough));
1025            _writePairNoComma(
1026                builder,
1027                indent,
1028                "path",
1029                Slang::StringUtil::makeStringWithFormat(
1030                    "\"%s\"",
1031                    path != nullptr ? path : "nullptr"));
1032        }
1033    }
1034
1035    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1036    m_fileStream.flush();
1037}
1038
1039
1040void JsonConsumer::IGlobalSession_setDownstreamCompilerPrelude(
1041    ObjectID objectId,
1042    SlangPassThrough inPassThrough,
1043    char const* prelude)
1044{
1045    SANITY_CHECK();
1046    Slang::StringBuilder builder;
1047    int indent = 0;
1048
1049    {
1050        ScopeWritterForKey scopeWritter(
1051            &builder,
1052            &indent,
1053            "IGlobalSession::setDownstreamCompilerPrelude");
1054        {
1055            _writePair(
1056                builder,
1057                indent,
1058                "this",
1059                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1060            _writePair(builder, indent, "passThrough", SlangPassThroughToString(inPassThrough));
1061            _writePairNoComma(
1062                builder,
1063                indent,
1064                "preludeText",
1065                Slang::StringUtil::makeStringWithFormat(
1066                    "\"%s\"",
1067                    prelude != nullptr ? prelude : "nullptr"));
1068        }
1069    }
1070
1071    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1072    m_fileStream.flush();
1073}
1074
1075
1076void JsonConsumer::IGlobalSession_getDownstreamCompilerPrelude(
1077    ObjectID objectId,
1078    SlangPassThrough inPassThrough,
1079    ObjectID outPreludeId)
1080{
1081    SANITY_CHECK();
1082    Slang::StringBuilder builder;
1083    int indent = 0;
1084
1085    {
1086        ScopeWritterForKey scopeWritter(
1087            &builder,
1088            &indent,
1089            "IGlobalSession::getDownstreamCompilerPrelude");
1090        {
1091            _writePair(
1092                builder,
1093                indent,
1094                "this",
1095                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1096            _writePair(builder, indent, "passThrough", SlangPassThroughToString(inPassThrough));
1097            _writePairNoComma(
1098                builder,
1099                indent,
1100                "outPrelude",
1101                Slang::StringUtil::makeStringWithFormat("0x%llX", outPreludeId));
1102        }
1103    }
1104
1105    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1106    m_fileStream.flush();
1107}
1108
1109
1110void JsonConsumer::IGlobalSession_setDefaultDownstreamCompiler(
1111    ObjectID objectId,
1112    SlangSourceLanguage sourceLanguage,
1113    SlangPassThrough defaultCompiler)
1114{
1115    SANITY_CHECK();
1116    Slang::StringBuilder builder;
1117    int indent = 0;
1118
1119    {
1120        ScopeWritterForKey scopeWritter(
1121            &builder,
1122            &indent,
1123            "IGlobalSession::setDefaultDownstreamCompiler");
1124        {
1125            _writePair(
1126                builder,
1127                indent,
1128                "this",
1129                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1130            _writePair(
1131                builder,
1132                indent,
1133                "sourceLanguage",
1134                SlangSourceLanguageToString(sourceLanguage));
1135            _writePairNoComma(
1136                builder,
1137                indent,
1138                "defaultCompiler",
1139                SlangPassThroughToString(defaultCompiler));
1140        }
1141    }
1142
1143    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1144    m_fileStream.flush();
1145}
1146
1147
1148void JsonConsumer::IGlobalSession_getDefaultDownstreamCompiler(
1149    ObjectID objectId,
1150    SlangSourceLanguage sourceLanguage)
1151{
1152    SANITY_CHECK();
1153    Slang::StringBuilder builder;
1154    int indent = 0;
1155
1156    {
1157        ScopeWritterForKey scopeWritter(
1158            &builder,
1159            &indent,
1160            "IGlobalSession::getDefaultDownstreamCompiler");
1161        {
1162            _writePair(
1163                builder,
1164                indent,
1165                "this",
1166                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1167            _writePairNoComma(
1168                builder,
1169                indent,
1170                "sourceLanguage",
1171                SlangSourceLanguageToString(sourceLanguage));
1172        }
1173    }
1174
1175    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1176    m_fileStream.flush();
1177}
1178
1179
1180void JsonConsumer::IGlobalSession_setLanguagePrelude(
1181    ObjectID objectId,
1182    SlangSourceLanguage inSourceLanguage,
1183    char const* prelude)
1184{
1185    SANITY_CHECK();
1186    Slang::StringBuilder builder;
1187    int indent = 0;
1188
1189    {
1190        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::setLanguagePrelude");
1191        {
1192            _writePair(
1193                builder,
1194                indent,
1195                "this",
1196                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1197            _writePair(
1198                builder,
1199                indent,
1200                "sourceLanguage",
1201                SlangSourceLanguageToString(inSourceLanguage));
1202            _writePairNoComma(
1203                builder,
1204                indent,
1205                "preludeText",
1206                Slang::StringUtil::makeStringWithFormat(
1207                    "\"%s\"",
1208                    prelude != nullptr ? prelude : "nullptr"));
1209        }
1210    }
1211
1212    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1213    m_fileStream.flush();
1214}
1215
1216
1217void JsonConsumer::IGlobalSession_getLanguagePrelude(
1218    ObjectID objectId,
1219    SlangSourceLanguage inSourceLanguage,
1220    ObjectID outPreludeId)
1221{
1222    SANITY_CHECK();
1223    Slang::StringBuilder builder;
1224    int indent = 0;
1225
1226    {
1227        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::getLanguagePrelude");
1228        {
1229            _writePair(
1230                builder,
1231                indent,
1232                "this",
1233                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1234            _writePair(
1235                builder,
1236                indent,
1237                "sourceLanguage",
1238                SlangSourceLanguageToString(inSourceLanguage));
1239            _writePairNoComma(
1240                builder,
1241                indent,
1242                "outPrelude",
1243                Slang::StringUtil::makeStringWithFormat("0x%llX", outPreludeId));
1244        }
1245    }
1246
1247    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1248    m_fileStream.flush();
1249}
1250
1251
1252void JsonConsumer::IGlobalSession_createCompileRequest(
1253    ObjectID objectId,
1254    ObjectID outCompileRequest)
1255{
1256    SANITY_CHECK();
1257    Slang::StringBuilder builder;
1258    int indent = 0;
1259    _writeString(builder, indent, "IGlobalSession::createCompileRequest: {\n");
1260
1261    {
1262        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::createCompileRequest");
1263        {
1264            _writePair(
1265                builder,
1266                indent,
1267                "this",
1268                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1269            _writePairNoComma(
1270                builder,
1271                indent,
1272                "outCompileRequest",
1273                Slang::StringUtil::makeStringWithFormat("0x%llX", outCompileRequest));
1274        }
1275    }
1276
1277    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1278    m_fileStream.flush();
1279}
1280
1281
1282void JsonConsumer::IGlobalSession_addBuiltins(
1283    ObjectID objectId,
1284    char const* sourcePath,
1285    char const* sourceString)
1286{
1287    SANITY_CHECK();
1288    Slang::StringBuilder builder;
1289    int indent = 0;
1290    _writeString(builder, indent, "IGlobalSession::addBuiltins: {\n");
1291
1292    {
1293        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::addBuiltins");
1294        {
1295            _writePair(
1296                builder,
1297                indent,
1298                "this",
1299                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1300            _writePair(
1301                builder,
1302                indent,
1303                "sourcePath",
1304                Slang::StringUtil::makeStringWithFormat(
1305                    "\"%s\"",
1306                    sourcePath != nullptr ? sourcePath : "nullptr"));
1307            _writePairNoComma(
1308                builder,
1309                indent,
1310                "sourceString",
1311                Slang::StringUtil::makeStringWithFormat(
1312                    "\"%s\"",
1313                    sourceString != nullptr ? sourceString : "nullptr"));
1314        }
1315    }
1316
1317    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1318    m_fileStream.flush();
1319}
1320
1321
1322void JsonConsumer::IGlobalSession_setSharedLibraryLoader(ObjectID objectId, ObjectID loaderId)
1323{
1324    SANITY_CHECK();
1325    Slang::StringBuilder builder;
1326    int indent = 0;
1327
1328    {
1329        ScopeWritterForKey scopeWritter(
1330            &builder,
1331            &indent,
1332            "IGlobalSession::setSharedLibraryLoader");
1333        {
1334            _writePair(
1335                builder,
1336                indent,
1337                "this",
1338                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1339            _writePairNoComma(
1340                builder,
1341                indent,
1342                "loader",
1343                Slang::StringUtil::makeStringWithFormat("0x%llX", loaderId));
1344        }
1345    }
1346
1347    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1348    m_fileStream.flush();
1349}
1350
1351
1352void JsonConsumer::IGlobalSession_getSharedLibraryLoader(ObjectID objectId, ObjectID outLoaderId)
1353{
1354    SANITY_CHECK();
1355    Slang::StringBuilder builder;
1356    int indent = 0;
1357
1358    {
1359        ScopeWritterForKey scopeWritter(
1360            &builder,
1361            &indent,
1362            "IGlobalSession::getSharedLibraryLoader");
1363        {
1364            _writePair(
1365                builder,
1366                indent,
1367                "this",
1368                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1369            _writePairNoComma(
1370                builder,
1371                indent,
1372                "retLoader",
1373                Slang::StringUtil::makeStringWithFormat("0x%llX", outLoaderId));
1374        }
1375    }
1376
1377    _writeString(builder, indent, "}\n");
1378
1379    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1380    m_fileStream.flush();
1381}
1382
1383
1384void JsonConsumer::IGlobalSession_checkCompileTargetSupport(
1385    ObjectID objectId,
1386    SlangCompileTarget target)
1387{
1388    SANITY_CHECK();
1389    Slang::StringBuilder builder;
1390    int indent = 0;
1391
1392    {
1393        ScopeWritterForKey scopeWritter(
1394            &builder,
1395            &indent,
1396            "IGlobalSession::checkCompileTargetSupport");
1397        {
1398            _writePair(
1399                builder,
1400                indent,
1401                "this",
1402                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1403            _writePairNoComma(builder, indent, "target", SlangCompileTargetToString(target));
1404        }
1405    }
1406
1407    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1408    m_fileStream.flush();
1409}
1410
1411
1412void JsonConsumer::IGlobalSession_checkPassThroughSupport(
1413    ObjectID objectId,
1414    SlangPassThrough passThrough)
1415{
1416    SANITY_CHECK();
1417    Slang::StringBuilder builder;
1418    int indent = 0;
1419
1420    {
1421        ScopeWritterForKey scopeWritter(
1422            &builder,
1423            &indent,
1424            "IGlobalSession::checkPassThroughSupport");
1425        {
1426            _writePair(
1427                builder,
1428                indent,
1429                "this",
1430                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1431            _writePairNoComma(
1432                builder,
1433                indent,
1434                "passThrough",
1435                SlangPassThroughToString(passThrough));
1436        }
1437    }
1438
1439    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1440    m_fileStream.flush();
1441}
1442
1443
1444void JsonConsumer::IGlobalSession_compileCoreModule(
1445    ObjectID objectId,
1446    slang::CompileCoreModuleFlags flags)
1447{
1448    SANITY_CHECK();
1449    Slang::StringBuilder builder;
1450    int indent = 0;
1451
1452    {
1453        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::compileCoreModule");
1454        {
1455            _writePair(
1456                builder,
1457                indent,
1458                "this",
1459                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1460            _writePairNoComma(builder, indent, "flags", CompileCoreModuleFlagsToString(flags));
1461        }
1462    }
1463
1464    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1465    m_fileStream.flush();
1466}
1467
1468
1469void JsonConsumer::IGlobalSession_loadCoreModule(
1470    ObjectID objectId,
1471    const void* coreModule,
1472    size_t coreModuleSizeInBytes)
1473{
1474    SANITY_CHECK();
1475    Slang::StringBuilder builder;
1476    int indent = 0;
1477    _writeString(builder, indent, "IGlobalSession::loadCoreModule: {\n");
1478
1479    {
1480        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::loadCoreModule");
1481        {
1482            _writePair(
1483                builder,
1484                indent,
1485                "this",
1486                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1487            _writePair(
1488                builder,
1489                indent,
1490                "coreModule-Ignore-Data",
1491                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1492            _writePairNoComma(
1493                builder,
1494                indent,
1495                "coreModuleSizeInBytes",
1496                (uint32_t)coreModuleSizeInBytes);
1497        }
1498    }
1499
1500    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1501    m_fileStream.flush();
1502}
1503
1504void JsonConsumer::IGlobalSession_saveCoreModule(
1505    ObjectID objectId,
1506    SlangArchiveType archiveType,
1507    ObjectID outBlobId)
1508{
1509    SANITY_CHECK();
1510    Slang::StringBuilder builder;
1511    int indent = 0;
1512
1513    {
1514        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::saveCoreModule");
1515        {
1516            _writePair(
1517                builder,
1518                indent,
1519                "this",
1520                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1521            _writePair(builder, indent, "archiveType", SlangArchiveTypeToString(archiveType));
1522            _writePairNoComma(
1523                builder,
1524                indent,
1525                "outBlobId",
1526                Slang::StringUtil::makeStringWithFormat("0x%llX", outBlobId));
1527        }
1528    }
1529
1530    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1531    m_fileStream.flush();
1532}
1533
1534
1535void JsonConsumer::IGlobalSession_findCapability(ObjectID objectId, char const* name)
1536{
1537    SANITY_CHECK();
1538    Slang::StringBuilder builder;
1539    int indent = 0;
1540
1541    {
1542        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::findCapability");
1543        {
1544            _writePair(
1545                builder,
1546                indent,
1547                "this",
1548                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1549            _writePairNoComma(
1550                builder,
1551                indent,
1552                "name",
1553                Slang::StringUtil::makeStringWithFormat(
1554                    "\"%s\"",
1555                    name != nullptr ? name : "nullptr"));
1556        }
1557    }
1558
1559    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1560    m_fileStream.flush();
1561}
1562
1563
1564void JsonConsumer::IGlobalSession_setDownstreamCompilerForTransition(
1565    ObjectID objectId,
1566    SlangCompileTarget source,
1567    SlangCompileTarget target,
1568    SlangPassThrough compiler)
1569{
1570    SANITY_CHECK();
1571    Slang::StringBuilder builder;
1572    int indent = 0;
1573
1574    {
1575        ScopeWritterForKey scopeWritter(
1576            &builder,
1577            &indent,
1578            "IGlobalSession::setDownstreamCompilerForTransition");
1579        {
1580            _writePair(
1581                builder,
1582                indent,
1583                "this",
1584                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1585            _writePair(builder, indent, "source", SlangCompileTargetToString(source));
1586            _writePair(builder, indent, "target", SlangCompileTargetToString(target));
1587            _writePairNoComma(builder, indent, "compiler", SlangPassThroughToString(compiler));
1588        }
1589    }
1590
1591    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1592    m_fileStream.flush();
1593}
1594
1595
1596void JsonConsumer::IGlobalSession_getDownstreamCompilerForTransition(
1597    ObjectID objectId,
1598    SlangCompileTarget source,
1599    SlangCompileTarget target)
1600{
1601    SANITY_CHECK();
1602    Slang::StringBuilder builder;
1603    int indent = 0;
1604
1605    {
1606        ScopeWritterForKey scopeWritter(
1607            &builder,
1608            &indent,
1609            "IGlobalSession::getDownstreamCompilerForTransition");
1610        {
1611            _writePair(
1612                builder,
1613                indent,
1614                "this",
1615                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1616            _writePair(builder, indent, "source", SlangCompileTargetToString(source));
1617            _writePairNoComma(builder, indent, "target", SlangCompileTargetToString(target));
1618        }
1619    }
1620
1621    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1622    m_fileStream.flush();
1623}
1624
1625
1626void JsonConsumer::IGlobalSession_setSPIRVCoreGrammar(ObjectID objectId, char const* jsonPath)
1627{
1628    SANITY_CHECK();
1629    Slang::StringBuilder builder;
1630    int indent = 0;
1631
1632    {
1633        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::setSPIRVCoreGrammar");
1634        {
1635            _writePair(
1636                builder,
1637                indent,
1638                "this",
1639                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1640            _writePairNoComma(
1641                builder,
1642                indent,
1643                "jsonPath",
1644                Slang::StringUtil::makeStringWithFormat(
1645                    "\"%s\"",
1646                    jsonPath != nullptr ? jsonPath : "nullptr"));
1647        }
1648    }
1649
1650    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1651    m_fileStream.flush();
1652}
1653
1654
1655void JsonConsumer::IGlobalSession_parseCommandLineArguments(
1656    ObjectID objectId,
1657    int argc,
1658    const char* const* argv,
1659    ObjectID outSessionDescId,
1660    ObjectID outAllocationId)
1661{
1662    SANITY_CHECK();
1663    Slang::StringBuilder builder;
1664    int indent = 0;
1665
1666    {
1667        ScopeWritterForKey scopeWritter(
1668            &builder,
1669            &indent,
1670            "IGlobalSession::parseCommandLineArguments");
1671        _writePair(
1672            builder,
1673            indent,
1674            "this",
1675            Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1676        _writePair(builder, indent, "argc", argc);
1677
1678        if (argv)
1679        {
1680            _writeString(builder, indent, "argv: {\n");
1681            ScopeWritterForKey scopeWritteriForArgv(&builder, &indent, "argv");
1682            for (int i = 0; i < argc; i++)
1683            {
1684                if (i == (argc - 1))
1685                    _writePairNoComma(
1686                        builder,
1687                        indent,
1688                        Slang::StringUtil::makeStringWithFormat("[%d]", i),
1689                        argv[i]);
1690                else
1691                    _writePair(
1692                        builder,
1693                        indent,
1694                        Slang::StringUtil::makeStringWithFormat("[%d]", i),
1695                        argv[i]);
1696            }
1697        }
1698        else
1699        {
1700            _writePair(builder, indent, "argv", "nullptr");
1701        }
1702    }
1703
1704    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1705    m_fileStream.flush();
1706}
1707
1708
1709void JsonConsumer::IGlobalSession_getSessionDescDigest(
1710    ObjectID objectId,
1711    slang::SessionDesc* sessionDesc,
1712    ObjectID outBlobId)
1713{
1714    SANITY_CHECK();
1715    Slang::StringBuilder builder;
1716    int indent = 0;
1717
1718    {
1719        ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::getSessionDescDigest");
1720        _writePair(
1721            builder,
1722            indent,
1723            "this",
1724            Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1725
1726        if (sessionDesc)
1727        {
1728            _writeSessionDescHelper(
1729                builder,
1730                indent,
1731                *sessionDesc,
1732                Slang::StringUtil::makeStringWithFormat("sessionDesc (0x%llX)\n", sessionDesc));
1733        }
1734        else
1735        {
1736            _writePair(builder, indent, "sessionDesc", "nullptr");
1737        }
1738
1739        _writePair(
1740            builder,
1741            indent,
1742            "outBlob",
1743            Slang::StringUtil::makeStringWithFormat("0x%llX", outBlobId));
1744    }
1745
1746    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1747    m_fileStream.flush();
1748}
1749
1750// ISession
1751void JsonConsumer::ISession_getGlobalSession(ObjectID objectId, ObjectID outGlobalSessionId)
1752{
1753    SANITY_CHECK();
1754    Slang::StringBuilder builder;
1755    int indent = 0;
1756
1757    {
1758        ScopeWritterForKey scopeWritter(&builder, &indent, "ISession::getGlobalSession");
1759        {
1760            _writePair(
1761                builder,
1762                indent,
1763                "this",
1764                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1765            _writePairNoComma(
1766                builder,
1767                indent,
1768                "retGlobalSession",
1769                Slang::StringUtil::makeStringWithFormat("0x%llX", outGlobalSessionId));
1770        }
1771    }
1772
1773    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1774    m_fileStream.flush();
1775}
1776
1777
1778void JsonConsumer::ISession_loadModule(
1779    ObjectID objectId,
1780    const char* moduleName,
1781    ObjectID outDiagnostics,
1782    ObjectID outModuleId)
1783{
1784    SANITY_CHECK();
1785    Slang::StringBuilder builder;
1786    int indent = 0;
1787
1788    {
1789        ScopeWritterForKey scopeWritter(&builder, &indent, "ISession::loadModule");
1790        {
1791            _writePair(
1792                builder,
1793                indent,
1794                "this",
1795                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1796            _writePair(
1797                builder,
1798                indent,
1799                "moduleName",
1800                Slang::StringUtil::makeStringWithFormat(
1801                    "\"%s\"",
1802                    moduleName != nullptr ? moduleName : "nullptr"));
1803            _writePair(
1804                builder,
1805                indent,
1806                "outDiagnostics",
1807                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnostics));
1808            _writePairNoComma(
1809                builder,
1810                indent,
1811                "retIModule",
1812                Slang::StringUtil::makeStringWithFormat("0x%llX", outModuleId));
1813        }
1814    }
1815
1816    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1817    m_fileStream.flush();
1818}
1819
1820void JsonConsumer::ISession_loadModuleFromIRBlob(
1821    ObjectID objectId,
1822    const char* moduleName,
1823    const char* path,
1824    slang::IBlob* source,
1825    ObjectID outDiagnosticsId,
1826    ObjectID outModuleId)
1827{
1828    SANITY_CHECK();
1829    Slang::StringBuilder builder;
1830    int indent = 0;
1831
1832    {
1833        ScopeWritterForKey scopeWritter(&builder, &indent, "ISession::loadModuleFromIRBlob");
1834        {
1835            _writePair(
1836                builder,
1837                indent,
1838                "this",
1839                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1840            _writePair(
1841                builder,
1842                indent,
1843                "moduleName",
1844                Slang::StringUtil::makeStringWithFormat(
1845                    "\"%s\"",
1846                    moduleName != nullptr ? moduleName : "nullptr"));
1847            _writePair(
1848                builder,
1849                indent,
1850                "path",
1851                Slang::StringUtil::makeStringWithFormat(
1852                    "\"%s\"",
1853                    path != nullptr ? path : "nullptr"));
1854            if (source)
1855            {
1856                void const* bufPtr = source->getBufferPointer();
1857                size_t bufSize = source->getBufferSize();
1858
1859                ScopeWritterForKey scopeWritterForSource(
1860                    &builder,
1861                    &indent,
1862                    Slang::StringUtil::makeStringWithFormat("source (0x%llX): {\n", source),
1863                    false);
1864                {
1865                    _writePair(
1866                        builder,
1867                        indent,
1868                        "bufferPointer",
1869                        Slang::StringUtil::makeStringWithFormat("0x%llX", bufPtr));
1870                    _writePairNoComma(builder, indent, "bufferSize", (uint32_t)bufSize);
1871                }
1872            }
1873            else
1874            {
1875                _writePair(builder, indent, "source", "nullptr");
1876            }
1877
1878            _writePair(
1879                builder,
1880                indent,
1881                "outDiagnostics",
1882                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
1883            _writePairNoComma(
1884                builder,
1885                indent,
1886                "retIModule",
1887                Slang::StringUtil::makeStringWithFormat("0x%llX", outModuleId));
1888        }
1889    }
1890
1891    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1892    m_fileStream.flush();
1893}
1894
1895
1896void JsonConsumer::ISession_loadModuleFromSource(
1897    ObjectID objectId,
1898    const char* moduleName,
1899    const char* path,
1900    slang::IBlob* source,
1901    ObjectID outDiagnosticsId,
1902    ObjectID outModuleId)
1903{
1904    SANITY_CHECK();
1905    Slang::StringBuilder builder;
1906    int indent = 0;
1907
1908    {
1909        ScopeWritterForKey scopeWritter(&builder, &indent, "ISession::loadModuleFromSource");
1910        _writePair(
1911            builder,
1912            indent,
1913            "this",
1914            Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1915        _writePair(
1916            builder,
1917            indent,
1918            "moduleName",
1919            Slang::StringUtil::makeStringWithFormat(
1920                "\"%s\"",
1921                moduleName != nullptr ? moduleName : "nullptr"));
1922        _writePair(
1923            builder,
1924            indent,
1925            "path",
1926            Slang::StringUtil::makeStringWithFormat("\"%s\"", path != nullptr ? path : "nullptr"));
1927        if (source)
1928        {
1929            void const* bufPtr = source->getBufferPointer();
1930            size_t bufSize = source->getBufferSize();
1931            ScopeWritterForKey scopeWritterForSource(
1932                &builder,
1933                &indent,
1934                Slang::StringUtil::makeStringWithFormat("source (0x%llX): {\n", source),
1935                false);
1936            {
1937                _writePair(
1938                    builder,
1939                    indent,
1940                    "bufferPointer",
1941                    Slang::StringUtil::makeStringWithFormat("0x%llX", bufPtr));
1942                _writePairNoComma(builder, indent, "bufferSize", (uint32_t)bufSize);
1943            }
1944        }
1945        else
1946        {
1947            _writePair(builder, indent, "source", "nullptr");
1948        }
1949
1950        _writePair(
1951            builder,
1952            indent,
1953            "outDiagnostics",
1954            Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
1955        _writePairNoComma(
1956            builder,
1957            indent,
1958            "retIModule",
1959            Slang::StringUtil::makeStringWithFormat("0x%llX", outModuleId));
1960    }
1961
1962    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
1963    m_fileStream.flush();
1964}
1965
1966
1967void JsonConsumer::ISession_loadModuleFromSourceString(
1968    ObjectID objectId,
1969    const char* moduleName,
1970    const char* path,
1971    const char* string,
1972    ObjectID outDiagnosticsId,
1973    ObjectID outModuleId)
1974{
1975    SANITY_CHECK();
1976    Slang::StringBuilder builder;
1977    int indent = 0;
1978
1979    {
1980        ScopeWritterForKey scopeWritter(&builder, &indent, "ISession::loadModuleFromSourceString");
1981        _writePair(
1982            builder,
1983            indent,
1984            "this",
1985            Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
1986        _writePair(
1987            builder,
1988            indent,
1989            "moduleName",
1990            Slang::StringUtil::makeStringWithFormat(
1991                "\"%s\"",
1992                moduleName != nullptr ? moduleName : "nullptr"));
1993
1994        _writePair(
1995            builder,
1996            indent,
1997            "path",
1998            Slang::StringUtil::makeStringWithFormat("\"%s\"", path != nullptr ? path : "nullptr"));
1999
2000        _writePair(
2001            builder,
2002            indent,
2003            "string",
2004            Slang::StringUtil::makeStringWithFormat(
2005                "\"%s\"",
2006                string != nullptr ? string : "nullptr"));
2007
2008        _writePair(
2009            builder,
2010            indent,
2011            "outDiagnostics",
2012            Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
2013        _writePairNoComma(
2014            builder,
2015            indent,
2016            "retIModule",
2017            Slang::StringUtil::makeStringWithFormat("0x%llX", outModuleId));
2018    }
2019
2020    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2021    m_fileStream.flush();
2022}
2023
2024
2025void JsonConsumer::ISession_createCompositeComponentType(
2026    ObjectID objectId,
2027    ObjectID* componentTypeIds,
2028    SlangInt componentTypeCount,
2029    ObjectID outCompositeComponentTypeId,
2030    ObjectID outDiagnosticsId)
2031{
2032    SANITY_CHECK();
2033    Slang::StringBuilder builder;
2034    int indent = 0;
2035
2036    {
2037        ScopeWritterForKey scopeWritter(
2038            &builder,
2039            &indent,
2040            "ISession::createCompositeComponentType");
2041        {
2042            _writePair(
2043                builder,
2044                indent,
2045                "this",
2046                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2047            if (componentTypeCount)
2048            {
2049                ScopeWritterForKey scopeWritterForComponentTypes(
2050                    &builder,
2051                    &indent,
2052                    "componentTypes",
2053                    false);
2054                for (int i = 0; i < componentTypeCount; i++)
2055                {
2056                    if (i != componentTypeCount - 1)
2057                    {
2058                        _writeString(
2059                            builder,
2060                            indent,
2061                            Slang::StringUtil::makeStringWithFormat(
2062                                "[%d]: 0x%llX,\n",
2063                                i,
2064                                componentTypeIds[i]));
2065                    }
2066                    else
2067                    {
2068                        _writeString(
2069                            builder,
2070                            indent,
2071                            Slang::StringUtil::makeStringWithFormat(
2072                                "[%d]: 0x%llX\n",
2073                                i,
2074                                componentTypeIds[i]));
2075                    }
2076                }
2077            }
2078            else
2079            {
2080                _writePair(builder, indent, "componentTypes", "nullptr");
2081            }
2082        }
2083        _writePair(builder, indent, "componentTypeCount", componentTypeCount);
2084        _writePair(
2085            builder,
2086            indent,
2087            "outCompositeComponentType",
2088            Slang::StringUtil::makeStringWithFormat("0x%llX", outCompositeComponentTypeId));
2089        _writePairNoComma(
2090            builder,
2091            indent,
2092            "outDiagnostics",
2093            Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
2094    }
2095
2096    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2097    m_fileStream.flush();
2098}
2099
2100
2101void JsonConsumer::ISession_specializeType(
2102    ObjectID objectId,
2103    ObjectID typeId,
2104    slang::SpecializationArg const* specializationArgs,
2105    SlangInt specializationArgCount,
2106    ObjectID outDiagnosticsId,
2107    ObjectID outTypeReflectionId)
2108{
2109    SANITY_CHECK();
2110    Slang::StringBuilder builder;
2111    int indent = 0;
2112
2113    {
2114        ScopeWritterForKey scopeWritter(&builder, &indent, "ISession::specializeType");
2115        _writePair(
2116            builder,
2117            indent,
2118            "this",
2119            Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2120        _writePair(
2121            builder,
2122            indent,
2123            "type",
2124            Slang::StringUtil::makeStringWithFormat("0x%llX", typeId));
2125
2126        if (specializationArgCount)
2127        {
2128            ScopeWritterForKey scopeWritterForArgs(&builder, &indent, "specializationArgs", false);
2129            for (int i = 0; i < specializationArgCount; i++)
2130            {
2131                ScopeWritterForKey scopeWritterForArg(
2132                    &builder,
2133                    &indent,
2134                    Slang::StringUtil::makeStringWithFormat("[%d]\n", i),
2135                    false);
2136                {
2137                    _writePair(
2138                        builder,
2139                        indent,
2140                        "kind",
2141                        SpecializationArgKindToString(specializationArgs[i].kind));
2142                    _writePairNoComma(
2143                        builder,
2144                        indent,
2145                        "type",
2146                        Slang::StringUtil::makeStringWithFormat(
2147                            "0x%llX",
2148                            specializationArgs[i].type));
2149                }
2150            }
2151        }
2152        else
2153        {
2154            _writePair(builder, indent, "specializationArgs", "nullptr");
2155        }
2156
2157        _writePair(builder, indent, "specializationArgCount", specializationArgCount);
2158        _writePair(builder, indent, "outDiagnostics", outDiagnosticsId);
2159        _writePairNoComma(builder, indent, "retTypeReflectionId", outTypeReflectionId);
2160    }
2161
2162    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2163    m_fileStream.flush();
2164}
2165
2166void JsonConsumer::ISession_getTypeLayout(
2167    ObjectID objectId,
2168    ObjectID typeId,
2169    SlangInt targetIndex,
2170    slang::LayoutRules rules,
2171    ObjectID outDiagnosticsId,
2172    ObjectID outTypeLayoutReflectionId)
2173{
2174    SANITY_CHECK();
2175    Slang::StringBuilder builder;
2176    int indent = 0;
2177
2178    {
2179        ScopeWritterForKey scopeWritter(&builder, &indent, "ISession::getTypeLayout");
2180        {
2181            _writePair(
2182                builder,
2183                indent,
2184                "this",
2185                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2186            _writePair(
2187                builder,
2188                indent,
2189                "type",
2190                Slang::StringUtil::makeStringWithFormat("0x%llX", typeId));
2191            _writePair(builder, indent, "rules", LayoutRulesToString(rules));
2192            _writePair(
2193                builder,
2194                indent,
2195                "outDiagnostics",
2196                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
2197            _writePairNoComma(
2198                builder,
2199                indent,
2200                "retTypeReflectionId",
2201                Slang::StringUtil::makeStringWithFormat("0x%llX", outTypeLayoutReflectionId));
2202        }
2203    }
2204
2205    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2206    m_fileStream.flush();
2207}
2208
2209void JsonConsumer::ISession_getContainerType(
2210    ObjectID objectId,
2211    ObjectID elementTypeId,
2212    slang::ContainerType containerType,
2213    ObjectID outDiagnosticsId,
2214    ObjectID outTypeReflectionId)
2215{
2216    SANITY_CHECK();
2217    Slang::StringBuilder builder;
2218    int indent = 0;
2219
2220    {
2221        ScopeWritterForKey scopeWritter(&builder, &indent, "ISession::getContainerType");
2222        _writePair(
2223            builder,
2224            indent,
2225            "this",
2226            Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2227        _writePair(
2228            builder,
2229            indent,
2230            "elementType",
2231            Slang::StringUtil::makeStringWithFormat("0x%llX", elementTypeId));
2232        _writePair(builder, indent, "containerType", ContainerTypeToString(containerType));
2233        _writePair(
2234            builder,
2235            indent,
2236            "outDiagnosticsId",
2237            Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnosticsId));
2238        _writePairNoComma(
2239            builder,
2240            indent,
2241            "outTypeReflectionId",
2242            Slang::StringUtil::makeStringWithFormat("0x%llX", outTypeReflectionId));
2243    }
2244
2245    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2246    m_fileStream.flush();
2247}
2248
2249void JsonConsumer::ISession_getDynamicType(ObjectID objectId, ObjectID outTypeReflectionId)
2250{
2251    SANITY_CHECK();
2252    Slang::StringBuilder builder;
2253    int indent = 0;
2254
2255    {
2256        ScopeWritterForKey scopeWritter(&builder, &indent, "ISession::getDynamicType");
2257        _writePair(
2258            builder,
2259            indent,
2260            "this",
2261            Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2262        _writePairNoComma(
2263            builder,
2264            indent,
2265            "outTypeReflectionId",
2266            Slang::StringUtil::makeStringWithFormat("0x%llX", outTypeReflectionId));
2267    }
2268
2269    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2270    m_fileStream.flush();
2271}
2272
2273void JsonConsumer::ISession_getTypeRTTIMangledName(
2274    ObjectID objectId,
2275    ObjectID typeId,
2276    ObjectID outNameBlobId)
2277{
2278    SANITY_CHECK();
2279    Slang::StringBuilder builder;
2280    int indent = 0;
2281
2282    {
2283        ScopeWritterForKey scopeWritter(&builder, &indent, "ISession::getTypeRTTIMangledName");
2284        _writePair(
2285            builder,
2286            indent,
2287            "this",
2288            Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2289        _writePair(
2290            builder,
2291            indent,
2292            "type",
2293            Slang::StringUtil::makeStringWithFormat("0x%llX", typeId));
2294        _writePairNoComma(
2295            builder,
2296            indent,
2297            "outNameBlobId",
2298            Slang::StringUtil::makeStringWithFormat("0x%llX", outNameBlobId));
2299    }
2300
2301    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2302    m_fileStream.flush();
2303}
2304
2305void JsonConsumer::ISession_getTypeConformanceWitnessMangledName(
2306    ObjectID objectId,
2307    ObjectID typeId,
2308    ObjectID interfaceTypeId,
2309    ObjectID outNameBlobId)
2310{
2311    SANITY_CHECK();
2312    Slang::StringBuilder builder;
2313    int indent = 0;
2314
2315    {
2316        ScopeWritterForKey scopeWritter(
2317            &builder,
2318            &indent,
2319            "ISession::getTypeConformanceWitnessMangledName");
2320        _writePair(
2321            builder,
2322            indent,
2323            "this",
2324            Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2325        _writePair(
2326            builder,
2327            indent,
2328            "type",
2329            Slang::StringUtil::makeStringWithFormat("0x%llX", typeId));
2330        _writePair(
2331            builder,
2332            indent,
2333            "interfaceType",
2334            Slang::StringUtil::makeStringWithFormat("0x%llX", interfaceTypeId));
2335        _writePairNoComma(
2336            builder,
2337            indent,
2338            "outNameBlobId",
2339            Slang::StringUtil::makeStringWithFormat("0x%llX", outNameBlobId));
2340    }
2341
2342    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2343    m_fileStream.flush();
2344}
2345
2346
2347void JsonConsumer::ISession_getTypeConformanceWitnessSequentialID(
2348    ObjectID objectId,
2349    ObjectID typeId,
2350    ObjectID interfaceTypeId,
2351    uint32_t outId)
2352{
2353    SANITY_CHECK();
2354    Slang::StringBuilder builder;
2355    int indent = 0;
2356
2357    {
2358        ScopeWritterForKey scopeWritter(
2359            &builder,
2360            &indent,
2361            "ISession::getTypeConformanceWitnessSequentialID");
2362        _writePair(
2363            builder,
2364            indent,
2365            "this",
2366            Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2367        _writePairNoComma(
2368            builder,
2369            indent,
2370            "type",
2371            Slang::StringUtil::makeStringWithFormat("0x%llX", typeId));
2372    }
2373
2374    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2375    m_fileStream.flush();
2376}
2377
2378void JsonConsumer::ISession_createTypeConformanceComponentType(
2379    ObjectID objectId,
2380    ObjectID typeId,
2381    ObjectID interfaceTypeId,
2382    ObjectID outConformanceId,
2383    SlangInt conformanceIdOverride,
2384    ObjectID outDiagnosticsId)
2385{
2386    SANITY_CHECK();
2387    Slang::StringBuilder builder;
2388    int indent = 0;
2389
2390    {
2391        ScopeWritterForKey scopeWritter(
2392            &builder,
2393            &indent,
2394            "ISession::createTypeConformanceComponentType");
2395        _writePair(
2396            builder,
2397            indent,
2398            "this",
2399            Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2400        _writePair(
2401            builder,
2402            indent,
2403            "type",
2404            Slang::StringUtil::makeStringWithFormat("0x%llX", typeId));
2405        _writePair(
2406            builder,
2407            indent,
2408            "interfaceTypeId",
2409            Slang::StringUtil::makeStringWithFormat("0x%llX", interfaceTypeId));
2410        _writePair(
2411            builder,
2412            indent,
2413            "outConformanceId",
2414            Slang::StringUtil::makeStringWithFormat("0x%llX", outConformanceId));
2415        _writePair(builder, indent, "conformanceIdOverride", conformanceIdOverride);
2416        _writePairNoComma(
2417            builder,
2418            indent,
2419            "outDiagnosticsId",
2420            Slang::StringUtil::makeStringWithFormat("0x%llX", typeId));
2421    }
2422
2423    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2424    m_fileStream.flush();
2425}
2426
2427
2428void JsonConsumer::ISession_createCompileRequest(ObjectID objectId, ObjectID outCompileRequestId)
2429{
2430    SANITY_CHECK();
2431    Slang::StringBuilder builder;
2432    int indent = 0;
2433
2434    {
2435        ScopeWritterForKey scopeWritter(&builder, &indent, "ISession::createCompileRequest");
2436        {
2437            _writePair(
2438                builder,
2439                indent,
2440                "this",
2441                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2442            _writePair(builder, indent, "outCompileRequest", outCompileRequestId);
2443        }
2444    }
2445
2446    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2447    m_fileStream.flush();
2448}
2449
2450
2451void JsonConsumer::ISession_getLoadedModule(ObjectID objectId, SlangInt index, ObjectID outModuleId)
2452{
2453    SANITY_CHECK();
2454    Slang::StringBuilder builder;
2455    int indent = 0;
2456
2457    {
2458        ScopeWritterForKey scopeWritter(&builder, &indent, "ISession::getLoadedModule");
2459        {
2460            _writePair(
2461                builder,
2462                indent,
2463                "this",
2464                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2465            _writePair(builder, indent, "index", index);
2466            _writePairNoComma(
2467                builder,
2468                indent,
2469                "retModule",
2470                Slang::StringUtil::makeStringWithFormat("0x%llX", outModuleId));
2471        }
2472    }
2473
2474    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2475    m_fileStream.flush();
2476}
2477
2478
2479// IModule
2480void JsonConsumer::IModule_findEntryPointByName(
2481    ObjectID objectId,
2482    char const* name,
2483    ObjectID outEntryPointId)
2484{
2485    SANITY_CHECK();
2486    Slang::StringBuilder builder;
2487    int indent = 0;
2488
2489    {
2490        ScopeWritterForKey scopeWritter(&builder, &indent, "IModule::findEntryPointByName");
2491        {
2492            _writePair(
2493                builder,
2494                indent,
2495                "this",
2496                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2497            _writePair(
2498                builder,
2499                indent,
2500                "name",
2501                Slang::StringUtil::makeStringWithFormat(
2502                    "\"%s\"",
2503                    name != nullptr ? name : "nullptr"));
2504
2505            _writePairNoComma(
2506                builder,
2507                indent,
2508                "outEntryPoint",
2509                Slang::StringUtil::makeStringWithFormat("0x%llX", outEntryPointId));
2510        }
2511    }
2512
2513    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2514    m_fileStream.flush();
2515}
2516
2517
2518void JsonConsumer::IModule_getDefinedEntryPoint(
2519    ObjectID objectId,
2520    SlangInt32 index,
2521    ObjectID outEntryPointId)
2522{
2523    SANITY_CHECK();
2524    Slang::StringBuilder builder;
2525    int indent = 0;
2526
2527    {
2528        ScopeWritterForKey scopeWritter(&builder, &indent, "IModule::getDefinedEntryPoint");
2529        {
2530            _writePair(
2531                builder,
2532                indent,
2533                "this",
2534                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2535            _writePair(builder, indent, "index", index);
2536            _writePairNoComma(
2537                builder,
2538                indent,
2539                "outEntryPoint",
2540                Slang::StringUtil::makeStringWithFormat("0x%llX", outEntryPointId));
2541        }
2542    }
2543
2544    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2545    m_fileStream.flush();
2546}
2547
2548
2549void JsonConsumer::IModule_serialize(ObjectID objectId, ObjectID outSerializedBlobId)
2550{
2551    SANITY_CHECK();
2552    Slang::StringBuilder builder;
2553    int indent = 0;
2554
2555    {
2556        ScopeWritterForKey scopeWritter(&builder, &indent, "IModule::serialize");
2557        {
2558            _writePair(
2559                builder,
2560                indent,
2561                "this",
2562                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2563            _writePairNoComma(builder, indent, "outSerializedBlob", outSerializedBlobId);
2564        }
2565    }
2566
2567    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2568    m_fileStream.flush();
2569}
2570
2571
2572void JsonConsumer::IModule_writeToFile(ObjectID objectId, char const* fileName)
2573{
2574    SANITY_CHECK();
2575    Slang::StringBuilder builder;
2576    int indent = 0;
2577
2578    {
2579        ScopeWritterForKey scopeWritter(&builder, &indent, "IModule::writeToFile");
2580        {
2581            _writePair(
2582                builder,
2583                indent,
2584                "this",
2585                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2586            _writePairNoComma(
2587                builder,
2588                indent,
2589                "fileName",
2590                Slang::StringUtil::makeStringWithFormat(
2591                    "\"%s\"",
2592                    fileName != nullptr ? fileName : "nullptr"));
2593        }
2594    }
2595
2596    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2597    m_fileStream.flush();
2598}
2599
2600
2601void JsonConsumer::IModule_findAndCheckEntryPoint(
2602    ObjectID objectId,
2603    char const* name,
2604    SlangStage stage,
2605    ObjectID outEntryPointId,
2606    ObjectID outDiagnostics)
2607{
2608    SANITY_CHECK();
2609    Slang::StringBuilder builder;
2610    int indent = 0;
2611
2612    {
2613        ScopeWritterForKey scopeWritter(&builder, &indent, "IModule::findAndCheckEntryPoint");
2614        {
2615            _writePair(
2616                builder,
2617                indent,
2618                "this",
2619                Slang::StringUtil::makeStringWithFormat("0x%llX", objectId));
2620            _writePair(
2621                builder,
2622                indent,
2623                "name",
2624                Slang::StringUtil::makeStringWithFormat(
2625                    "\"%s\"",
2626                    name != nullptr ? name : "nullptr"));
2627            _writePair(builder, indent, "stage", SlangStageToString(stage));
2628            _writePair(
2629                builder,
2630                indent,
2631                "outEntryPoint",
2632                Slang::StringUtil::makeStringWithFormat("0x%llX", outEntryPointId));
2633            _writePairNoComma(
2634                builder,
2635                indent,
2636                "outDiagnostics",
2637                Slang::StringUtil::makeStringWithFormat("0x%llX", outDiagnostics));
2638        }
2639    }
2640
2641    m_fileStream.write(builder.produceString().begin(), builder.produceString().getLength());
2642    m_fileStream.flush();
2643}
2644
2645void JsonConsumer::IModule_getSession(ObjectID objectId, ObjectID outSessionId)
2646{
2647    SANITY_CHECK();
2648    m_moduleHelper.getSession(objectId, outSessionId);
2649}
2650
2651void JsonConsumer::IModule_getLayout(
2652    ObjectID objectId,
2653    SlangInt targetIndex,
2654    ObjectID outDiagnosticsId,
2655    ObjectID retProgramLayoutId)
2656{
2657    SANITY_CHECK();
2658    m_moduleHelper.getLayout(objectId, targetIndex, outDiagnosticsId, retProgramLayoutId);
2659}
2660
2661
2662void JsonConsumer::IModule_getEntryPointCode(
2663    ObjectID objectId,
2664    SlangInt entryPointIndex,
2665    SlangInt targetIndex,
2666    ObjectID outCodeId,
2667    ObjectID outDiagnosticsId)
2668{
2669    SANITY_CHECK();
2670    m_moduleHelper
2671        .getEntryPointCode(objectId, entryPointIndex, targetIndex, outCodeId, outDiagnosticsId);
2672}
2673
2674
2675void JsonConsumer::IModule_getTargetCode(
2676    ObjectID objectId,
2677    SlangInt targetIndex,
2678    ObjectID outCodeId,
2679    ObjectID outDiagnosticsId)
2680{
2681    SANITY_CHECK();
2682    m_moduleHelper.getTargetCode(objectId, targetIndex, outCodeId, outDiagnosticsId);
2683}
2684
2685
2686void JsonConsumer::IModule_getResultAsFileSystem(
2687    ObjectID objectId,
2688    SlangInt entryPointIndex,
2689    SlangInt targetIndex,
2690    ObjectID outFileSystemId)
2691{
2692    SANITY_CHECK();
2693    m_moduleHelper.getResultAsFileSystem(objectId, entryPointIndex, targetIndex, outFileSystemId);
2694}
2695
2696
2697void JsonConsumer::IModule_getEntryPointHash(
2698    ObjectID objectId,
2699    SlangInt entryPointIndex,
2700    SlangInt targetIndex,
2701    ObjectID outHashId)
2702{
2703    SANITY_CHECK();
2704    m_moduleHelper.getEntryPointHash(objectId, entryPointIndex, targetIndex, outHashId);
2705}
2706
2707
2708void JsonConsumer::IModule_specialize(
2709    ObjectID objectId,
2710    slang::SpecializationArg const* specializationArgs,
2711    SlangInt specializationArgCount,
2712    ObjectID outSpecializedComponentTypeId,
2713    ObjectID outDiagnosticsId)
2714{
2715    SANITY_CHECK();
2716    m_moduleHelper.specialize(
2717        objectId,
2718        specializationArgs,
2719        specializationArgCount,
2720        outSpecializedComponentTypeId,
2721        outDiagnosticsId);
2722}
2723
2724
2725void JsonConsumer::IModule_link(
2726    ObjectID objectId,
2727    ObjectID outLinkedComponentTypeId,
2728    ObjectID outDiagnosticsId)
2729{
2730    SANITY_CHECK();
2731    m_moduleHelper.link(objectId, outLinkedComponentTypeId, outDiagnosticsId);
2732}
2733
2734
2735void JsonConsumer::IModule_getEntryPointHostCallable(
2736    ObjectID objectId,
2737    int entryPointIndex,
2738    int targetIndex,
2739    ObjectID outSharedLibraryId,
2740    ObjectID outDiagnosticsId)
2741{
2742    SANITY_CHECK();
2743    m_moduleHelper.getEntryPointHostCallable(
2744        objectId,
2745        entryPointIndex,
2746        targetIndex,
2747        outSharedLibraryId,
2748        outDiagnosticsId);
2749}
2750
2751
2752void JsonConsumer::IModule_renameEntryPoint(
2753    ObjectID objectId,
2754    const char* newName,
2755    ObjectID outEntryPointId)
2756{
2757    SANITY_CHECK();
2758    m_moduleHelper.renameEntryPoint(objectId, newName, outEntryPointId);
2759}
2760
2761
2762void JsonConsumer::IModule_linkWithOptions(
2763    ObjectID objectId,
2764    ObjectID outLinkedComponentTypeId,
2765    uint32_t compilerOptionEntryCount,
2766    slang::CompilerOptionEntry* compilerOptionEntries,
2767    ObjectID outDiagnosticsId)
2768{
2769    SANITY_CHECK();
2770    m_moduleHelper.linkWithOptions(
2771        objectId,
2772        outLinkedComponentTypeId,
2773        compilerOptionEntryCount,
2774        compilerOptionEntries,
2775        outDiagnosticsId);
2776}
2777
2778// IEntryPoint
2779void JsonConsumer::IEntryPoint_getSession(ObjectID objectId, ObjectID outSessionId)
2780{
2781    SANITY_CHECK();
2782    m_entryPointHelper.getSession(objectId, outSessionId);
2783}
2784
2785
2786void JsonConsumer::IEntryPoint_getLayout(
2787    ObjectID objectId,
2788    SlangInt targetIndex,
2789    ObjectID outDiagnosticsId,
2790    ObjectID retProgramLayoutId)
2791{
2792    SANITY_CHECK();
2793    m_entryPointHelper.getLayout(objectId, targetIndex, outDiagnosticsId, retProgramLayoutId);
2794}
2795
2796
2797void JsonConsumer::IEntryPoint_getEntryPointCode(
2798    ObjectID objectId,
2799    SlangInt entryPointIndex,
2800    SlangInt targetIndex,
2801    ObjectID outCodeId,
2802    ObjectID outDiagnosticsId)
2803{
2804    SANITY_CHECK();
2805    m_entryPointHelper
2806        .getEntryPointCode(objectId, entryPointIndex, targetIndex, outCodeId, outDiagnosticsId);
2807}
2808
2809
2810void JsonConsumer::IEntryPoint_getTargetCode(
2811    ObjectID objectId,
2812    SlangInt targetIndex,
2813    ObjectID outCodeId,
2814    ObjectID outDiagnosticsId)
2815{
2816    SANITY_CHECK();
2817    m_entryPointHelper.getTargetCode(objectId, targetIndex, outCodeId, outDiagnosticsId);
2818}
2819
2820
2821void JsonConsumer::IEntryPoint_getResultAsFileSystem(
2822    ObjectID objectId,
2823    SlangInt entryPointIndex,
2824    SlangInt targetIndex,
2825    ObjectID outFileSystem)
2826{
2827    SANITY_CHECK();
2828    m_entryPointHelper.getResultAsFileSystem(objectId, entryPointIndex, targetIndex, outFileSystem);
2829}
2830
2831
2832void JsonConsumer::IEntryPoint_getEntryPointHash(
2833    ObjectID objectId,
2834    SlangInt entryPointIndex,
2835    SlangInt targetIndex,
2836    ObjectID outHashId)
2837{
2838    SANITY_CHECK();
2839    m_entryPointHelper.getEntryPointHash(objectId, entryPointIndex, targetIndex, outHashId);
2840}
2841
2842
2843void JsonConsumer::IEntryPoint_specialize(
2844    ObjectID objectId,
2845    slang::SpecializationArg const* specializationArgs,
2846    SlangInt specializationArgCount,
2847    ObjectID outSpecializedComponentTypeId,
2848    ObjectID outDiagnosticsId)
2849{
2850    SANITY_CHECK();
2851    m_entryPointHelper.specialize(
2852        objectId,
2853        specializationArgs,
2854        specializationArgCount,
2855        outSpecializedComponentTypeId,
2856        outDiagnosticsId);
2857}
2858
2859
2860void JsonConsumer::IEntryPoint_link(
2861    ObjectID objectId,
2862    ObjectID outLinkedComponentTypeId,
2863    ObjectID outDiagnosticsId)
2864{
2865    SANITY_CHECK();
2866    m_entryPointHelper.link(objectId, outLinkedComponentTypeId, outDiagnosticsId);
2867}
2868
2869
2870void JsonConsumer::IEntryPoint_getEntryPointHostCallable(
2871    ObjectID objectId,
2872    int entryPointIndex,
2873    int targetIndex,
2874    ObjectID outSharedLibrary,
2875    ObjectID outDiagnostics)
2876{
2877    SANITY_CHECK();
2878    m_entryPointHelper.getEntryPointHostCallable(
2879        objectId,
2880        entryPointIndex,
2881        targetIndex,
2882        outSharedLibrary,
2883        outDiagnostics);
2884}
2885
2886
2887void JsonConsumer::IEntryPoint_renameEntryPoint(
2888    ObjectID objectId,
2889    const char* newName,
2890    ObjectID outEntryPointId)
2891{
2892    SANITY_CHECK();
2893    m_entryPointHelper.renameEntryPoint(objectId, newName, outEntryPointId);
2894}
2895
2896
2897void JsonConsumer::IEntryPoint_linkWithOptions(
2898    ObjectID objectId,
2899    ObjectID outLinkedComponentTypeId,
2900    uint32_t compilerOptionEntryCount,
2901    slang::CompilerOptionEntry* compilerOptionEntries,
2902    ObjectID outDiagnosticsId)
2903{
2904    SANITY_CHECK();
2905    m_entryPointHelper.linkWithOptions(
2906        objectId,
2907        outLinkedComponentTypeId,
2908        compilerOptionEntryCount,
2909        compilerOptionEntries,
2910        outDiagnosticsId);
2911}
2912
2913
2914// ICompositeComponentType
2915void JsonConsumer::ICompositeComponentType_getSession(ObjectID objectId, ObjectID outSessionId)
2916{
2917    SANITY_CHECK();
2918    m_compositeComponentTypeHelper.getSession(objectId, outSessionId);
2919}
2920
2921
2922void JsonConsumer::ICompositeComponentType_getLayout(
2923    ObjectID objectId,
2924    SlangInt targetIndex,
2925    ObjectID outDiagnosticsId,
2926    ObjectID retProgramLayoutId)
2927{
2928    SANITY_CHECK();
2929    m_compositeComponentTypeHelper
2930        .getLayout(objectId, targetIndex, outDiagnosticsId, retProgramLayoutId);
2931}
2932
2933
2934void JsonConsumer::ICompositeComponentType_getEntryPointCode(
2935    ObjectID objectId,
2936    SlangInt entryPointIndex,
2937    SlangInt targetIndex,
2938    ObjectID outCodeId,
2939    ObjectID outDiagnosticsId)
2940{
2941    SANITY_CHECK();
2942    m_compositeComponentTypeHelper
2943        .getEntryPointCode(objectId, entryPointIndex, targetIndex, outCodeId, outDiagnosticsId);
2944}
2945
2946
2947void JsonConsumer::ICompositeComponentType_getTargetCode(
2948    ObjectID objectId,
2949    SlangInt targetIndex,
2950    ObjectID outCodeId,
2951    ObjectID outDiagnosticsId)
2952{
2953    SANITY_CHECK();
2954    m_compositeComponentTypeHelper
2955        .getTargetCode(objectId, targetIndex, outCodeId, outDiagnosticsId);
2956}
2957
2958
2959void JsonConsumer::ICompositeComponentType_getResultAsFileSystem(
2960    ObjectID objectId,
2961    SlangInt entryPointIndex,
2962    SlangInt targetIndex,
2963    ObjectID outFileSystem)
2964{
2965    SANITY_CHECK();
2966    m_compositeComponentTypeHelper
2967        .getResultAsFileSystem(objectId, entryPointIndex, targetIndex, outFileSystem);
2968}
2969
2970
2971void JsonConsumer::ICompositeComponentType_getEntryPointHash(
2972    ObjectID objectId,
2973    SlangInt entryPointIndex,
2974    SlangInt targetIndex,
2975    ObjectID outHashId)
2976{
2977    SANITY_CHECK();
2978    m_compositeComponentTypeHelper
2979        .getEntryPointHash(objectId, entryPointIndex, targetIndex, outHashId);
2980}
2981
2982
2983void JsonConsumer::ICompositeComponentType_specialize(
2984    ObjectID objectId,
2985    slang::SpecializationArg const* specializationArgs,
2986    SlangInt specializationArgCount,
2987    ObjectID outSpecializedComponentTypeId,
2988    ObjectID outDiagnosticsId)
2989{
2990    SANITY_CHECK();
2991    m_compositeComponentTypeHelper.specialize(
2992        objectId,
2993        specializationArgs,
2994        specializationArgCount,
2995        outSpecializedComponentTypeId,
2996        outDiagnosticsId);
2997}
2998
2999
3000void JsonConsumer::ICompositeComponentType_link(
3001    ObjectID objectId,
3002    ObjectID outLinkedComponentTypeId,
3003    ObjectID outDiagnosticsId)
3004{
3005    SANITY_CHECK();
3006    m_compositeComponentTypeHelper.link(objectId, outLinkedComponentTypeId, outDiagnosticsId);
3007}
3008
3009
3010void JsonConsumer::ICompositeComponentType_getEntryPointHostCallable(
3011    ObjectID objectId,
3012    int entryPointIndex,
3013    int targetIndex,
3014    ObjectID outSharedLibrary,
3015    ObjectID outDiagnostics)
3016{
3017    SANITY_CHECK();
3018    m_compositeComponentTypeHelper.getEntryPointHostCallable(
3019        objectId,
3020        entryPointIndex,
3021        targetIndex,
3022        outSharedLibrary,
3023        outDiagnostics);
3024}
3025
3026
3027void JsonConsumer::ICompositeComponentType_renameEntryPoint(
3028    ObjectID objectId,
3029    const char* newName,
3030    ObjectID outEntryPointId)
3031{
3032    SANITY_CHECK();
3033    m_compositeComponentTypeHelper.renameEntryPoint(objectId, newName, outEntryPointId);
3034}
3035
3036
3037void JsonConsumer::ICompositeComponentType_linkWithOptions(
3038    ObjectID objectId,
3039    ObjectID outLinkedComponentTypeId,
3040    uint32_t compilerOptionEntryCount,
3041    slang::CompilerOptionEntry* compilerOptionEntries,
3042    ObjectID outDiagnosticsId)
3043{
3044    SANITY_CHECK();
3045    m_compositeComponentTypeHelper.linkWithOptions(
3046        objectId,
3047        outLinkedComponentTypeId,
3048        compilerOptionEntryCount,
3049        compilerOptionEntries,
3050        outDiagnosticsId);
3051}
3052
3053void JsonConsumer::ICompositeComponentType_queryInterface(
3054    ObjectID objectId,
3055    const SlangUUID& guid,
3056    ObjectID outInterfaceId)
3057{
3058    SANITY_CHECK();
3059    m_compositeComponentTypeHelper.queryInterface(objectId, guid, outInterfaceId);
3060}
3061
3062// ITypeConformance
3063void JsonConsumer::ITypeConformance_getSession(ObjectID objectId, ObjectID outSessionId)
3064{
3065    SANITY_CHECK();
3066    m_typeConformanceHelper.getSession(objectId, outSessionId);
3067}
3068
3069
3070void JsonConsumer::ITypeConformance_getLayout(
3071    ObjectID objectId,
3072    SlangInt targetIndex,
3073    ObjectID outDiagnosticsId,
3074    ObjectID retProgramLayoutId)
3075{
3076    SANITY_CHECK();
3077    m_typeConformanceHelper.getLayout(objectId, targetIndex, outDiagnosticsId, retProgramLayoutId);
3078}
3079
3080
3081void JsonConsumer::ITypeConformance_getEntryPointCode(
3082    ObjectID objectId,
3083    SlangInt entryPointIndex,
3084    SlangInt targetIndex,
3085    ObjectID outCodeId,
3086    ObjectID outDiagnosticsId)
3087{
3088    SANITY_CHECK();
3089    m_typeConformanceHelper
3090        .getEntryPointCode(objectId, entryPointIndex, targetIndex, outCodeId, outDiagnosticsId);
3091}
3092
3093
3094void JsonConsumer::ITypeConformance_getTargetCode(
3095    ObjectID objectId,
3096    SlangInt targetIndex,
3097    ObjectID outCodeId,
3098    ObjectID outDiagnosticsId)
3099{
3100    SANITY_CHECK();
3101    m_typeConformanceHelper.getTargetCode(objectId, targetIndex, outCodeId, outDiagnosticsId);
3102}
3103
3104
3105void JsonConsumer::ITypeConformance_getResultAsFileSystem(
3106    ObjectID objectId,
3107    SlangInt entryPointIndex,
3108    SlangInt targetIndex,
3109    ObjectID outFileSystem)
3110{
3111    SANITY_CHECK();
3112    m_typeConformanceHelper
3113        .getResultAsFileSystem(objectId, entryPointIndex, targetIndex, outFileSystem);
3114}
3115
3116
3117void JsonConsumer::ITypeConformance_getEntryPointHash(
3118    ObjectID objectId,
3119    SlangInt entryPointIndex,
3120    SlangInt targetIndex,
3121    ObjectID outHashId)
3122{
3123    SANITY_CHECK();
3124    m_typeConformanceHelper.getEntryPointHash(objectId, entryPointIndex, targetIndex, outHashId);
3125}
3126
3127
3128void JsonConsumer::ITypeConformance_specialize(
3129    ObjectID objectId,
3130    slang::SpecializationArg const* specializationArgs,
3131    SlangInt specializationArgCount,
3132    ObjectID outSpecializedComponentTypeId,
3133    ObjectID outDiagnosticsId)
3134{
3135    SANITY_CHECK();
3136    m_typeConformanceHelper.specialize(
3137        objectId,
3138        specializationArgs,
3139        specializationArgCount,
3140        outSpecializedComponentTypeId,
3141        outDiagnosticsId);
3142}
3143
3144
3145void JsonConsumer::ITypeConformance_link(
3146    ObjectID objectId,
3147    ObjectID outLinkedComponentTypeId,
3148    ObjectID outDiagnosticsId)
3149{
3150    SANITY_CHECK();
3151    m_typeConformanceHelper.link(objectId, outLinkedComponentTypeId, outDiagnosticsId);
3152}
3153
3154
3155void JsonConsumer::ITypeConformance_getEntryPointHostCallable(
3156    ObjectID objectId,
3157    int entryPointIndex,
3158    int targetIndex,
3159    ObjectID outSharedLibrary,
3160    ObjectID outDiagnostics)
3161{
3162    SANITY_CHECK();
3163    m_typeConformanceHelper.getEntryPointHostCallable(
3164        objectId,
3165        entryPointIndex,
3166        targetIndex,
3167        outSharedLibrary,
3168        outDiagnostics);
3169}
3170
3171
3172void JsonConsumer::ITypeConformance_renameEntryPoint(
3173    ObjectID objectId,
3174    const char* newName,
3175    ObjectID outEntryPointId)
3176{
3177    SANITY_CHECK();
3178    m_typeConformanceHelper.renameEntryPoint(objectId, newName, outEntryPointId);
3179}
3180
3181
3182void JsonConsumer::ITypeConformance_linkWithOptions(
3183    ObjectID objectId,
3184    ObjectID outLinkedComponentTypeId,
3185    uint32_t compilerOptionEntryCount,
3186    slang::CompilerOptionEntry* compilerOptionEntries,
3187    ObjectID outDiagnosticsId)
3188{
3189    SANITY_CHECK();
3190    m_typeConformanceHelper.linkWithOptions(
3191        objectId,
3192        outLinkedComponentTypeId,
3193        compilerOptionEntryCount,
3194        compilerOptionEntries,
3195        outDiagnosticsId);
3196}
3197
3198void JsonConsumer::IComponentType2_getTargetCompileResult(
3199    ObjectID objectId,
3200    SlangInt targetIndex,
3201    ObjectID outCompileResultId,
3202    ObjectID outDiagnosticsId)
3203{
3204    SANITY_CHECK();
3205    m_componentType2Helper
3206        .getTargetCompileResult(objectId, targetIndex, outCompileResultId, outDiagnosticsId);
3207}
3208
3209void JsonConsumer::IComponentType2_getEntryPointCompileResult(
3210    ObjectID objectId,
3211    SlangInt entryPointIndex,
3212    SlangInt targetIndex,
3213    ObjectID outCompileResultId,
3214    ObjectID outDiagnosticsId)
3215{
3216    SANITY_CHECK();
3217    m_componentType2Helper.getEntryPointCompileResult(
3218        objectId,
3219        entryPointIndex,
3220        targetIndex,
3221        outCompileResultId,
3222        outDiagnosticsId);
3223}
3224}; // namespace SlangRecord