tracel_rspirv/dr/
autogen_nonsemantic_shader_debuginfo_100.rs

1// AUTOMATICALLY GENERATED from the SPIR-V JSON grammar:
2//   external/spirv.core.grammar.json.
3// DO NOT MODIFY!
4
5use crate::{
6    dr::{self, Builder},
7    spirv,
8};
9impl Builder {
10    #[allow(clippy::too_many_arguments)]
11    pub fn shader_debug_info_none(&mut self) -> spirv::Word {
12        self.shader_debug_info_none_id(None)
13    }
14    #[allow(clippy::too_many_arguments)]
15    pub fn shader_debug_info_none_id(&mut self, result_id: Option<spirv::Word>) -> spirv::Word {
16        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
17        let result_type = self.type_void();
18        let mut inst = dr::Instruction::new(
19            spirv::Op::ExtInst,
20            Some(result_type),
21            result_id,
22            vec![
23                dr::Operand::IdRef(extension_set),
24                dr::Operand::LiteralExtInstInteger(
25                    crate::spirv::DebugInfoOp::DebugInfoNone as spirv::Word,
26                ),
27            ],
28        );
29        if let Some(id) = inst.result_id {
30            self.module_mut().types_global_values.push(inst);
31            id
32        } else if let Some(id) = self.dedup_insert_type(&inst) {
33            id
34        } else {
35            let id = self.id();
36            inst.result_id = Some(id);
37            self.module_mut().types_global_values.push(inst);
38            id
39        }
40    }
41    #[allow(clippy::too_many_arguments)]
42    pub fn shader_debug_compilation_unit(
43        &mut self,
44        version: spirv::Word,
45        dwarf_version: spirv::Word,
46        source: spirv::Word,
47        language: spirv::Word,
48    ) -> spirv::Word {
49        self.shader_debug_compilation_unit_id(None, version, dwarf_version, source, language)
50    }
51    #[allow(clippy::too_many_arguments)]
52    pub fn shader_debug_compilation_unit_id(
53        &mut self,
54        result_id: Option<spirv::Word>,
55        version: spirv::Word,
56        dwarf_version: spirv::Word,
57        source: spirv::Word,
58        language: spirv::Word,
59    ) -> spirv::Word {
60        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
61        let result_type = self.type_void();
62        let mut inst = dr::Instruction::new(
63            spirv::Op::ExtInst,
64            Some(result_type),
65            result_id,
66            vec![
67                dr::Operand::IdRef(extension_set),
68                dr::Operand::LiteralExtInstInteger(
69                    crate::spirv::DebugInfoOp::DebugCompilationUnit as spirv::Word,
70                ),
71                dr::Operand::IdRef(version),
72                dr::Operand::IdRef(dwarf_version),
73                dr::Operand::IdRef(source),
74                dr::Operand::IdRef(language),
75            ],
76        );
77        if let Some(id) = inst.result_id {
78            self.module_mut().types_global_values.push(inst);
79            id
80        } else if let Some(id) = self.dedup_insert_type(&inst) {
81            id
82        } else {
83            let id = self.id();
84            inst.result_id = Some(id);
85            self.module_mut().types_global_values.push(inst);
86            id
87        }
88    }
89    #[allow(clippy::too_many_arguments)]
90    pub fn shader_debug_type_basic(
91        &mut self,
92        name: spirv::Word,
93        size: spirv::Word,
94        encoding: spirv::Word,
95        flags: spirv::Word,
96    ) -> spirv::Word {
97        self.shader_debug_type_basic_id(None, name, size, encoding, flags)
98    }
99    #[allow(clippy::too_many_arguments)]
100    pub fn shader_debug_type_basic_id(
101        &mut self,
102        result_id: Option<spirv::Word>,
103        name: spirv::Word,
104        size: spirv::Word,
105        encoding: spirv::Word,
106        flags: spirv::Word,
107    ) -> spirv::Word {
108        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
109        let result_type = self.type_void();
110        let mut inst = dr::Instruction::new(
111            spirv::Op::ExtInst,
112            Some(result_type),
113            result_id,
114            vec![
115                dr::Operand::IdRef(extension_set),
116                dr::Operand::LiteralExtInstInteger(
117                    crate::spirv::DebugInfoOp::DebugTypeBasic as spirv::Word,
118                ),
119                dr::Operand::IdRef(name),
120                dr::Operand::IdRef(size),
121                dr::Operand::IdRef(encoding),
122                dr::Operand::IdRef(flags),
123            ],
124        );
125        if let Some(id) = inst.result_id {
126            self.module_mut().types_global_values.push(inst);
127            id
128        } else if let Some(id) = self.dedup_insert_type(&inst) {
129            id
130        } else {
131            let id = self.id();
132            inst.result_id = Some(id);
133            self.module_mut().types_global_values.push(inst);
134            id
135        }
136    }
137    #[allow(clippy::too_many_arguments)]
138    pub fn shader_debug_type_pointer(
139        &mut self,
140        base_type: spirv::Word,
141        storage_class: spirv::Word,
142        flags: spirv::Word,
143    ) -> spirv::Word {
144        self.shader_debug_type_pointer_id(None, base_type, storage_class, flags)
145    }
146    #[allow(clippy::too_many_arguments)]
147    pub fn shader_debug_type_pointer_id(
148        &mut self,
149        result_id: Option<spirv::Word>,
150        base_type: spirv::Word,
151        storage_class: spirv::Word,
152        flags: spirv::Word,
153    ) -> spirv::Word {
154        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
155        let result_type = self.type_void();
156        let mut inst = dr::Instruction::new(
157            spirv::Op::ExtInst,
158            Some(result_type),
159            result_id,
160            vec![
161                dr::Operand::IdRef(extension_set),
162                dr::Operand::LiteralExtInstInteger(
163                    crate::spirv::DebugInfoOp::DebugTypePointer as spirv::Word,
164                ),
165                dr::Operand::IdRef(base_type),
166                dr::Operand::IdRef(storage_class),
167                dr::Operand::IdRef(flags),
168            ],
169        );
170        if let Some(id) = inst.result_id {
171            self.module_mut().types_global_values.push(inst);
172            id
173        } else if let Some(id) = self.dedup_insert_type(&inst) {
174            id
175        } else {
176            let id = self.id();
177            inst.result_id = Some(id);
178            self.module_mut().types_global_values.push(inst);
179            id
180        }
181    }
182    #[allow(clippy::too_many_arguments)]
183    pub fn shader_debug_type_qualifier(
184        &mut self,
185        base_type: spirv::Word,
186        type_qualifier: spirv::Word,
187    ) -> spirv::Word {
188        self.shader_debug_type_qualifier_id(None, base_type, type_qualifier)
189    }
190    #[allow(clippy::too_many_arguments)]
191    pub fn shader_debug_type_qualifier_id(
192        &mut self,
193        result_id: Option<spirv::Word>,
194        base_type: spirv::Word,
195        type_qualifier: spirv::Word,
196    ) -> spirv::Word {
197        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
198        let result_type = self.type_void();
199        let mut inst = dr::Instruction::new(
200            spirv::Op::ExtInst,
201            Some(result_type),
202            result_id,
203            vec![
204                dr::Operand::IdRef(extension_set),
205                dr::Operand::LiteralExtInstInteger(
206                    crate::spirv::DebugInfoOp::DebugTypeQualifier as spirv::Word,
207                ),
208                dr::Operand::IdRef(base_type),
209                dr::Operand::IdRef(type_qualifier),
210            ],
211        );
212        if let Some(id) = inst.result_id {
213            self.module_mut().types_global_values.push(inst);
214            id
215        } else if let Some(id) = self.dedup_insert_type(&inst) {
216            id
217        } else {
218            let id = self.id();
219            inst.result_id = Some(id);
220            self.module_mut().types_global_values.push(inst);
221            id
222        }
223    }
224    #[allow(clippy::too_many_arguments)]
225    pub fn shader_debug_type_array(
226        &mut self,
227        base_type: spirv::Word,
228        component_counts: impl IntoIterator<Item = spirv::Word>,
229    ) -> spirv::Word {
230        self.shader_debug_type_array_id(None, base_type, component_counts)
231    }
232    #[allow(clippy::too_many_arguments)]
233    pub fn shader_debug_type_array_id(
234        &mut self,
235        result_id: Option<spirv::Word>,
236        base_type: spirv::Word,
237        component_counts: impl IntoIterator<Item = spirv::Word>,
238    ) -> spirv::Word {
239        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
240        let result_type = self.type_void();
241        let mut inst = dr::Instruction::new(
242            spirv::Op::ExtInst,
243            Some(result_type),
244            result_id,
245            vec![
246                dr::Operand::IdRef(extension_set),
247                dr::Operand::LiteralExtInstInteger(
248                    crate::spirv::DebugInfoOp::DebugTypeArray as spirv::Word,
249                ),
250                dr::Operand::IdRef(base_type),
251            ],
252        );
253        inst.operands
254            .extend(component_counts.into_iter().map(dr::Operand::IdRef));
255        if let Some(id) = inst.result_id {
256            self.module_mut().types_global_values.push(inst);
257            id
258        } else if let Some(id) = self.dedup_insert_type(&inst) {
259            id
260        } else {
261            let id = self.id();
262            inst.result_id = Some(id);
263            self.module_mut().types_global_values.push(inst);
264            id
265        }
266    }
267    #[allow(clippy::too_many_arguments)]
268    pub fn shader_debug_type_vector(
269        &mut self,
270        base_type: spirv::Word,
271        component_count: spirv::Word,
272    ) -> spirv::Word {
273        self.shader_debug_type_vector_id(None, base_type, component_count)
274    }
275    #[allow(clippy::too_many_arguments)]
276    pub fn shader_debug_type_vector_id(
277        &mut self,
278        result_id: Option<spirv::Word>,
279        base_type: spirv::Word,
280        component_count: spirv::Word,
281    ) -> spirv::Word {
282        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
283        let result_type = self.type_void();
284        let mut inst = dr::Instruction::new(
285            spirv::Op::ExtInst,
286            Some(result_type),
287            result_id,
288            vec![
289                dr::Operand::IdRef(extension_set),
290                dr::Operand::LiteralExtInstInteger(
291                    crate::spirv::DebugInfoOp::DebugTypeVector as spirv::Word,
292                ),
293                dr::Operand::IdRef(base_type),
294                dr::Operand::IdRef(component_count),
295            ],
296        );
297        if let Some(id) = inst.result_id {
298            self.module_mut().types_global_values.push(inst);
299            id
300        } else if let Some(id) = self.dedup_insert_type(&inst) {
301            id
302        } else {
303            let id = self.id();
304            inst.result_id = Some(id);
305            self.module_mut().types_global_values.push(inst);
306            id
307        }
308    }
309    #[allow(clippy::too_many_arguments)]
310    pub fn shader_debug_typedef(
311        &mut self,
312        name: spirv::Word,
313        base_type: spirv::Word,
314        source: spirv::Word,
315        line: spirv::Word,
316        column: spirv::Word,
317        parent: spirv::Word,
318    ) -> spirv::Word {
319        self.shader_debug_typedef_id(None, name, base_type, source, line, column, parent)
320    }
321    #[allow(clippy::too_many_arguments)]
322    pub fn shader_debug_typedef_id(
323        &mut self,
324        result_id: Option<spirv::Word>,
325        name: spirv::Word,
326        base_type: spirv::Word,
327        source: spirv::Word,
328        line: spirv::Word,
329        column: spirv::Word,
330        parent: spirv::Word,
331    ) -> spirv::Word {
332        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
333        let result_type = self.type_void();
334        let mut inst = dr::Instruction::new(
335            spirv::Op::ExtInst,
336            Some(result_type),
337            result_id,
338            vec![
339                dr::Operand::IdRef(extension_set),
340                dr::Operand::LiteralExtInstInteger(
341                    crate::spirv::DebugInfoOp::DebugTypedef as spirv::Word,
342                ),
343                dr::Operand::IdRef(name),
344                dr::Operand::IdRef(base_type),
345                dr::Operand::IdRef(source),
346                dr::Operand::IdRef(line),
347                dr::Operand::IdRef(column),
348                dr::Operand::IdRef(parent),
349            ],
350        );
351        if let Some(id) = inst.result_id {
352            self.module_mut().types_global_values.push(inst);
353            id
354        } else if let Some(id) = self.dedup_insert_type(&inst) {
355            id
356        } else {
357            let id = self.id();
358            inst.result_id = Some(id);
359            self.module_mut().types_global_values.push(inst);
360            id
361        }
362    }
363    #[allow(clippy::too_many_arguments)]
364    pub fn shader_debug_type_function(
365        &mut self,
366        flags: spirv::Word,
367        return_type: spirv::Word,
368        parameter_types: impl IntoIterator<Item = spirv::Word>,
369    ) -> spirv::Word {
370        self.shader_debug_type_function_id(None, flags, return_type, parameter_types)
371    }
372    #[allow(clippy::too_many_arguments)]
373    pub fn shader_debug_type_function_id(
374        &mut self,
375        result_id: Option<spirv::Word>,
376        flags: spirv::Word,
377        return_type: spirv::Word,
378        parameter_types: impl IntoIterator<Item = spirv::Word>,
379    ) -> spirv::Word {
380        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
381        let result_type = self.type_void();
382        let mut inst = dr::Instruction::new(
383            spirv::Op::ExtInst,
384            Some(result_type),
385            result_id,
386            vec![
387                dr::Operand::IdRef(extension_set),
388                dr::Operand::LiteralExtInstInteger(
389                    crate::spirv::DebugInfoOp::DebugTypeFunction as spirv::Word,
390                ),
391                dr::Operand::IdRef(flags),
392                dr::Operand::IdRef(return_type),
393            ],
394        );
395        inst.operands
396            .extend(parameter_types.into_iter().map(dr::Operand::IdRef));
397        if let Some(id) = inst.result_id {
398            self.module_mut().types_global_values.push(inst);
399            id
400        } else if let Some(id) = self.dedup_insert_type(&inst) {
401            id
402        } else {
403            let id = self.id();
404            inst.result_id = Some(id);
405            self.module_mut().types_global_values.push(inst);
406            id
407        }
408    }
409    #[allow(clippy::too_many_arguments)]
410    pub fn shader_debug_type_enum(
411        &mut self,
412        name: spirv::Word,
413        underlying_type: spirv::Word,
414        source: spirv::Word,
415        line: spirv::Word,
416        column: spirv::Word,
417        parent: spirv::Word,
418        size: spirv::Word,
419        flags: spirv::Word,
420        value_name_value_name: impl IntoIterator<Item = (spirv::Word, spirv::Word)>,
421    ) -> spirv::Word {
422        self.shader_debug_type_enum_id(
423            None,
424            name,
425            underlying_type,
426            source,
427            line,
428            column,
429            parent,
430            size,
431            flags,
432            value_name_value_name,
433        )
434    }
435    #[allow(clippy::too_many_arguments)]
436    pub fn shader_debug_type_enum_id(
437        &mut self,
438        result_id: Option<spirv::Word>,
439        name: spirv::Word,
440        underlying_type: spirv::Word,
441        source: spirv::Word,
442        line: spirv::Word,
443        column: spirv::Word,
444        parent: spirv::Word,
445        size: spirv::Word,
446        flags: spirv::Word,
447        value_name_value_name: impl IntoIterator<Item = (spirv::Word, spirv::Word)>,
448    ) -> spirv::Word {
449        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
450        let result_type = self.type_void();
451        let mut inst = dr::Instruction::new(
452            spirv::Op::ExtInst,
453            Some(result_type),
454            result_id,
455            vec![
456                dr::Operand::IdRef(extension_set),
457                dr::Operand::LiteralExtInstInteger(
458                    crate::spirv::DebugInfoOp::DebugTypeEnum as spirv::Word,
459                ),
460                dr::Operand::IdRef(name),
461                dr::Operand::IdRef(underlying_type),
462                dr::Operand::IdRef(source),
463                dr::Operand::IdRef(line),
464                dr::Operand::IdRef(column),
465                dr::Operand::IdRef(parent),
466                dr::Operand::IdRef(size),
467                dr::Operand::IdRef(flags),
468            ],
469        );
470        for v in value_name_value_name {
471            inst.operands.push(dr::Operand::IdRef(v.0));
472            inst.operands.push(dr::Operand::IdRef(v.1));
473        }
474        if let Some(id) = inst.result_id {
475            self.module_mut().types_global_values.push(inst);
476            id
477        } else if let Some(id) = self.dedup_insert_type(&inst) {
478            id
479        } else {
480            let id = self.id();
481            inst.result_id = Some(id);
482            self.module_mut().types_global_values.push(inst);
483            id
484        }
485    }
486    #[allow(clippy::too_many_arguments)]
487    pub fn shader_debug_type_composite(
488        &mut self,
489        name: spirv::Word,
490        tag: spirv::Word,
491        source: spirv::Word,
492        line: spirv::Word,
493        column: spirv::Word,
494        parent: spirv::Word,
495        linkage_name: spirv::Word,
496        size: spirv::Word,
497        flags: spirv::Word,
498        members: impl IntoIterator<Item = spirv::Word>,
499    ) -> spirv::Word {
500        self.shader_debug_type_composite_id(
501            None,
502            name,
503            tag,
504            source,
505            line,
506            column,
507            parent,
508            linkage_name,
509            size,
510            flags,
511            members,
512        )
513    }
514    #[allow(clippy::too_many_arguments)]
515    pub fn shader_debug_type_composite_id(
516        &mut self,
517        result_id: Option<spirv::Word>,
518        name: spirv::Word,
519        tag: spirv::Word,
520        source: spirv::Word,
521        line: spirv::Word,
522        column: spirv::Word,
523        parent: spirv::Word,
524        linkage_name: spirv::Word,
525        size: spirv::Word,
526        flags: spirv::Word,
527        members: impl IntoIterator<Item = spirv::Word>,
528    ) -> spirv::Word {
529        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
530        let result_type = self.type_void();
531        let mut inst = dr::Instruction::new(
532            spirv::Op::ExtInst,
533            Some(result_type),
534            result_id,
535            vec![
536                dr::Operand::IdRef(extension_set),
537                dr::Operand::LiteralExtInstInteger(
538                    crate::spirv::DebugInfoOp::DebugTypeComposite as spirv::Word,
539                ),
540                dr::Operand::IdRef(name),
541                dr::Operand::IdRef(tag),
542                dr::Operand::IdRef(source),
543                dr::Operand::IdRef(line),
544                dr::Operand::IdRef(column),
545                dr::Operand::IdRef(parent),
546                dr::Operand::IdRef(linkage_name),
547                dr::Operand::IdRef(size),
548                dr::Operand::IdRef(flags),
549            ],
550        );
551        inst.operands
552            .extend(members.into_iter().map(dr::Operand::IdRef));
553        if let Some(id) = inst.result_id {
554            self.module_mut().types_global_values.push(inst);
555            id
556        } else if let Some(id) = self.dedup_insert_type(&inst) {
557            id
558        } else {
559            let id = self.id();
560            inst.result_id = Some(id);
561            self.module_mut().types_global_values.push(inst);
562            id
563        }
564    }
565    #[allow(clippy::too_many_arguments)]
566    pub fn shader_debug_type_member(
567        &mut self,
568        name: spirv::Word,
569        ty: spirv::Word,
570        source: spirv::Word,
571        line: spirv::Word,
572        column: spirv::Word,
573        offset: spirv::Word,
574        size: spirv::Word,
575        flags: spirv::Word,
576        value: Option<spirv::Word>,
577    ) -> spirv::Word {
578        self.shader_debug_type_member_id(
579            None, name, ty, source, line, column, offset, size, flags, value,
580        )
581    }
582    #[allow(clippy::too_many_arguments)]
583    pub fn shader_debug_type_member_id(
584        &mut self,
585        result_id: Option<spirv::Word>,
586        name: spirv::Word,
587        ty: spirv::Word,
588        source: spirv::Word,
589        line: spirv::Word,
590        column: spirv::Word,
591        offset: spirv::Word,
592        size: spirv::Word,
593        flags: spirv::Word,
594        value: Option<spirv::Word>,
595    ) -> spirv::Word {
596        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
597        let result_type = self.type_void();
598        let mut inst = dr::Instruction::new(
599            spirv::Op::ExtInst,
600            Some(result_type),
601            result_id,
602            vec![
603                dr::Operand::IdRef(extension_set),
604                dr::Operand::LiteralExtInstInteger(
605                    crate::spirv::DebugInfoOp::DebugTypeMember as spirv::Word,
606                ),
607                dr::Operand::IdRef(name),
608                dr::Operand::IdRef(ty),
609                dr::Operand::IdRef(source),
610                dr::Operand::IdRef(line),
611                dr::Operand::IdRef(column),
612                dr::Operand::IdRef(offset),
613                dr::Operand::IdRef(size),
614                dr::Operand::IdRef(flags),
615            ],
616        );
617        if let Some(v) = value {
618            inst.operands.push(dr::Operand::IdRef(v));
619        }
620        if let Some(id) = inst.result_id {
621            self.module_mut().types_global_values.push(inst);
622            id
623        } else if let Some(id) = self.dedup_insert_type(&inst) {
624            id
625        } else {
626            let id = self.id();
627            inst.result_id = Some(id);
628            self.module_mut().types_global_values.push(inst);
629            id
630        }
631    }
632    #[allow(clippy::too_many_arguments)]
633    pub fn shader_debug_type_inheritance(
634        &mut self,
635        parent: spirv::Word,
636        offset: spirv::Word,
637        size: spirv::Word,
638        flags: spirv::Word,
639    ) -> spirv::Word {
640        self.shader_debug_type_inheritance_id(None, parent, offset, size, flags)
641    }
642    #[allow(clippy::too_many_arguments)]
643    pub fn shader_debug_type_inheritance_id(
644        &mut self,
645        result_id: Option<spirv::Word>,
646        parent: spirv::Word,
647        offset: spirv::Word,
648        size: spirv::Word,
649        flags: spirv::Word,
650    ) -> spirv::Word {
651        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
652        let result_type = self.type_void();
653        let mut inst = dr::Instruction::new(
654            spirv::Op::ExtInst,
655            Some(result_type),
656            result_id,
657            vec![
658                dr::Operand::IdRef(extension_set),
659                dr::Operand::LiteralExtInstInteger(
660                    crate::spirv::DebugInfoOp::DebugTypeInheritance as spirv::Word,
661                ),
662                dr::Operand::IdRef(parent),
663                dr::Operand::IdRef(offset),
664                dr::Operand::IdRef(size),
665                dr::Operand::IdRef(flags),
666            ],
667        );
668        if let Some(id) = inst.result_id {
669            self.module_mut().types_global_values.push(inst);
670            id
671        } else if let Some(id) = self.dedup_insert_type(&inst) {
672            id
673        } else {
674            let id = self.id();
675            inst.result_id = Some(id);
676            self.module_mut().types_global_values.push(inst);
677            id
678        }
679    }
680    #[allow(clippy::too_many_arguments)]
681    pub fn shader_debug_type_ptr_to_member(
682        &mut self,
683        member_type: spirv::Word,
684        parent: spirv::Word,
685    ) -> spirv::Word {
686        self.shader_debug_type_ptr_to_member_id(None, member_type, parent)
687    }
688    #[allow(clippy::too_many_arguments)]
689    pub fn shader_debug_type_ptr_to_member_id(
690        &mut self,
691        result_id: Option<spirv::Word>,
692        member_type: spirv::Word,
693        parent: spirv::Word,
694    ) -> spirv::Word {
695        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
696        let result_type = self.type_void();
697        let mut inst = dr::Instruction::new(
698            spirv::Op::ExtInst,
699            Some(result_type),
700            result_id,
701            vec![
702                dr::Operand::IdRef(extension_set),
703                dr::Operand::LiteralExtInstInteger(
704                    crate::spirv::DebugInfoOp::DebugTypePtrToMember as spirv::Word,
705                ),
706                dr::Operand::IdRef(member_type),
707                dr::Operand::IdRef(parent),
708            ],
709        );
710        if let Some(id) = inst.result_id {
711            self.module_mut().types_global_values.push(inst);
712            id
713        } else if let Some(id) = self.dedup_insert_type(&inst) {
714            id
715        } else {
716            let id = self.id();
717            inst.result_id = Some(id);
718            self.module_mut().types_global_values.push(inst);
719            id
720        }
721    }
722    #[allow(clippy::too_many_arguments)]
723    pub fn shader_debug_type_template(
724        &mut self,
725        target: spirv::Word,
726        parameters: impl IntoIterator<Item = spirv::Word>,
727    ) -> spirv::Word {
728        self.shader_debug_type_template_id(None, target, parameters)
729    }
730    #[allow(clippy::too_many_arguments)]
731    pub fn shader_debug_type_template_id(
732        &mut self,
733        result_id: Option<spirv::Word>,
734        target: spirv::Word,
735        parameters: impl IntoIterator<Item = spirv::Word>,
736    ) -> spirv::Word {
737        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
738        let result_type = self.type_void();
739        let mut inst = dr::Instruction::new(
740            spirv::Op::ExtInst,
741            Some(result_type),
742            result_id,
743            vec![
744                dr::Operand::IdRef(extension_set),
745                dr::Operand::LiteralExtInstInteger(
746                    crate::spirv::DebugInfoOp::DebugTypeTemplate as spirv::Word,
747                ),
748                dr::Operand::IdRef(target),
749            ],
750        );
751        inst.operands
752            .extend(parameters.into_iter().map(dr::Operand::IdRef));
753        if let Some(id) = inst.result_id {
754            self.module_mut().types_global_values.push(inst);
755            id
756        } else if let Some(id) = self.dedup_insert_type(&inst) {
757            id
758        } else {
759            let id = self.id();
760            inst.result_id = Some(id);
761            self.module_mut().types_global_values.push(inst);
762            id
763        }
764    }
765    #[allow(clippy::too_many_arguments)]
766    pub fn shader_debug_type_template_parameter(
767        &mut self,
768        name: spirv::Word,
769        actual_type: spirv::Word,
770        value: spirv::Word,
771        source: spirv::Word,
772        line: spirv::Word,
773        column: spirv::Word,
774    ) -> spirv::Word {
775        self.shader_debug_type_template_parameter_id(
776            None,
777            name,
778            actual_type,
779            value,
780            source,
781            line,
782            column,
783        )
784    }
785    #[allow(clippy::too_many_arguments)]
786    pub fn shader_debug_type_template_parameter_id(
787        &mut self,
788        result_id: Option<spirv::Word>,
789        name: spirv::Word,
790        actual_type: spirv::Word,
791        value: spirv::Word,
792        source: spirv::Word,
793        line: spirv::Word,
794        column: spirv::Word,
795    ) -> spirv::Word {
796        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
797        let result_type = self.type_void();
798        let mut inst = dr::Instruction::new(
799            spirv::Op::ExtInst,
800            Some(result_type),
801            result_id,
802            vec![
803                dr::Operand::IdRef(extension_set),
804                dr::Operand::LiteralExtInstInteger(
805                    crate::spirv::DebugInfoOp::DebugTypeTemplateParameter as spirv::Word,
806                ),
807                dr::Operand::IdRef(name),
808                dr::Operand::IdRef(actual_type),
809                dr::Operand::IdRef(value),
810                dr::Operand::IdRef(source),
811                dr::Operand::IdRef(line),
812                dr::Operand::IdRef(column),
813            ],
814        );
815        if let Some(id) = inst.result_id {
816            self.module_mut().types_global_values.push(inst);
817            id
818        } else if let Some(id) = self.dedup_insert_type(&inst) {
819            id
820        } else {
821            let id = self.id();
822            inst.result_id = Some(id);
823            self.module_mut().types_global_values.push(inst);
824            id
825        }
826    }
827    #[allow(clippy::too_many_arguments)]
828    pub fn shader_debug_type_template_template_parameter(
829        &mut self,
830        name: spirv::Word,
831        template_name: spirv::Word,
832        source: spirv::Word,
833        line: spirv::Word,
834        column: spirv::Word,
835    ) -> spirv::Word {
836        self.shader_debug_type_template_template_parameter_id(
837            None,
838            name,
839            template_name,
840            source,
841            line,
842            column,
843        )
844    }
845    #[allow(clippy::too_many_arguments)]
846    pub fn shader_debug_type_template_template_parameter_id(
847        &mut self,
848        result_id: Option<spirv::Word>,
849        name: spirv::Word,
850        template_name: spirv::Word,
851        source: spirv::Word,
852        line: spirv::Word,
853        column: spirv::Word,
854    ) -> spirv::Word {
855        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
856        let result_type = self.type_void();
857        let mut inst = dr::Instruction::new(
858            spirv::Op::ExtInst,
859            Some(result_type),
860            result_id,
861            vec![
862                dr::Operand::IdRef(extension_set),
863                dr::Operand::LiteralExtInstInteger(
864                    crate::spirv::DebugInfoOp::DebugTypeTemplateTemplateParameter as spirv::Word,
865                ),
866                dr::Operand::IdRef(name),
867                dr::Operand::IdRef(template_name),
868                dr::Operand::IdRef(source),
869                dr::Operand::IdRef(line),
870                dr::Operand::IdRef(column),
871            ],
872        );
873        if let Some(id) = inst.result_id {
874            self.module_mut().types_global_values.push(inst);
875            id
876        } else if let Some(id) = self.dedup_insert_type(&inst) {
877            id
878        } else {
879            let id = self.id();
880            inst.result_id = Some(id);
881            self.module_mut().types_global_values.push(inst);
882            id
883        }
884    }
885    #[allow(clippy::too_many_arguments)]
886    pub fn shader_debug_type_template_parameter_pack(
887        &mut self,
888        name: spirv::Word,
889        source: spirv::Word,
890        line: spirv::Word,
891        column: spirv::Word,
892        template_parameters: impl IntoIterator<Item = spirv::Word>,
893    ) -> spirv::Word {
894        self.shader_debug_type_template_parameter_pack_id(
895            None,
896            name,
897            source,
898            line,
899            column,
900            template_parameters,
901        )
902    }
903    #[allow(clippy::too_many_arguments)]
904    pub fn shader_debug_type_template_parameter_pack_id(
905        &mut self,
906        result_id: Option<spirv::Word>,
907        name: spirv::Word,
908        source: spirv::Word,
909        line: spirv::Word,
910        column: spirv::Word,
911        template_parameters: impl IntoIterator<Item = spirv::Word>,
912    ) -> spirv::Word {
913        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
914        let result_type = self.type_void();
915        let mut inst = dr::Instruction::new(
916            spirv::Op::ExtInst,
917            Some(result_type),
918            result_id,
919            vec![
920                dr::Operand::IdRef(extension_set),
921                dr::Operand::LiteralExtInstInteger(
922                    crate::spirv::DebugInfoOp::DebugTypeTemplateParameterPack as spirv::Word,
923                ),
924                dr::Operand::IdRef(name),
925                dr::Operand::IdRef(source),
926                dr::Operand::IdRef(line),
927                dr::Operand::IdRef(column),
928            ],
929        );
930        inst.operands
931            .extend(template_parameters.into_iter().map(dr::Operand::IdRef));
932        if let Some(id) = inst.result_id {
933            self.module_mut().types_global_values.push(inst);
934            id
935        } else if let Some(id) = self.dedup_insert_type(&inst) {
936            id
937        } else {
938            let id = self.id();
939            inst.result_id = Some(id);
940            self.module_mut().types_global_values.push(inst);
941            id
942        }
943    }
944    #[allow(clippy::too_many_arguments)]
945    pub fn shader_debug_global_variable(
946        &mut self,
947        name: spirv::Word,
948        ty: spirv::Word,
949        source: spirv::Word,
950        line: spirv::Word,
951        column: spirv::Word,
952        parent: spirv::Word,
953        linkage_name: spirv::Word,
954        variable: spirv::Word,
955        flags: spirv::Word,
956        static_member_declaration: Option<spirv::Word>,
957    ) -> spirv::Word {
958        self.shader_debug_global_variable_id(
959            None,
960            name,
961            ty,
962            source,
963            line,
964            column,
965            parent,
966            linkage_name,
967            variable,
968            flags,
969            static_member_declaration,
970        )
971    }
972    #[allow(clippy::too_many_arguments)]
973    pub fn shader_debug_global_variable_id(
974        &mut self,
975        result_id: Option<spirv::Word>,
976        name: spirv::Word,
977        ty: spirv::Word,
978        source: spirv::Word,
979        line: spirv::Word,
980        column: spirv::Word,
981        parent: spirv::Word,
982        linkage_name: spirv::Word,
983        variable: spirv::Word,
984        flags: spirv::Word,
985        static_member_declaration: Option<spirv::Word>,
986    ) -> spirv::Word {
987        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
988        let result_type = self.type_void();
989        let mut inst = dr::Instruction::new(
990            spirv::Op::ExtInst,
991            Some(result_type),
992            result_id,
993            vec![
994                dr::Operand::IdRef(extension_set),
995                dr::Operand::LiteralExtInstInteger(
996                    crate::spirv::DebugInfoOp::DebugGlobalVariable as spirv::Word,
997                ),
998                dr::Operand::IdRef(name),
999                dr::Operand::IdRef(ty),
1000                dr::Operand::IdRef(source),
1001                dr::Operand::IdRef(line),
1002                dr::Operand::IdRef(column),
1003                dr::Operand::IdRef(parent),
1004                dr::Operand::IdRef(linkage_name),
1005                dr::Operand::IdRef(variable),
1006                dr::Operand::IdRef(flags),
1007            ],
1008        );
1009        if let Some(v) = static_member_declaration {
1010            inst.operands.push(dr::Operand::IdRef(v));
1011        }
1012        if let Some(id) = inst.result_id {
1013            self.module_mut().types_global_values.push(inst);
1014            id
1015        } else if let Some(id) = self.dedup_insert_type(&inst) {
1016            id
1017        } else {
1018            let id = self.id();
1019            inst.result_id = Some(id);
1020            self.module_mut().types_global_values.push(inst);
1021            id
1022        }
1023    }
1024    #[allow(clippy::too_many_arguments)]
1025    pub fn shader_debug_function_declaration(
1026        &mut self,
1027        name: spirv::Word,
1028        ty: spirv::Word,
1029        source: spirv::Word,
1030        line: spirv::Word,
1031        column: spirv::Word,
1032        parent: spirv::Word,
1033        linkage_name: spirv::Word,
1034        flags: spirv::Word,
1035    ) -> spirv::Word {
1036        self.shader_debug_function_declaration_id(
1037            None,
1038            name,
1039            ty,
1040            source,
1041            line,
1042            column,
1043            parent,
1044            linkage_name,
1045            flags,
1046        )
1047    }
1048    #[allow(clippy::too_many_arguments)]
1049    pub fn shader_debug_function_declaration_id(
1050        &mut self,
1051        result_id: Option<spirv::Word>,
1052        name: spirv::Word,
1053        ty: spirv::Word,
1054        source: spirv::Word,
1055        line: spirv::Word,
1056        column: spirv::Word,
1057        parent: spirv::Word,
1058        linkage_name: spirv::Word,
1059        flags: spirv::Word,
1060    ) -> spirv::Word {
1061        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1062        let result_type = self.type_void();
1063        let mut inst = dr::Instruction::new(
1064            spirv::Op::ExtInst,
1065            Some(result_type),
1066            result_id,
1067            vec![
1068                dr::Operand::IdRef(extension_set),
1069                dr::Operand::LiteralExtInstInteger(
1070                    crate::spirv::DebugInfoOp::DebugFunctionDeclaration as spirv::Word,
1071                ),
1072                dr::Operand::IdRef(name),
1073                dr::Operand::IdRef(ty),
1074                dr::Operand::IdRef(source),
1075                dr::Operand::IdRef(line),
1076                dr::Operand::IdRef(column),
1077                dr::Operand::IdRef(parent),
1078                dr::Operand::IdRef(linkage_name),
1079                dr::Operand::IdRef(flags),
1080            ],
1081        );
1082        if let Some(id) = inst.result_id {
1083            self.module_mut().types_global_values.push(inst);
1084            id
1085        } else if let Some(id) = self.dedup_insert_type(&inst) {
1086            id
1087        } else {
1088            let id = self.id();
1089            inst.result_id = Some(id);
1090            self.module_mut().types_global_values.push(inst);
1091            id
1092        }
1093    }
1094    #[allow(clippy::too_many_arguments)]
1095    pub fn shader_debug_function(
1096        &mut self,
1097        name: spirv::Word,
1098        ty: spirv::Word,
1099        source: spirv::Word,
1100        line: spirv::Word,
1101        column: spirv::Word,
1102        parent: spirv::Word,
1103        linkage_name: spirv::Word,
1104        flags: spirv::Word,
1105        scope_line: spirv::Word,
1106        declaration: Option<spirv::Word>,
1107    ) -> spirv::Word {
1108        self.shader_debug_function_id(
1109            None,
1110            name,
1111            ty,
1112            source,
1113            line,
1114            column,
1115            parent,
1116            linkage_name,
1117            flags,
1118            scope_line,
1119            declaration,
1120        )
1121    }
1122    #[allow(clippy::too_many_arguments)]
1123    pub fn shader_debug_function_id(
1124        &mut self,
1125        result_id: Option<spirv::Word>,
1126        name: spirv::Word,
1127        ty: spirv::Word,
1128        source: spirv::Word,
1129        line: spirv::Word,
1130        column: spirv::Word,
1131        parent: spirv::Word,
1132        linkage_name: spirv::Word,
1133        flags: spirv::Word,
1134        scope_line: spirv::Word,
1135        declaration: Option<spirv::Word>,
1136    ) -> spirv::Word {
1137        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1138        let result_type = self.type_void();
1139        let mut inst = dr::Instruction::new(
1140            spirv::Op::ExtInst,
1141            Some(result_type),
1142            result_id,
1143            vec![
1144                dr::Operand::IdRef(extension_set),
1145                dr::Operand::LiteralExtInstInteger(
1146                    crate::spirv::DebugInfoOp::DebugFunction as spirv::Word,
1147                ),
1148                dr::Operand::IdRef(name),
1149                dr::Operand::IdRef(ty),
1150                dr::Operand::IdRef(source),
1151                dr::Operand::IdRef(line),
1152                dr::Operand::IdRef(column),
1153                dr::Operand::IdRef(parent),
1154                dr::Operand::IdRef(linkage_name),
1155                dr::Operand::IdRef(flags),
1156                dr::Operand::IdRef(scope_line),
1157            ],
1158        );
1159        if let Some(v) = declaration {
1160            inst.operands.push(dr::Operand::IdRef(v));
1161        }
1162        if let Some(id) = inst.result_id {
1163            self.module_mut().types_global_values.push(inst);
1164            id
1165        } else if let Some(id) = self.dedup_insert_type(&inst) {
1166            id
1167        } else {
1168            let id = self.id();
1169            inst.result_id = Some(id);
1170            self.module_mut().types_global_values.push(inst);
1171            id
1172        }
1173    }
1174    #[allow(clippy::too_many_arguments)]
1175    pub fn shader_debug_lexical_block(
1176        &mut self,
1177        source: spirv::Word,
1178        line: spirv::Word,
1179        column: spirv::Word,
1180        parent: spirv::Word,
1181        name: Option<spirv::Word>,
1182    ) -> spirv::Word {
1183        self.shader_debug_lexical_block_id(None, source, line, column, parent, name)
1184    }
1185    #[allow(clippy::too_many_arguments)]
1186    pub fn shader_debug_lexical_block_id(
1187        &mut self,
1188        result_id: Option<spirv::Word>,
1189        source: spirv::Word,
1190        line: spirv::Word,
1191        column: spirv::Word,
1192        parent: spirv::Word,
1193        name: Option<spirv::Word>,
1194    ) -> spirv::Word {
1195        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1196        let result_type = self.type_void();
1197        let mut inst = dr::Instruction::new(
1198            spirv::Op::ExtInst,
1199            Some(result_type),
1200            result_id,
1201            vec![
1202                dr::Operand::IdRef(extension_set),
1203                dr::Operand::LiteralExtInstInteger(
1204                    crate::spirv::DebugInfoOp::DebugLexicalBlock as spirv::Word,
1205                ),
1206                dr::Operand::IdRef(source),
1207                dr::Operand::IdRef(line),
1208                dr::Operand::IdRef(column),
1209                dr::Operand::IdRef(parent),
1210            ],
1211        );
1212        if let Some(v) = name {
1213            inst.operands.push(dr::Operand::IdRef(v));
1214        }
1215        if let Some(id) = inst.result_id {
1216            self.module_mut().types_global_values.push(inst);
1217            id
1218        } else if let Some(id) = self.dedup_insert_type(&inst) {
1219            id
1220        } else {
1221            let id = self.id();
1222            inst.result_id = Some(id);
1223            self.module_mut().types_global_values.push(inst);
1224            id
1225        }
1226    }
1227    #[allow(clippy::too_many_arguments)]
1228    pub fn shader_debug_lexical_block_discriminator(
1229        &mut self,
1230        source: spirv::Word,
1231        discriminator: spirv::Word,
1232        parent: spirv::Word,
1233    ) -> spirv::Word {
1234        self.shader_debug_lexical_block_discriminator_id(None, source, discriminator, parent)
1235    }
1236    #[allow(clippy::too_many_arguments)]
1237    pub fn shader_debug_lexical_block_discriminator_id(
1238        &mut self,
1239        result_id: Option<spirv::Word>,
1240        source: spirv::Word,
1241        discriminator: spirv::Word,
1242        parent: spirv::Word,
1243    ) -> spirv::Word {
1244        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1245        let result_type = self.type_void();
1246        let mut inst = dr::Instruction::new(
1247            spirv::Op::ExtInst,
1248            Some(result_type),
1249            result_id,
1250            vec![
1251                dr::Operand::IdRef(extension_set),
1252                dr::Operand::LiteralExtInstInteger(
1253                    crate::spirv::DebugInfoOp::DebugLexicalBlockDiscriminator as spirv::Word,
1254                ),
1255                dr::Operand::IdRef(source),
1256                dr::Operand::IdRef(discriminator),
1257                dr::Operand::IdRef(parent),
1258            ],
1259        );
1260        if let Some(id) = inst.result_id {
1261            self.module_mut().types_global_values.push(inst);
1262            id
1263        } else if let Some(id) = self.dedup_insert_type(&inst) {
1264            id
1265        } else {
1266            let id = self.id();
1267            inst.result_id = Some(id);
1268            self.module_mut().types_global_values.push(inst);
1269            id
1270        }
1271    }
1272    #[allow(clippy::too_many_arguments)]
1273    pub fn shader_debug_inlined_at(
1274        &mut self,
1275        line: spirv::Word,
1276        scope: spirv::Word,
1277        inlined: Option<spirv::Word>,
1278    ) -> spirv::Word {
1279        self.shader_debug_inlined_at_id(None, line, scope, inlined)
1280    }
1281    #[allow(clippy::too_many_arguments)]
1282    pub fn shader_debug_inlined_at_id(
1283        &mut self,
1284        result_id: Option<spirv::Word>,
1285        line: spirv::Word,
1286        scope: spirv::Word,
1287        inlined: Option<spirv::Word>,
1288    ) -> spirv::Word {
1289        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1290        let result_type = self.type_void();
1291        let mut inst = dr::Instruction::new(
1292            spirv::Op::ExtInst,
1293            Some(result_type),
1294            result_id,
1295            vec![
1296                dr::Operand::IdRef(extension_set),
1297                dr::Operand::LiteralExtInstInteger(
1298                    crate::spirv::DebugInfoOp::DebugInlinedAt as spirv::Word,
1299                ),
1300                dr::Operand::IdRef(line),
1301                dr::Operand::IdRef(scope),
1302            ],
1303        );
1304        if let Some(v) = inlined {
1305            inst.operands.push(dr::Operand::IdRef(v));
1306        }
1307        if let Some(id) = inst.result_id {
1308            self.module_mut().types_global_values.push(inst);
1309            id
1310        } else if let Some(id) = self.dedup_insert_type(&inst) {
1311            id
1312        } else {
1313            let id = self.id();
1314            inst.result_id = Some(id);
1315            self.module_mut().types_global_values.push(inst);
1316            id
1317        }
1318    }
1319    #[allow(clippy::too_many_arguments)]
1320    pub fn shader_debug_local_variable(
1321        &mut self,
1322        name: spirv::Word,
1323        ty: spirv::Word,
1324        source: spirv::Word,
1325        line: spirv::Word,
1326        column: spirv::Word,
1327        parent: spirv::Word,
1328        flags: spirv::Word,
1329        arg_number: Option<spirv::Word>,
1330    ) -> spirv::Word {
1331        self.shader_debug_local_variable_id(
1332            None, name, ty, source, line, column, parent, flags, arg_number,
1333        )
1334    }
1335    #[allow(clippy::too_many_arguments)]
1336    pub fn shader_debug_local_variable_id(
1337        &mut self,
1338        result_id: Option<spirv::Word>,
1339        name: spirv::Word,
1340        ty: spirv::Word,
1341        source: spirv::Word,
1342        line: spirv::Word,
1343        column: spirv::Word,
1344        parent: spirv::Word,
1345        flags: spirv::Word,
1346        arg_number: Option<spirv::Word>,
1347    ) -> spirv::Word {
1348        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1349        let result_type = self.type_void();
1350        let mut inst = dr::Instruction::new(
1351            spirv::Op::ExtInst,
1352            Some(result_type),
1353            result_id,
1354            vec![
1355                dr::Operand::IdRef(extension_set),
1356                dr::Operand::LiteralExtInstInteger(
1357                    crate::spirv::DebugInfoOp::DebugLocalVariable as spirv::Word,
1358                ),
1359                dr::Operand::IdRef(name),
1360                dr::Operand::IdRef(ty),
1361                dr::Operand::IdRef(source),
1362                dr::Operand::IdRef(line),
1363                dr::Operand::IdRef(column),
1364                dr::Operand::IdRef(parent),
1365                dr::Operand::IdRef(flags),
1366            ],
1367        );
1368        if let Some(v) = arg_number {
1369            inst.operands.push(dr::Operand::IdRef(v));
1370        }
1371        if let Some(id) = inst.result_id {
1372            self.module_mut().types_global_values.push(inst);
1373            id
1374        } else if let Some(id) = self.dedup_insert_type(&inst) {
1375            id
1376        } else {
1377            let id = self.id();
1378            inst.result_id = Some(id);
1379            self.module_mut().types_global_values.push(inst);
1380            id
1381        }
1382    }
1383    #[allow(clippy::too_many_arguments)]
1384    pub fn shader_debug_inlined_variable(
1385        &mut self,
1386        variable: spirv::Word,
1387        inlined: spirv::Word,
1388    ) -> spirv::Word {
1389        self.shader_debug_inlined_variable_id(None, variable, inlined)
1390    }
1391    #[allow(clippy::too_many_arguments)]
1392    pub fn shader_debug_inlined_variable_id(
1393        &mut self,
1394        result_id: Option<spirv::Word>,
1395        variable: spirv::Word,
1396        inlined: spirv::Word,
1397    ) -> spirv::Word {
1398        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1399        let result_type = self.type_void();
1400        let mut inst = dr::Instruction::new(
1401            spirv::Op::ExtInst,
1402            Some(result_type),
1403            result_id,
1404            vec![
1405                dr::Operand::IdRef(extension_set),
1406                dr::Operand::LiteralExtInstInteger(
1407                    crate::spirv::DebugInfoOp::DebugInlinedVariable as spirv::Word,
1408                ),
1409                dr::Operand::IdRef(variable),
1410                dr::Operand::IdRef(inlined),
1411            ],
1412        );
1413        if let Some(id) = inst.result_id {
1414            self.module_mut().types_global_values.push(inst);
1415            id
1416        } else if let Some(id) = self.dedup_insert_type(&inst) {
1417            id
1418        } else {
1419            let id = self.id();
1420            inst.result_id = Some(id);
1421            self.module_mut().types_global_values.push(inst);
1422            id
1423        }
1424    }
1425    #[allow(clippy::too_many_arguments)]
1426    pub fn shader_debug_operation(
1427        &mut self,
1428        op_code: spirv::Word,
1429        operands: impl IntoIterator<Item = spirv::Word>,
1430    ) -> spirv::Word {
1431        self.shader_debug_operation_id(None, op_code, operands)
1432    }
1433    #[allow(clippy::too_many_arguments)]
1434    pub fn shader_debug_operation_id(
1435        &mut self,
1436        result_id: Option<spirv::Word>,
1437        op_code: spirv::Word,
1438        operands: impl IntoIterator<Item = spirv::Word>,
1439    ) -> spirv::Word {
1440        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1441        let result_type = self.type_void();
1442        let mut inst = dr::Instruction::new(
1443            spirv::Op::ExtInst,
1444            Some(result_type),
1445            result_id,
1446            vec![
1447                dr::Operand::IdRef(extension_set),
1448                dr::Operand::LiteralExtInstInteger(
1449                    crate::spirv::DebugInfoOp::DebugOperation as spirv::Word,
1450                ),
1451                dr::Operand::IdRef(op_code),
1452            ],
1453        );
1454        inst.operands
1455            .extend(operands.into_iter().map(dr::Operand::IdRef));
1456        if let Some(id) = inst.result_id {
1457            self.module_mut().types_global_values.push(inst);
1458            id
1459        } else if let Some(id) = self.dedup_insert_type(&inst) {
1460            id
1461        } else {
1462            let id = self.id();
1463            inst.result_id = Some(id);
1464            self.module_mut().types_global_values.push(inst);
1465            id
1466        }
1467    }
1468    #[allow(clippy::too_many_arguments)]
1469    pub fn shader_debug_expression(
1470        &mut self,
1471        operands: impl IntoIterator<Item = spirv::Word>,
1472    ) -> spirv::Word {
1473        self.shader_debug_expression_id(None, operands)
1474    }
1475    #[allow(clippy::too_many_arguments)]
1476    pub fn shader_debug_expression_id(
1477        &mut self,
1478        result_id: Option<spirv::Word>,
1479        operands: impl IntoIterator<Item = spirv::Word>,
1480    ) -> spirv::Word {
1481        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1482        let result_type = self.type_void();
1483        let mut inst = dr::Instruction::new(
1484            spirv::Op::ExtInst,
1485            Some(result_type),
1486            result_id,
1487            vec![
1488                dr::Operand::IdRef(extension_set),
1489                dr::Operand::LiteralExtInstInteger(
1490                    crate::spirv::DebugInfoOp::DebugExpression as spirv::Word,
1491                ),
1492            ],
1493        );
1494        inst.operands
1495            .extend(operands.into_iter().map(dr::Operand::IdRef));
1496        if let Some(id) = inst.result_id {
1497            self.module_mut().types_global_values.push(inst);
1498            id
1499        } else if let Some(id) = self.dedup_insert_type(&inst) {
1500            id
1501        } else {
1502            let id = self.id();
1503            inst.result_id = Some(id);
1504            self.module_mut().types_global_values.push(inst);
1505            id
1506        }
1507    }
1508    #[allow(clippy::too_many_arguments)]
1509    pub fn shader_debug_macro_def(
1510        &mut self,
1511        source: spirv::Word,
1512        line: spirv::Word,
1513        name: spirv::Word,
1514        value: Option<spirv::Word>,
1515    ) -> spirv::Word {
1516        self.shader_debug_macro_def_id(None, source, line, name, value)
1517    }
1518    #[allow(clippy::too_many_arguments)]
1519    pub fn shader_debug_macro_def_id(
1520        &mut self,
1521        result_id: Option<spirv::Word>,
1522        source: spirv::Word,
1523        line: spirv::Word,
1524        name: spirv::Word,
1525        value: Option<spirv::Word>,
1526    ) -> spirv::Word {
1527        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1528        let result_type = self.type_void();
1529        let mut inst = dr::Instruction::new(
1530            spirv::Op::ExtInst,
1531            Some(result_type),
1532            result_id,
1533            vec![
1534                dr::Operand::IdRef(extension_set),
1535                dr::Operand::LiteralExtInstInteger(
1536                    crate::spirv::DebugInfoOp::DebugMacroDef as spirv::Word,
1537                ),
1538                dr::Operand::IdRef(source),
1539                dr::Operand::IdRef(line),
1540                dr::Operand::IdRef(name),
1541            ],
1542        );
1543        if let Some(v) = value {
1544            inst.operands.push(dr::Operand::IdRef(v));
1545        }
1546        if let Some(id) = inst.result_id {
1547            self.module_mut().types_global_values.push(inst);
1548            id
1549        } else if let Some(id) = self.dedup_insert_type(&inst) {
1550            id
1551        } else {
1552            let id = self.id();
1553            inst.result_id = Some(id);
1554            self.module_mut().types_global_values.push(inst);
1555            id
1556        }
1557    }
1558    #[allow(clippy::too_many_arguments)]
1559    pub fn shader_debug_macro_undef(
1560        &mut self,
1561        source: spirv::Word,
1562        line: spirv::Word,
1563        macro_: spirv::Word,
1564    ) -> spirv::Word {
1565        self.shader_debug_macro_undef_id(None, source, line, macro_)
1566    }
1567    #[allow(clippy::too_many_arguments)]
1568    pub fn shader_debug_macro_undef_id(
1569        &mut self,
1570        result_id: Option<spirv::Word>,
1571        source: spirv::Word,
1572        line: spirv::Word,
1573        macro_: spirv::Word,
1574    ) -> spirv::Word {
1575        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1576        let result_type = self.type_void();
1577        let mut inst = dr::Instruction::new(
1578            spirv::Op::ExtInst,
1579            Some(result_type),
1580            result_id,
1581            vec![
1582                dr::Operand::IdRef(extension_set),
1583                dr::Operand::LiteralExtInstInteger(
1584                    crate::spirv::DebugInfoOp::DebugMacroUndef as spirv::Word,
1585                ),
1586                dr::Operand::IdRef(source),
1587                dr::Operand::IdRef(line),
1588                dr::Operand::IdRef(macro_),
1589            ],
1590        );
1591        if let Some(id) = inst.result_id {
1592            self.module_mut().types_global_values.push(inst);
1593            id
1594        } else if let Some(id) = self.dedup_insert_type(&inst) {
1595            id
1596        } else {
1597            let id = self.id();
1598            inst.result_id = Some(id);
1599            self.module_mut().types_global_values.push(inst);
1600            id
1601        }
1602    }
1603    #[allow(clippy::too_many_arguments)]
1604    pub fn shader_debug_imported_entity(
1605        &mut self,
1606        name: spirv::Word,
1607        tag: spirv::Word,
1608        source: spirv::Word,
1609        entity: spirv::Word,
1610        line: spirv::Word,
1611        column: spirv::Word,
1612        parent: spirv::Word,
1613    ) -> spirv::Word {
1614        self.shader_debug_imported_entity_id(None, name, tag, source, entity, line, column, parent)
1615    }
1616    #[allow(clippy::too_many_arguments)]
1617    pub fn shader_debug_imported_entity_id(
1618        &mut self,
1619        result_id: Option<spirv::Word>,
1620        name: spirv::Word,
1621        tag: spirv::Word,
1622        source: spirv::Word,
1623        entity: spirv::Word,
1624        line: spirv::Word,
1625        column: spirv::Word,
1626        parent: spirv::Word,
1627    ) -> spirv::Word {
1628        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1629        let result_type = self.type_void();
1630        let mut inst = dr::Instruction::new(
1631            spirv::Op::ExtInst,
1632            Some(result_type),
1633            result_id,
1634            vec![
1635                dr::Operand::IdRef(extension_set),
1636                dr::Operand::LiteralExtInstInteger(
1637                    crate::spirv::DebugInfoOp::DebugImportedEntity as spirv::Word,
1638                ),
1639                dr::Operand::IdRef(name),
1640                dr::Operand::IdRef(tag),
1641                dr::Operand::IdRef(source),
1642                dr::Operand::IdRef(entity),
1643                dr::Operand::IdRef(line),
1644                dr::Operand::IdRef(column),
1645                dr::Operand::IdRef(parent),
1646            ],
1647        );
1648        if let Some(id) = inst.result_id {
1649            self.module_mut().types_global_values.push(inst);
1650            id
1651        } else if let Some(id) = self.dedup_insert_type(&inst) {
1652            id
1653        } else {
1654            let id = self.id();
1655            inst.result_id = Some(id);
1656            self.module_mut().types_global_values.push(inst);
1657            id
1658        }
1659    }
1660    #[allow(clippy::too_many_arguments)]
1661    pub fn shader_debug_source(
1662        &mut self,
1663        file: spirv::Word,
1664        text: Option<spirv::Word>,
1665    ) -> spirv::Word {
1666        self.shader_debug_source_id(None, file, text)
1667    }
1668    #[allow(clippy::too_many_arguments)]
1669    pub fn shader_debug_source_id(
1670        &mut self,
1671        result_id: Option<spirv::Word>,
1672        file: spirv::Word,
1673        text: Option<spirv::Word>,
1674    ) -> spirv::Word {
1675        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1676        let result_type = self.type_void();
1677        let mut inst = dr::Instruction::new(
1678            spirv::Op::ExtInst,
1679            Some(result_type),
1680            result_id,
1681            vec![
1682                dr::Operand::IdRef(extension_set),
1683                dr::Operand::LiteralExtInstInteger(
1684                    crate::spirv::DebugInfoOp::DebugSource as spirv::Word,
1685                ),
1686                dr::Operand::IdRef(file),
1687            ],
1688        );
1689        if let Some(v) = text {
1690            inst.operands.push(dr::Operand::IdRef(v));
1691        }
1692        if let Some(id) = inst.result_id {
1693            self.module_mut().types_global_values.push(inst);
1694            id
1695        } else if let Some(id) = self.dedup_insert_type(&inst) {
1696            id
1697        } else {
1698            let id = self.id();
1699            inst.result_id = Some(id);
1700            self.module_mut().types_global_values.push(inst);
1701            id
1702        }
1703    }
1704    #[allow(clippy::too_many_arguments)]
1705    pub fn shader_debug_source_continued(&mut self, text: spirv::Word) -> spirv::Word {
1706        self.shader_debug_source_continued_id(None, text)
1707    }
1708    #[allow(clippy::too_many_arguments)]
1709    pub fn shader_debug_source_continued_id(
1710        &mut self,
1711        result_id: Option<spirv::Word>,
1712        text: spirv::Word,
1713    ) -> spirv::Word {
1714        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1715        let result_type = self.type_void();
1716        let mut inst = dr::Instruction::new(
1717            spirv::Op::ExtInst,
1718            Some(result_type),
1719            result_id,
1720            vec![
1721                dr::Operand::IdRef(extension_set),
1722                dr::Operand::LiteralExtInstInteger(
1723                    crate::spirv::DebugInfoOp::DebugSourceContinued as spirv::Word,
1724                ),
1725                dr::Operand::IdRef(text),
1726            ],
1727        );
1728        if let Some(id) = inst.result_id {
1729            self.module_mut().types_global_values.push(inst);
1730            id
1731        } else if let Some(id) = self.dedup_insert_type(&inst) {
1732            id
1733        } else {
1734            let id = self.id();
1735            inst.result_id = Some(id);
1736            self.module_mut().types_global_values.push(inst);
1737            id
1738        }
1739    }
1740    #[allow(clippy::too_many_arguments)]
1741    pub fn shader_debug_build_identifier(
1742        &mut self,
1743        identifier: spirv::Word,
1744        flags: spirv::Word,
1745    ) -> spirv::Word {
1746        self.shader_debug_build_identifier_id(None, identifier, flags)
1747    }
1748    #[allow(clippy::too_many_arguments)]
1749    pub fn shader_debug_build_identifier_id(
1750        &mut self,
1751        result_id: Option<spirv::Word>,
1752        identifier: spirv::Word,
1753        flags: spirv::Word,
1754    ) -> spirv::Word {
1755        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1756        let result_type = self.type_void();
1757        let mut inst = dr::Instruction::new(
1758            spirv::Op::ExtInst,
1759            Some(result_type),
1760            result_id,
1761            vec![
1762                dr::Operand::IdRef(extension_set),
1763                dr::Operand::LiteralExtInstInteger(
1764                    crate::spirv::DebugInfoOp::DebugBuildIdentifier as spirv::Word,
1765                ),
1766                dr::Operand::IdRef(identifier),
1767                dr::Operand::IdRef(flags),
1768            ],
1769        );
1770        if let Some(id) = inst.result_id {
1771            self.module_mut().types_global_values.push(inst);
1772            id
1773        } else if let Some(id) = self.dedup_insert_type(&inst) {
1774            id
1775        } else {
1776            let id = self.id();
1777            inst.result_id = Some(id);
1778            self.module_mut().types_global_values.push(inst);
1779            id
1780        }
1781    }
1782    #[allow(clippy::too_many_arguments)]
1783    pub fn shader_debug_storage_path(&mut self, path: spirv::Word) -> spirv::Word {
1784        self.shader_debug_storage_path_id(None, path)
1785    }
1786    #[allow(clippy::too_many_arguments)]
1787    pub fn shader_debug_storage_path_id(
1788        &mut self,
1789        result_id: Option<spirv::Word>,
1790        path: spirv::Word,
1791    ) -> spirv::Word {
1792        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1793        let result_type = self.type_void();
1794        let mut inst = dr::Instruction::new(
1795            spirv::Op::ExtInst,
1796            Some(result_type),
1797            result_id,
1798            vec![
1799                dr::Operand::IdRef(extension_set),
1800                dr::Operand::LiteralExtInstInteger(
1801                    crate::spirv::DebugInfoOp::DebugStoragePath as spirv::Word,
1802                ),
1803                dr::Operand::IdRef(path),
1804            ],
1805        );
1806        if let Some(id) = inst.result_id {
1807            self.module_mut().types_global_values.push(inst);
1808            id
1809        } else if let Some(id) = self.dedup_insert_type(&inst) {
1810            id
1811        } else {
1812            let id = self.id();
1813            inst.result_id = Some(id);
1814            self.module_mut().types_global_values.push(inst);
1815            id
1816        }
1817    }
1818    #[allow(clippy::too_many_arguments)]
1819    pub fn shader_debug_entry_point(
1820        &mut self,
1821        entry_point: spirv::Word,
1822        compilation_unit: spirv::Word,
1823        compiler_signature: spirv::Word,
1824        command_line_arguments: spirv::Word,
1825    ) -> spirv::Word {
1826        self.shader_debug_entry_point_id(
1827            None,
1828            entry_point,
1829            compilation_unit,
1830            compiler_signature,
1831            command_line_arguments,
1832        )
1833    }
1834    #[allow(clippy::too_many_arguments)]
1835    pub fn shader_debug_entry_point_id(
1836        &mut self,
1837        result_id: Option<spirv::Word>,
1838        entry_point: spirv::Word,
1839        compilation_unit: spirv::Word,
1840        compiler_signature: spirv::Word,
1841        command_line_arguments: spirv::Word,
1842    ) -> spirv::Word {
1843        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1844        let result_type = self.type_void();
1845        let mut inst = dr::Instruction::new(
1846            spirv::Op::ExtInst,
1847            Some(result_type),
1848            result_id,
1849            vec![
1850                dr::Operand::IdRef(extension_set),
1851                dr::Operand::LiteralExtInstInteger(
1852                    crate::spirv::DebugInfoOp::DebugEntryPoint as spirv::Word,
1853                ),
1854                dr::Operand::IdRef(entry_point),
1855                dr::Operand::IdRef(compilation_unit),
1856                dr::Operand::IdRef(compiler_signature),
1857                dr::Operand::IdRef(command_line_arguments),
1858            ],
1859        );
1860        if let Some(id) = inst.result_id {
1861            self.module_mut().types_global_values.push(inst);
1862            id
1863        } else if let Some(id) = self.dedup_insert_type(&inst) {
1864            id
1865        } else {
1866            let id = self.id();
1867            inst.result_id = Some(id);
1868            self.module_mut().types_global_values.push(inst);
1869            id
1870        }
1871    }
1872    #[allow(clippy::too_many_arguments)]
1873    pub fn shader_debug_type_matrix(
1874        &mut self,
1875        vector_type: spirv::Word,
1876        vector_count: spirv::Word,
1877        column_major: spirv::Word,
1878    ) -> spirv::Word {
1879        self.shader_debug_type_matrix_id(None, vector_type, vector_count, column_major)
1880    }
1881    #[allow(clippy::too_many_arguments)]
1882    pub fn shader_debug_type_matrix_id(
1883        &mut self,
1884        result_id: Option<spirv::Word>,
1885        vector_type: spirv::Word,
1886        vector_count: spirv::Word,
1887        column_major: spirv::Word,
1888    ) -> spirv::Word {
1889        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1890        let result_type = self.type_void();
1891        let mut inst = dr::Instruction::new(
1892            spirv::Op::ExtInst,
1893            Some(result_type),
1894            result_id,
1895            vec![
1896                dr::Operand::IdRef(extension_set),
1897                dr::Operand::LiteralExtInstInteger(
1898                    crate::spirv::DebugInfoOp::DebugTypeMatrix as spirv::Word,
1899                ),
1900                dr::Operand::IdRef(vector_type),
1901                dr::Operand::IdRef(vector_count),
1902                dr::Operand::IdRef(column_major),
1903            ],
1904        );
1905        if let Some(id) = inst.result_id {
1906            self.module_mut().types_global_values.push(inst);
1907            id
1908        } else if let Some(id) = self.dedup_insert_type(&inst) {
1909            id
1910        } else {
1911            let id = self.id();
1912            inst.result_id = Some(id);
1913            self.module_mut().types_global_values.push(inst);
1914            id
1915        }
1916    }
1917    #[allow(clippy::too_many_arguments)]
1918    pub fn shader_debug_scope(
1919        &mut self,
1920        scope: spirv::Word,
1921        inlined_at: Option<spirv::Word>,
1922    ) -> Result<spirv::Word, dr::Error> {
1923        self.shader_debug_scope_id(None, scope, inlined_at)
1924    }
1925    #[allow(clippy::too_many_arguments)]
1926    pub fn shader_debug_scope_id(
1927        &mut self,
1928        result_id: Option<spirv::Word>,
1929        scope: spirv::Word,
1930        inlined_at: Option<spirv::Word>,
1931    ) -> Result<spirv::Word, dr::Error> {
1932        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1933        let result_type = self.type_void();
1934        #[allow(unused_mut)]
1935        let mut args = vec![dr::Operand::IdRef(scope)];
1936        if let Some(v) = inlined_at {
1937            args.push(dr::Operand::IdRef(v));
1938        }
1939        self.ext_inst(
1940            result_type,
1941            result_id,
1942            extension_set,
1943            crate::spirv::DebugInfoOp::DebugScope as spirv::Word,
1944            args,
1945        )
1946    }
1947    #[allow(clippy::too_many_arguments)]
1948    pub fn shader_debug_no_scope(&mut self) -> Result<spirv::Word, dr::Error> {
1949        self.shader_debug_no_scope_id(None)
1950    }
1951    #[allow(clippy::too_many_arguments)]
1952    pub fn shader_debug_no_scope_id(
1953        &mut self,
1954        result_id: Option<spirv::Word>,
1955    ) -> Result<spirv::Word, dr::Error> {
1956        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1957        let result_type = self.type_void();
1958        #[allow(unused_mut)]
1959        let mut args = vec![];
1960        self.ext_inst(
1961            result_type,
1962            result_id,
1963            extension_set,
1964            crate::spirv::DebugInfoOp::DebugNoScope as spirv::Word,
1965            args,
1966        )
1967    }
1968    #[allow(clippy::too_many_arguments)]
1969    pub fn shader_debug_declare(
1970        &mut self,
1971        local_variable: spirv::Word,
1972        variable: spirv::Word,
1973        expression: spirv::Word,
1974        indexes: impl IntoIterator<Item = spirv::Word>,
1975    ) -> Result<spirv::Word, dr::Error> {
1976        self.shader_debug_declare_id(None, local_variable, variable, expression, indexes)
1977    }
1978    #[allow(clippy::too_many_arguments)]
1979    pub fn shader_debug_declare_id(
1980        &mut self,
1981        result_id: Option<spirv::Word>,
1982        local_variable: spirv::Word,
1983        variable: spirv::Word,
1984        expression: spirv::Word,
1985        indexes: impl IntoIterator<Item = spirv::Word>,
1986    ) -> Result<spirv::Word, dr::Error> {
1987        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
1988        let result_type = self.type_void();
1989        #[allow(unused_mut)]
1990        let mut args = vec![
1991            dr::Operand::IdRef(local_variable),
1992            dr::Operand::IdRef(variable),
1993            dr::Operand::IdRef(expression),
1994        ];
1995        args.extend(indexes.into_iter().map(dr::Operand::IdRef));
1996        self.ext_inst(
1997            result_type,
1998            result_id,
1999            extension_set,
2000            crate::spirv::DebugInfoOp::DebugDeclare as spirv::Word,
2001            args,
2002        )
2003    }
2004    #[allow(clippy::too_many_arguments)]
2005    pub fn shader_debug_value(
2006        &mut self,
2007        local_variable: spirv::Word,
2008        value: spirv::Word,
2009        expression: spirv::Word,
2010        indexes: impl IntoIterator<Item = spirv::Word>,
2011    ) -> Result<spirv::Word, dr::Error> {
2012        self.shader_debug_value_id(None, local_variable, value, expression, indexes)
2013    }
2014    #[allow(clippy::too_many_arguments)]
2015    pub fn shader_debug_value_id(
2016        &mut self,
2017        result_id: Option<spirv::Word>,
2018        local_variable: spirv::Word,
2019        value: spirv::Word,
2020        expression: spirv::Word,
2021        indexes: impl IntoIterator<Item = spirv::Word>,
2022    ) -> Result<spirv::Word, dr::Error> {
2023        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
2024        let result_type = self.type_void();
2025        #[allow(unused_mut)]
2026        let mut args = vec![
2027            dr::Operand::IdRef(local_variable),
2028            dr::Operand::IdRef(value),
2029            dr::Operand::IdRef(expression),
2030        ];
2031        args.extend(indexes.into_iter().map(dr::Operand::IdRef));
2032        self.ext_inst(
2033            result_type,
2034            result_id,
2035            extension_set,
2036            crate::spirv::DebugInfoOp::DebugValue as spirv::Word,
2037            args,
2038        )
2039    }
2040    #[allow(clippy::too_many_arguments)]
2041    pub fn shader_debug_function_definition(
2042        &mut self,
2043        function: spirv::Word,
2044        definition: spirv::Word,
2045    ) -> Result<spirv::Word, dr::Error> {
2046        self.shader_debug_function_definition_id(None, function, definition)
2047    }
2048    #[allow(clippy::too_many_arguments)]
2049    pub fn shader_debug_function_definition_id(
2050        &mut self,
2051        result_id: Option<spirv::Word>,
2052        function: spirv::Word,
2053        definition: spirv::Word,
2054    ) -> Result<spirv::Word, dr::Error> {
2055        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
2056        let result_type = self.type_void();
2057        #[allow(unused_mut)]
2058        let mut args = vec![dr::Operand::IdRef(function), dr::Operand::IdRef(definition)];
2059        self.ext_inst(
2060            result_type,
2061            result_id,
2062            extension_set,
2063            crate::spirv::DebugInfoOp::DebugFunctionDefinition as spirv::Word,
2064            args,
2065        )
2066    }
2067    #[allow(clippy::too_many_arguments)]
2068    pub fn shader_debug_line(
2069        &mut self,
2070        source: spirv::Word,
2071        line_start: spirv::Word,
2072        line_end: spirv::Word,
2073        column_start: spirv::Word,
2074        column_end: spirv::Word,
2075    ) -> Result<spirv::Word, dr::Error> {
2076        self.shader_debug_line_id(None, source, line_start, line_end, column_start, column_end)
2077    }
2078    #[allow(clippy::too_many_arguments)]
2079    pub fn shader_debug_line_id(
2080        &mut self,
2081        result_id: Option<spirv::Word>,
2082        source: spirv::Word,
2083        line_start: spirv::Word,
2084        line_end: spirv::Word,
2085        column_start: spirv::Word,
2086        column_end: spirv::Word,
2087    ) -> Result<spirv::Word, dr::Error> {
2088        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
2089        let result_type = self.type_void();
2090        #[allow(unused_mut)]
2091        let mut args = vec![
2092            dr::Operand::IdRef(source),
2093            dr::Operand::IdRef(line_start),
2094            dr::Operand::IdRef(line_end),
2095            dr::Operand::IdRef(column_start),
2096            dr::Operand::IdRef(column_end),
2097        ];
2098        self.ext_inst(
2099            result_type,
2100            result_id,
2101            extension_set,
2102            crate::spirv::DebugInfoOp::DebugLine as spirv::Word,
2103            args,
2104        )
2105    }
2106    #[allow(clippy::too_many_arguments)]
2107    pub fn shader_debug_no_line(&mut self) -> Result<spirv::Word, dr::Error> {
2108        self.shader_debug_no_line_id(None)
2109    }
2110    #[allow(clippy::too_many_arguments)]
2111    pub fn shader_debug_no_line_id(
2112        &mut self,
2113        result_id: Option<spirv::Word>,
2114    ) -> Result<spirv::Word, dr::Error> {
2115        let extension_set = super::ext_inst_import(self, "NonSemantic.Shader.DebugInfo.100");
2116        let result_type = self.type_void();
2117        #[allow(unused_mut)]
2118        let mut args = vec![];
2119        self.ext_inst(
2120            result_type,
2121            result_id,
2122            extension_set,
2123            crate::spirv::DebugInfoOp::DebugNoLine as spirv::Word,
2124            args,
2125        )
2126    }
2127}
tracel_rspirv/dr/autogen_nonsemantic_shader_debuginfo_100.rs

tracel_rspirv/dr/
autogen_nonsemantic_shader_debuginfo_100.rs
