feat: warn when payable fallback function found but no receive function

crates/interface/src/diagnostics/context.rs

@@ -345,7 +345,10 @@ impl DiagCtxtInner {
         match (self.deduplicated_err_count, self.deduplicated_warn_count) {
             (0, 0) => Ok(()),
             (0, w) => {
-                self.emitter.emit_diagnostic(&Diag::new(Level::Warning, warnings(w)));
+                // TODO: Don't emit in tests since it's not handled by `ui_test`.
+                if self.flags.track_diagnostics {
+                    self.emitter.emit_diagnostic(&Diag::new(Level::Warning, warnings(w)));
+                }
                 Ok(())
             }
             (e, 0) => self.emit_diagnostic(Diag::new(Level::Error, errors(e))),

crates/sema/src/hir/mod.rs

@@ -612,6 +612,11 @@ pub struct Function<'hir> {
 }
 
 impl Function<'_> {
+    /// Returns the span of the `kind` keyword.
+    pub fn keyword_span(&self) -> Span {
+        self.span.with_hi(self.span.lo() + self.kind.to_str().len() as u32)
+    }
+
     /// Returns `true` if this is a free function, meaning it is not part of a contract.
     pub fn is_free(&self) -> bool {
         self.contract.is_none()

crates/sema/src/typeck/mod.rs

@@ -5,19 +5,37 @@ use crate::{
 };
 use rayon::prelude::*;
 use solar_data_structures::{map::FxHashSet, parallel};
+use solar_interface::error_code;
 
 pub(crate) fn check(gcx: Gcx<'_>) {
     parallel!(
         gcx.sess,
         gcx.hir.par_contract_ids().for_each(|id| {
             check_duplicate_definitions(gcx, &gcx.symbol_resolver.contract_scopes[id]);
+            check_payable_fallback_without_receive(gcx, id);
         }),
         gcx.hir.par_source_ids().for_each(|id| {
             check_duplicate_definitions(gcx, &gcx.symbol_resolver.source_scopes[id]);
         }),
     );
 }
 
+fn check_payable_fallback_without_receive(gcx: Gcx<'_>, contract_id: hir::ContractId) {
+    let contract = gcx.hir.contract(contract_id);
+
+    if let Some(fallback) = contract.fallback {
+        let fallback = gcx.hir.function(fallback);
+        if fallback.state_mutability.is_payable() && contract.receive.is_none() {
+            gcx.dcx()
+                .warn("contract has a payable fallback function, but no receive ether function")
+                .span(contract.name.span)
+                .code(error_code!(3628))
+                .span_help(fallback.keyword_span(), "consider changing `fallback` to `receive`")
+                .emit();
+        }
+    }
+}
+
 /// Checks for definitions that have the same name and parameter types in the given scope.
 fn check_duplicate_definitions(gcx: Gcx<'_>, scope: &Declarations) {
     let is_duplicate = |a: Declaration, b: Declaration| -> bool {

tests/ui/parser/payable_fallback_without_receive.sol

@@ -0,0 +1,17 @@
+contract P1 {
+    //~^ WARN: contract has a payable fallback function, but no receive ether function
+    fallback() external payable {}
+}
+
+contract P2 is P1 {
+    receive() external payable {}
+}
+
+contract P3 {
+    fallback() external payable {}
+
+    receive() external payable {}
+}
+
+contract P4 is P1 {}
+//~^ WARN: contract has a payable fallback function, but no receive ether function

tests/ui/parser/payable_fallback_without_receive.stderr

@@ -0,0 +1,22 @@
+warning[3628]: contract has a payable fallback function, but no receive ether function
+  --> ROOT/tests/ui/parser/payable_fallback_without_receive.sol:LL:CC
+   |
+LL | contract P1 {
+   |          --
+LL |
+LL |     fallback() external payable {}
+   |     -------- help: consider changing `fallback` to `receive`
+   |
+
+warning[3628]: contract has a payable fallback function, but no receive ether function
+  --> ROOT/tests/ui/parser/payable_fallback_without_receive.sol:LL:CC
+   |
+LL |     fallback() external payable {}
+   |     -------- help: consider changing `fallback` to `receive`
+LL | }
+...
+LL |
+LL | contract P4 is P1 {}
+   |          --
+   |
+