feat(ast)!: add span to yul switch cases (#493)

Also renames to `branches` to `cases`, and moves the default case into
the list.

Author: DaniPopes

crates/ast/src/ast/yul.rs

@@ -157,16 +157,25 @@ pub enum StmtKind<'ast> {
 #[derive(Debug)]
 pub struct StmtSwitch<'ast> {
     pub selector: Expr<'ast>,
-    pub branches: Box<'ast, [StmtSwitchCase<'ast>]>,
-    pub default_case: Option<Block<'ast>>,
+    /// The cases of the switch statement. Includes the default case in the last position, if any.
+    pub cases: Box<'ast, [StmtSwitchCase<'ast>]>,
+}
+
+impl<'ast> StmtSwitch<'ast> {
+    /// Returns the default case of the switch statement, if any.
+    pub fn default_case(&self) -> Option<&StmtSwitchCase<'ast>> {
+        self.cases.last().filter(|case| case.constant.is_none())
+    }
 }
 
 /// Represents a non-default case of a Yul switch statement.
 ///
 /// See [`StmtSwitch`] for more information.
 #[derive(Debug)]
 pub struct StmtSwitchCase<'ast> {
-    pub constant: Lit<'ast>,
+    pub span: Span,
+    /// The constant of the case, if any. `None` for the default case.
+    pub constant: Option<Lit<'ast>>,
     pub body: Block<'ast>,
 }
 

crates/ast/src/visit.rs

@@ -565,20 +565,20 @@ declare_visitors! {
         }
 
         fn visit_yul_stmt_switch(&mut self, switch: &'ast #mut yul::StmtSwitch<'ast>) -> ControlFlow<Self::BreakValue> {
-            let yul::StmtSwitch { selector, branches, default_case } = switch;
+            let yul::StmtSwitch { selector, cases } = switch;
             self.visit_yul_expr #_mut(selector)?;
-            for case in branches.iter #_mut() {
+            for case in cases.iter #_mut() {
                 self.visit_yul_stmt_case #_mut(case)?;
             }
-            if let Some(case) = default_case {
-                self.visit_yul_block #_mut(case)?;
-            }
             ControlFlow::Continue(())
         }
 
         fn visit_yul_stmt_case(&mut self, case: &'ast #mut yul::StmtSwitchCase<'ast>) -> ControlFlow<Self::BreakValue> {
-            let yul::StmtSwitchCase { constant, body } = case;
-            self.visit_lit #_mut(constant)?;
+            let yul::StmtSwitchCase { span, constant, body } = case;
+            self.visit_span #_mut(span)?;
+            if let Some(constant) = constant {
+                self.visit_lit #_mut(constant)?;
+            }
             self.visit_yul_block #_mut(body)?;
             ControlFlow::Continue(())
         }

crates/parse/src/parser/yul.rs

@@ -2,7 +2,7 @@ use super::SeqSep;
 use crate::{PResult, Parser};
 use smallvec::SmallVec;
 use solar_ast::{
-    AstPath, Box, DocComments, Lit, LitKind, PathSlice, StrKind, StrLit, token::*, yul::*,
+    AstPath, Box, DocComments, Lit, LitKind, PathSlice, StrKind, StrLit, Symbol, token::*, yul::*,
 };
 use solar_interface::{Ident, error_code, kw, sym};
 
@@ -214,20 +214,16 @@ impl<'sess, 'ast> Parser<'sess, 'ast> {
     fn parse_yul_stmt_switch(&mut self) -> PResult<'sess, StmtSwitch<'ast>> {
         let lo = self.prev_token.span;
         let selector = self.parse_yul_expr()?;
-        let mut branches = Vec::new();
-        while self.eat_keyword(kw::Case) {
-            let constant = self.parse_yul_lit()?;
-            self.expect_no_subdenomination();
-            let body = self.parse_yul_block_unchecked()?;
-            branches.push(StmtSwitchCase { constant, body });
+        let mut cases = Vec::new();
+        while self.check_keyword(kw::Case) {
+            cases.push(self.parse_yul_stmt_switch_case(kw::Case)?);
         }
-        let branches = self.alloc_vec(branches);
-        let default_case = if self.eat_keyword(kw::Default) {
-            Some(self.parse_yul_block_unchecked()?)
+        let default_case = if self.check_keyword(kw::Default) {
+            Some(self.parse_yul_stmt_switch_case(kw::Default)?)
         } else {
             None
         };
-        if branches.is_empty() {
+        if cases.is_empty() {
             let span = lo.to(self.prev_token.span);
             if default_case.is_none() {
                 self.dcx().err("`switch` statement has no cases").span(span).emit();
@@ -239,7 +235,28 @@ impl<'sess, 'ast> Parser<'sess, 'ast> {
                     .emit();
             }
         }
-        Ok(StmtSwitch { selector, branches, default_case })
+        if let Some(default_case) = default_case {
+            cases.push(default_case);
+        }
+        let cases = self.alloc_vec(cases);
+        Ok(StmtSwitch { selector, cases })
+    }
+
+    fn parse_yul_stmt_switch_case(&mut self, kw: Symbol) -> PResult<'sess, StmtSwitchCase<'ast>> {
+        self.parse_spanned(|this| {
+            debug_assert!(this.token.is_keyword(kw));
+            this.bump();
+            let constant = if kw == kw::Case {
+                let lit = this.parse_yul_lit()?;
+                this.expect_no_subdenomination();
+                Some(lit)
+            } else {
+                None
+            };
+            let body = this.parse_yul_block_unchecked()?;
+            Ok((constant, body))
+        })
+        .map(|(span, (constant, body))| StmtSwitchCase { span, constant, body })
     }
 
     /// Parses a Yul for statement.

crates/sema/src/stats.rs

@@ -474,12 +474,9 @@ impl<'ast> Visit<'ast> for StatCollector {
     ) -> ControlFlow<Self::BreakValue> {
         self.record("YulStmtSwitch", None, switch);
         // Don't visit selector field since it isn't boxed
-        for case in switch.branches.iter() {
+        for case in switch.cases.iter() {
             self.visit_yul_stmt_case(case)?;
         }
-        if let Some(case) = &switch.default_case {
-            self.visit_yul_block(case)?;
-        }
         ControlFlow::Continue(())
     }
 

tests/ui/parser/bad_switch.sol

@@ -0,0 +1,8 @@
+function f() {
+    assembly {
+        switch 42 //~ ERROR: `switch` statement has no cases
+
+        switch 42 //~ WARN: `switch` statement has only a default case
+        default {}
+    }
+}

tests/ui/parser/bad_switch.stderr

@@ -0,0 +1,15 @@
+error: `switch` statement has no cases
+  --> ROOT/tests/ui/parser/bad_switch.sol:LL:CC
+   |
+LL |         switch 42
+   |         ^^^^^^^^^
+
+warning[9592]: `switch` statement has only a default case
+  --> ROOT/tests/ui/parser/bad_switch.sol:LL:CC
+   |
+LL | /         switch 42
+LL | |         default {}
+   | |__________________^
+
+error: aborting due to 1 previous error; 1 warning emitted
+