Metaprogramming stuff

crates/common/src/diagnostics.rs

@@ -187,6 +187,7 @@ pub enum DiagnosticPass {
     MsgLower,
     EventLower,
     ErrorLower,
+    DeriveLower,
     ArithmeticAttr,
     PayableAttr,
 
@@ -215,6 +216,7 @@ impl DiagnosticPass {
             Self::MsgLower => 9,
             Self::EventLower => 10,
             Self::ErrorLower => 16,
+            Self::DeriveLower => 17,
             Self::ArithmeticAttr => 12,
             Self::PayableAttr => 13,
             Self::InlineAttr => 14,

crates/hir/src/analysis/analysis_pass.rs

@@ -1,7 +1,7 @@
 use crate::analysis::{HirAnalysisDb, diagnostics::DiagnosticVoucher};
 use crate::{
-    ArithmeticAttrError, ErrorDiagnostic, EventError, InlineAttrError, LoopUnrollAttrError,
-    ParserError, PayableError, SelectorError,
+    ArithmeticAttrError, DeriveError, ErrorDiagnostic, EventError, InlineAttrError,
+    LoopUnrollAttrError, ParserError, PayableError, SelectorError,
     hir_def::{ModuleTree, TopLevelMod},
     lower::{parse_file_impl, scope_graph_impl},
 };
@@ -131,6 +131,22 @@ impl ModuleAnalysisPass for ErrorLowerPass {
     }
 }
 
+/// Analysis pass that collects derive lowering errors from `#[derive(...)]` struct desugaring.
+pub struct DeriveLowerPass {}
+
+impl ModuleAnalysisPass for DeriveLowerPass {
+    fn run_on_module<'db>(
+        &mut self,
+        db: &'db dyn HirAnalysisDb,
+        top_mod: TopLevelMod<'db>,
+    ) -> Vec<Box<dyn DiagnosticVoucher>> {
+        scope_graph_impl::accumulated::<DeriveError>(db, top_mod)
+            .into_iter()
+            .map(|d| Box::new(d.clone()) as _)
+            .collect::<Vec<_>>()
+    }
+}
+
 /// Analysis pass that collects arithmetic attribute validation errors.
 pub struct ArithmeticAttrPass {}
 

crates/hir/src/analysis/diagnostics.rs

@@ -712,6 +712,52 @@ impl DiagnosticVoucher for crate::ErrorDiagnostic {
     }
 }
 
+impl DiagnosticVoucher for crate::DeriveError {
+    fn to_complete(&self, _db: &dyn SpannedHirAnalysisDb) -> CompleteDiagnostic {
+        use crate::DeriveErrorKind;
+
+        let primary_span = Span::new(self.file, self.primary_range, SpanKind::Original);
+
+        let (code, message, label, notes) = match &self.kind {
+            DeriveErrorKind::DeriveOnEnum => (
+                1,
+                "`#[derive]` is only valid on structs".to_string(),
+                "`#[derive]` cannot be applied to enums".to_string(),
+                vec!["move `#[derive]` to a struct declaration".to_string()],
+            ),
+            DeriveErrorKind::DeriveOnGenericStruct { trait_name } => (
+                2,
+                format!("`#[derive({trait_name})]` structs must be non-generic"),
+                "generics are not supported on derived structs".to_string(),
+                vec!["remove generic parameters from the struct".to_string()],
+            ),
+            DeriveErrorKind::UnknownDeriveTrait { name } => (
+                3,
+                format!("unknown derive trait `{name}`"),
+                format!("`{name}` is not a recognized derive trait"),
+                vec![format!(
+                    "recognized traits: {}",
+                    crate::lower::derive::KNOWN_DERIVE_TRAITS.join(", ")
+                )],
+            ),
+        };
+
+        let error_code = GlobalErrorCode::new(DiagnosticPass::DeriveLower, code);
+
+        CompleteDiagnostic::new(
+            Severity::Error,
+            message,
+            vec![SubDiagnostic::new(
+                LabelStyle::Primary,
+                label,
+                Some(primary_span),
+            )],
+            notes,
+            error_code,
+        )
+    }
+}
+
 impl DiagnosticVoucher for crate::InlineAttrError {
     fn to_complete(&self, _db: &dyn SpannedHirAnalysisDb) -> CompleteDiagnostic {
         use crate::hir_def::InlineAttrErrorKind;

crates/hir/src/analysis/mod.rs

@@ -6,8 +6,8 @@ pub mod place;
 pub mod semantic;
 
 use self::analysis_pass::{
-    AnalysisPassManager, ArithmeticAttrPass, ErrorLowerPass, EventLowerPass, InlineAttrPass,
-    LoopUnrollAttrPass, MsgLowerPass, ParsingPass, PayableAttrPass,
+    AnalysisPassManager, ArithmeticAttrPass, DeriveLowerPass, ErrorLowerPass, EventLowerPass,
+    InlineAttrPass, LoopUnrollAttrPass, MsgLowerPass, ParsingPass, PayableAttrPass,
 };
 use self::name_resolution::ImportAnalysisPass;
 use self::ty::{
@@ -33,6 +33,7 @@ pub fn initialize_analysis_pass() -> AnalysisPassManager {
     pass_manager.add_module_pass("MsgLower", Box::new(MsgLowerPass {}));
     pass_manager.add_module_pass("EventLower", Box::new(EventLowerPass {}));
     pass_manager.add_module_pass("ErrorLower", Box::new(ErrorLowerPass {}));
+    pass_manager.add_module_pass("DeriveLower", Box::new(DeriveLowerPass {}));
     pass_manager.add_module_pass("InlineAttr", Box::new(InlineAttrPass {}));
     pass_manager.add_module_pass("LoopUnrollAttr", Box::new(LoopUnrollAttrPass {}));
     pass_manager.add_module_pass("MsgSelector", Box::new(MsgSelectorAnalysisPass {}));

crates/hir/src/analysis/semantic/borrowck/normalize.rs

@@ -738,6 +738,7 @@ impl<'db> NormalizeCtxt<'db> {
                     place,
                 }
             }
+            SExpr::DynField { base, .. } => NExpr::Use(self.normalize_operand(*base, origin)),
             SExpr::Index { base, index } => {
                 let place = self.project_local_place(
                     base.value,

crates/hir/src/analysis/semantic/ctfe/canonicalize.rs

@@ -264,6 +264,7 @@ fn writable_local_roots<'db>(
             | SExpr::ExtractEnumField { .. }
             | SExpr::CodeRegionOffset { .. }
             | SExpr::CodeRegionLen { .. }
+            | SExpr::DynField { .. }
             | SExpr::Call { .. } => {}
         }
     }