Improve cfg_if! parsing during module resolution

Fixes 4442

* Prevent Infinite loop when reaching tokens that can't be parsed as
  items. For example, nested `if #[..]` checks.
* Handle arbitrarily nested `if #[..]`, `else if #[..]`, `else` checks.

Author: ytmimi

src/parse/macros/cfg_if.rs

@@ -2,7 +2,7 @@ use std::panic::{catch_unwind, AssertUnwindSafe};
 
 use rustc_ast::ast;
 use rustc_ast::token::{Delimiter, TokenKind};
-use rustc_parse::parser::ForceCollect;
+use rustc_parse::parser::{ForceCollect, Parser};
 use rustc_span::symbol::kw;
 
 use crate::parse::macros::build_stream_parser;
@@ -31,40 +31,25 @@ fn parse_cfg_if_inner<'a>(
 
     while parser.token.kind != TokenKind::Eof {
         if process_if_cfg {
-            if !parser.eat_keyword(kw::If) {
-                return Err("Expected `if`");
-            }
-
-            if !matches!(parser.token.kind, TokenKind::Pound) {
-                return Err("Failed to parse attributes");
-            }
-
-            // Inner attributes are not actually syntactically permitted here, but we don't
-            // care about inner vs outer attributes in this position. Our purpose with this
-            // special case parsing of cfg_if macros is to ensure we can correctly resolve
-            // imported modules that may have a custom `path` defined.
-            //
-            // As such, we just need to advance the parser past the attribute and up to
-            // to the opening brace.
-            // See also https://github.com/rust-lang/rust/pull/79433
-            parser
-                .parse_attribute(rustc_parse::parser::attr::InnerAttrPolicy::Permitted)
-                .map_err(|e| {
-                    e.cancel();
-                    "Failed to parse attributes"
-                })?;
-        }
-
-        if !parser.eat(&TokenKind::OpenDelim(Delimiter::Brace)) {
-            return Err("Expected an opening brace");
+            eat_if(&mut parser)?;
         }
 
         while parser.token != TokenKind::CloseDelim(Delimiter::Brace)
             && parser.token.kind != TokenKind::Eof
         {
             let item = match parser.parse_item(ForceCollect::No) {
                 Ok(Some(item_ptr)) => item_ptr.into_inner(),
-                Ok(None) => continue,
+                Ok(None) => {
+                    if matches!(parser.token.kind, TokenKind::Ident(symbol, ..) if symbol == kw::If)
+                    {
+                        // eat a nested if
+                        eat_if(&mut parser)?;
+                    } else {
+                        // Not sure what token we're on. To prevent infinite loops bump the parser
+                        parser.bump();
+                    }
+                    continue;
+                }
                 Err(err) => {
                     err.cancel();
                     parser.psess.dcx.reset_err_count();
@@ -82,16 +67,49 @@ fn parse_cfg_if_inner<'a>(
             return Err("Expected a closing brace");
         }
 
-        if parser.eat(&TokenKind::Eof) {
-            break;
+        if matches!(parser.token.kind, TokenKind::Ident(symbol, ..) if symbol == kw::Else) {
+            // there might be an `else` after the `if`
+            parser.eat_keyword(kw::Else);
+            // there might be an opening brace after the `else`, but it might also be an `else if`
+            parser.eat(&TokenKind::OpenDelim(Delimiter::Brace));
         }
 
-        if !parser.eat_keyword(kw::Else) {
-            return Err("Expected `else`");
+        if parser.eat(&TokenKind::Eof) {
+            break;
         }
 
         process_if_cfg = parser.token.is_keyword(kw::If);
     }
 
     Ok(items)
 }
+
+fn eat_if(parser: &mut Parser<'_>) -> Result<(), &'static str> {
+    if !parser.eat_keyword(kw::If) {
+        return Err("Expected `if`");
+    }
+
+    if !matches!(parser.token.kind, TokenKind::Pound) {
+        return Err("Failed to parse attributes");
+    }
+
+    // Inner attributes are not actually syntactically permitted here, but we don't
+    // care about inner vs outer attributes in this position. Our purpose with this
+    // special case parsing of cfg_if macros is to ensure we can correctly resolve
+    // imported modules that may have a custom `path` defined.
+    //
+    // As such, we just need to advance the parser past the attribute and up to
+    // to the opening brace.
+    // See also https://github.com/rust-lang/rust/pull/79433
+    parser
+        .parse_attribute(rustc_parse::parser::attr::InnerAttrPolicy::Permitted)
+        .map_err(|e| {
+            e.cancel();
+            "Failed to parse attributes"
+        })?;
+
+    if !parser.eat(&TokenKind::OpenDelim(Delimiter::Brace)) {
+        return Err("Expected an opening brace");
+    }
+    Ok(())
+}

tests/source/issue-4442/a.rs

@@ -0,0 +1,2 @@
+fn a       ()
+{println!("mod a")}

tests/source/issue-4442/b.rs

@@ -0,0 +1,2 @@
+fn b       ()
+{println!("mod b")}

tests/source/issue-4442/c.rs

@@ -0,0 +1,2 @@
+fn c       ()
+{println!("mod c")}

tests/source/issue-4442/d.rs

@@ -0,0 +1,2 @@
+fn d       ()
+{println!("mod d")}

tests/source/issue-4442/e.rs

@@ -0,0 +1,2 @@
+fn e       ()
+{println!("mod e")}

tests/source/issue-4442/lib.rs

@@ -0,0 +1,26 @@
+// main.rs
+cfg_if::cfg_if! {
+    if #[cfg(not(feature = "client"))] {
+        mod a;
+        if #[cfg(feature = "server")] {
+            if #[cfg(not(feature = "client"))] {
+                if #[cfg(feature = "server")] {
+                    if #[cfg(not(feature = "client"))] {
+                        mod b;
+                    } else {
+                        mod c;
+                    }
+                    if #[cfg(feature = "server")] {
+                        if #[cfg(not(feature = "client"))] {
+                            if #[cfg(feature = "server")] {
+                                mod d;
+                            } else {
+                                mod e;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

tests/target/issue-4442/a.rs

@@ -0,0 +1,3 @@
+fn a() {
+    println!("mod a")
+}

tests/target/issue-4442/b.rs

@@ -0,0 +1,3 @@
+fn b() {
+    println!("mod b")
+}

tests/target/issue-4442/c.rs

@@ -0,0 +1,3 @@
+fn c() {
+    println!("mod c")
+}

tests/target/issue-4442/d.rs

@@ -0,0 +1,3 @@
+fn d() {
+    println!("mod d")
+}

tests/target/issue-4442/e.rs

@@ -0,0 +1,3 @@
+fn e() {
+    println!("mod e")
+}

tests/target/issue-4442/lib.rs

@@ -0,0 +1,26 @@
+// main.rs
+cfg_if::cfg_if! {
+    if #[cfg(not(feature = "client"))] {
+        mod a;
+        if #[cfg(feature = "server")] {
+            if #[cfg(not(feature = "client"))] {
+                if #[cfg(feature = "server")] {
+                    if #[cfg(not(feature = "client"))] {
+                        mod b;
+                    } else {
+                        mod c;
+                    }
+                    if #[cfg(feature = "server")] {
+                        if #[cfg(not(feature = "client"))] {
+                            if #[cfg(feature = "server")] {
+                                mod d;
+                            } else {
+                                mod e;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}