Split some queries

crates/hir-def/src/attr.rs

@@ -12,6 +12,7 @@ use hir_expand::{
 use intern::{sym, Symbol};
 use la_arena::{ArenaMap, Idx, RawIdx};
 use mbe::DelimiterKind;
+use rustc_abi::ReprOptions;
 use syntax::{
     ast::{self, HasAttrs},
     AstPtr,
@@ -83,7 +84,7 @@ impl Attrs {
                 let krate = loc.parent.lookup(db).container.krate;
                 item_tree = loc.id.item_tree(db);
                 let variant = &item_tree[loc.id.value];
-                (FieldParent::Variant(loc.id.value), &variant.fields, krate)
+                (FieldParent::EnumVariant(loc.id.value), &variant.fields, krate)
             }
             VariantId::StructId(it) => {
                 let loc = it.lookup(db);
@@ -221,6 +222,130 @@ impl Attrs {
     pub fn is_unstable(&self) -> bool {
         self.by_key(&sym::unstable).exists()
     }
+
+    pub fn rustc_legacy_const_generics(&self) -> Option<Box<Box<[u32]>>> {
+        self.by_key(&sym::rustc_legacy_const_generics)
+            .tt_values()
+            .next()
+            .map(parse_rustc_legacy_const_generics)
+            .filter(|it| !it.is_empty())
+            .map(Box::new)
+    }
+
+    pub fn repr(&self) -> Option<ReprOptions> {
+        self.by_key(&sym::repr).tt_values().find_map(parse_repr_tt)
+    }
+}
+
+fn parse_rustc_legacy_const_generics(tt: &crate::tt::TopSubtree) -> Box<[u32]> {
+    let mut indices = Vec::new();
+    let mut iter = tt.iter();
+    while let (Some(first), second) = (iter.next(), iter.next()) {
+        match first {
+            TtElement::Leaf(tt::Leaf::Literal(lit)) => match lit.symbol.as_str().parse() {
+                Ok(index) => indices.push(index),
+                Err(_) => break,
+            },
+            _ => break,
+        }
+
+        if let Some(comma) = second {
+            match comma {
+                TtElement::Leaf(tt::Leaf::Punct(punct)) if punct.char == ',' => {}
+                _ => break,
+            }
+        }
+    }
+
+    indices.into_boxed_slice()
+}
+
+fn parse_repr_tt(tt: &crate::tt::TopSubtree) -> Option<ReprOptions> {
+    use crate::builtin_type::{BuiltinInt, BuiltinUint};
+    use rustc_abi::{Align, Integer, IntegerType, ReprFlags, ReprOptions};
+
+    match tt.top_subtree().delimiter {
+        tt::Delimiter { kind: DelimiterKind::Parenthesis, .. } => {}
+        _ => return None,
+    }
+
+    let mut flags = ReprFlags::empty();
+    let mut int = None;
+    let mut max_align: Option<Align> = None;
+    let mut min_pack: Option<Align> = None;
+
+    let mut tts = tt.iter();
+    while let Some(tt) = tts.next() {
+        if let TtElement::Leaf(tt::Leaf::Ident(ident)) = tt {
+            flags.insert(match &ident.sym {
+                s if *s == sym::packed => {
+                    let pack = if let Some(TtElement::Subtree(_, mut tt_iter)) = tts.peek() {
+                        tts.next();
+                        if let Some(TtElement::Leaf(tt::Leaf::Literal(lit))) = tt_iter.next() {
+                            lit.symbol.as_str().parse().unwrap_or_default()
+                        } else {
+                            0
+                        }
+                    } else {
+                        0
+                    };
+                    let pack = Align::from_bytes(pack).unwrap_or(Align::ONE);
+                    min_pack =
+                        Some(if let Some(min_pack) = min_pack { min_pack.min(pack) } else { pack });
+                    ReprFlags::empty()
+                }
+                s if *s == sym::align => {
+                    if let Some(TtElement::Subtree(_, mut tt_iter)) = tts.peek() {
+                        tts.next();
+                        if let Some(TtElement::Leaf(tt::Leaf::Literal(lit))) = tt_iter.next() {
+                            if let Ok(align) = lit.symbol.as_str().parse() {
+                                let align = Align::from_bytes(align).ok();
+                                max_align = max_align.max(align);
+                            }
+                        }
+                    }
+                    ReprFlags::empty()
+                }
+                s if *s == sym::C => ReprFlags::IS_C,
+                s if *s == sym::transparent => ReprFlags::IS_TRANSPARENT,
+                s if *s == sym::simd => ReprFlags::IS_SIMD,
+                repr => {
+                    if let Some(builtin) = BuiltinInt::from_suffix_sym(repr)
+                        .map(Either::Left)
+                        .or_else(|| BuiltinUint::from_suffix_sym(repr).map(Either::Right))
+                    {
+                        int = Some(match builtin {
+                            Either::Left(bi) => match bi {
+                                BuiltinInt::Isize => IntegerType::Pointer(true),
+                                BuiltinInt::I8 => IntegerType::Fixed(Integer::I8, true),
+                                BuiltinInt::I16 => IntegerType::Fixed(Integer::I16, true),
+                                BuiltinInt::I32 => IntegerType::Fixed(Integer::I32, true),
+                                BuiltinInt::I64 => IntegerType::Fixed(Integer::I64, true),
+                                BuiltinInt::I128 => IntegerType::Fixed(Integer::I128, true),
+                            },
+                            Either::Right(bu) => match bu {
+                                BuiltinUint::Usize => IntegerType::Pointer(false),
+                                BuiltinUint::U8 => IntegerType::Fixed(Integer::I8, false),
+                                BuiltinUint::U16 => IntegerType::Fixed(Integer::I16, false),
+                                BuiltinUint::U32 => IntegerType::Fixed(Integer::I32, false),
+                                BuiltinUint::U64 => IntegerType::Fixed(Integer::I64, false),
+                                BuiltinUint::U128 => IntegerType::Fixed(Integer::I128, false),
+                            },
+                        });
+                    }
+                    ReprFlags::empty()
+                }
+            })
+        }
+    }
+
+    Some(ReprOptions {
+        int,
+        align: max_align,
+        pack: min_pack,
+        flags,
+        field_shuffle_seed: rustc_hashes::Hash64::ZERO,
+    })
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]