Move unsafe packed ref logic to Semantics, use `Attrs::by_key` to simplify repr attr lookup

1 files changed, 41 insertions, 0 deletions

diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index e392130ab..1072b3971 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -279,6 +279,47 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
     pub fn assert_contains_node(&self, node: &SyntaxNode) {
         self.imp.assert_contains_node(node)
     }
+
+    pub fn is_unsafe_pat(&self, pat: &ast::Pat) -> bool {
+        let ty = (|| {
+            let parent = match pat {
+                ast::Pat::BindPat(bind_pat) => bind_pat.syntax().parent()?,
+                _ => return None,
+            };
+
+            // `BindPat` can live under `RecordPat` directly under `RecordFieldPat` or
+            // `RecordFieldPatList`. `RecordFieldPat` also lives under `RecordFieldPatList`,
+            // so this tries to lookup the `BindPat` anywhere along that structure to the
+            // `RecordPat` so we can get the containing type.
+            let record_pat = ast::RecordFieldPat::cast(parent.clone())
+                .and_then(|record_pat| record_pat.syntax().parent())
+                .or_else(|| Some(parent.clone()))
+                .and_then(|parent| {
+                    ast::RecordFieldPatList::cast(parent)?
+                        .syntax()
+                        .parent()
+                        .and_then(ast::RecordPat::cast)
+                });
+
+            // If this doesn't match a `RecordPat`, fallback to a `LetStmt` to see if
+            // this is initialized from a `FieldExpr`.
+            if let Some(record_pat) = record_pat {
+                self.type_of_pat(&ast::Pat::RecordPat(record_pat))
+            } else if let Some(let_stmt) = ast::LetStmt::cast(parent) {
+                let field_expr = match let_stmt.initializer()? {
+                    ast::Expr::FieldExpr(field_expr) => field_expr,
+                    _ => return None,
+                };
+
+                self.type_of_expr(&field_expr.expr()?)
+            } else {
+                None
+            }
+        })();
+
+        // Binding a reference to a packed type is possibly unsafe.
+        ty.map(|ty| ty.is_packed(self.db)).unwrap_or(false)
+    }
 }
 
 impl<'db> SemanticsImpl<'db> {