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 <[email protected]>

Author: Pasta-coder

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

@@ -241,6 +241,64 @@ 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 }).
+static bool
+is_const_dependent (HIR::Expr &expr)
+{
+  switch (expr.get_expression_type ())
+    {
+    // Paths definitely imply dependency on a name/parameter
+    case HIR::Expr::ExprType::Path:
+      return true;
+
+    case HIR::Expr::ExprType::Block:
+      {
+	auto &block = static_cast<HIR::BlockExpr &> (expr);
+	if (block.has_expr ())
+	  return is_const_dependent (block.get_final_expr ());
+
+	if (!block.get_statements ().empty ())
+	  return true;
+
+	return false;
+      }
+
+    case HIR::Expr::ExprType::Grouped:
+      {
+	auto &group = static_cast<HIR::GroupedExpr &> (expr);
+	return is_const_dependent (group.get_expr_in_parens ());
+      }
+
+    case HIR::Expr::ExprType::Lit:
+      return false;
+
+    default:
+      return true;
+    }
+}
+
+// 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))
+  {
+    return is_const_dependent (binary->get_lhs ())
+	   || is_const_dependent (binary->get_rhs ());
+  }
+
+if (auto *neg = dynamic_cast<HIR::NegationExpr *> (&expr))
+  {
+    return is_const_dependent (neg->get_expr ());
+  }
+
+// If it is not a Path/Identifier and not a structure containing one,
+// assume it is concrete (independent).
+return false;
+}
+
 TyTy::BaseType *
 TypeCheckExpr::resolve_root_path (HIR::PathInExpression &expr, size_t *offset,
 				  NodeId *root_resolved_node_id)
@@ -366,6 +424,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 +601,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" }