Method parse_id_in

crates/rustc_codegen_spirv/src/builder/spirv_asm.rs:897–1038

(
        &mut self,
        id_map: &mut FxHashMap<&'a str, Word>,
        token: Token<'a, 'cx, 'tcx>,
    )

    }

    fn parse_id_in<'a>(
        &mut self,
        id_map: &mut FxHashMap<&'a str, Word>,
        token: Token<'a, 'cx, 'tcx>,
    ) -> Option<Word> {
        match token {
            Token::Word(word) => {
                if let Some(id) = word.strip_prefix('%') {
                    Some(*id_map.entry(id).or_insert_with(|| self.emit().id()))
                } else {
                    self.err("expected ID");
                    None
                }
            }
            Token::String(_) => {
                self.err("expected ID, not string");
                None
            }
            Token::Typeof(hole, span, kind) => match hole {
                InlineAsmOperandRef::In { reg, value } => {
                    self.check_reg(span, reg);
                    let ty = value.immediate().ty;
                    Some(match kind {
                        TypeofKind::Plain => ty,
                        TypeofKind::Dereference => match self.lookup_type(ty) {
                            SpirvType::Pointer { pointee } => pointee,
                            other => {
                                self.tcx.sess.span_err(
                                    span,
                                    format!(
                                        "cannot use typeof* on non-pointer type: {}",
                                        other.debug(ty, self)
                                    ),
                                );
                                ty
                            }
                        },
                    })
                }
                InlineAsmOperandRef::Out {
                    reg,
                    late: _,
                    place,
                } => {
                    self.check_reg(span, reg);
                    match place {
                        Some(place) => match self.lookup_type(place.llval.ty) {
                            SpirvType::Pointer { pointee } => Some(pointee),
                            other => {
                                self.tcx.sess.span_err(
                                    span,
                                    format!(
                                        "out register type not pointer: {}",
                                        other.debug(place.llval.ty, self)
                                    ),
                                );
                                None
                            }