gccrs: avoid ICE on generic const expressions in path resolution

Generic const expressions such as { N + 1 } are symbolic and cannot be
evaluated immediately during type checking path resolution. Previously,
these expressions were allowed to propagate, leading to assertion failures
and internal compiler errors (ICE) in the backend when it attempted to
resolve them as concrete values.

This patch adds validation in the typechecker to detect non-literal
const generic arguments during path resolution. It rejects symbolic
expressions gracefully by emitting a diagnostic, preventing the compiler
from crashing.

Fixes #4302

gcc/rust/ChangeLog:

	* typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::resolve_root_path):
	Reject non-literal generic const arguments to prevent ICE.
	(TypeCheckExpr::resolve_segments): Likewise.

gcc/testsuite/ChangeLog:

	* rust/compile/issue-4302.rs: New test.

Signed-off-by: Jayant Chauhan <0001jayant@gmail.com>

Author: Pasta-coder

gcc/rust/typecheck/rust-hir-type-check-path.cc

@@ -241,6 +241,69 @@ TypeCheckExpr::visit (HIR::PathInExpression &expr)
     }
 }
 
+/* Helper to check if a const generic expression is dependent (symbolic).
+   Returns true if the expression contains paths or identifiers (e.g., { N + 1
+   }). Returns false if the expression is purely literal/concrete (e.g., { 1 + 1
+   }).  */
+static bool
+is_const_dependent (HIR::Expr &expr)
+{
+  switch (expr.get_expression_type ())
+    {
+    // These imply dependency on a name (likely a generic parameter)
+    case HIR::Expr::ExprType::Path:
+      return true;
+
+    // Literals are not dependent
+    case HIR::Expr::ExprType::Lit:
+      return false;
+
+    // Recurse into blocks
+    case HIR::Expr::ExprType::Block:
+      {
+	auto &block = static_cast<HIR::BlockExpr &> (expr);
+	if (block.has_expr ())
+	  // get_final_expr returns reference -> No '*'
+	  return is_const_dependent (block.get_final_expr ());
+
+	if (!block.get_statements ().empty ())
+	  return true;
+
+	return false;
+      }
+
+    // Recurse into grouping (e.g., (N))
+    case HIR::Expr::ExprType::Grouped:
+      {
+	auto &group = static_cast<HIR::GroupedExpr &> (expr);
+	// get_expr_in_parens returns unique_ptr -> Needs '*'
+	return is_const_dependent (*group.get_expr_in_parens ());
+      }
+
+    default:
+      break;
+    }
+
+  // Fallback: Check specific classes using dynamic_cast.
+  // This handles types like ArithmeticOrLogical and Negation regardless
+  // of their enum mapping (which may be ExprType::Operator or similar).
+
+  if (auto *binary = dynamic_cast<HIR::ArithmeticOrLogicalExpr *> (&expr))
+    {
+      // get_lhs/rhs return unique_ptr -> Needs '*'
+      return is_const_dependent (*binary->get_lhs ())
+	     || is_const_dependent (*binary->get_rhs ());
+    }
+
+  if (auto *neg = dynamic_cast<HIR::NegationExpr *> (&expr))
+    {
+      // get_expr returns unique_ptr -> Needs '*'
+      return is_const_dependent (*neg->get_expr ());
+    }
+
+  return false;
+}
+
 TyTy::BaseType *
 TypeCheckExpr::resolve_root_path (HIR::PathInExpression &expr, size_t *offset,
 				  NodeId *root_resolved_node_id)
@@ -366,6 +429,25 @@ TypeCheckExpr::resolve_root_path (HIR::PathInExpression &expr, size_t *offset,
       // turbo-fish segment path::<ty>
       if (seg.has_generic_args ())
 	{
+	  // Check for dependent const expressions (like { N + 1 })
+	  bool is_dependent = false;
+	  for (auto &arg : seg.get_generic_args ().get_const_args ())
+	    {
+	      if (is_const_dependent (*arg.get_expression ()))
+		{
+		  is_dependent = true;
+		  break;
+		}
+	    }
+
+	  if (is_dependent)
+	    {
+	      *root_resolved_node_id = ref_node_id;
+	      *offset = *offset + 1;
+	      root_tyty = lookup;
+	      continue;
+	    }
+
 	  lookup = SubstMapper::Resolve (lookup, expr.get_locus (),
 					 &seg.get_generic_args (),
 					 context->regions_from_generic_args (
@@ -524,6 +606,20 @@ TypeCheckExpr::resolve_segments (NodeId root_resolved_node_id,
 
       if (seg.has_generic_args ())
 	{
+	  // Check for dependent const expressions (like { N + 1 })
+	  bool is_dependent = false;
+	  for (auto &arg : seg.get_generic_args ().get_const_args ())
+	    {
+	      if (is_const_dependent (*arg.get_expression ()))
+		{
+		  is_dependent = true;
+		  break;
+		}
+	    }
+	  if (is_dependent)
+	    {
+	      continue;
+	    }
 	  rust_debug_loc (seg.get_locus (), "applying segment generics: %s",
 			  tyseg->as_string ().c_str ());
 	  tyseg

gcc/testsuite/rust/compile/issue-4302.rs

@@ -0,0 +1,6 @@
+pub struct Foo<const N: usize>;
+
+pub fn foo<const N: usize>() -> Foo<{ N + 1 }> { // { dg-error "cannot evaluate constant expression with generic parameters" }
+    Foo
+}
+// { dg-excess-errors "Noisy error cascade" }