gccrs: avoid ICE on generic const expressions in path resolution

Generic const expressions such as `{ N + 1 }` are symbolic and cannot be
evaluated to a concrete value immediately during type checking. Previously,
the compiler lacked a representation for these symbolic expressions in the
type system, causing it to treat them as concrete values. This led to
assertion failures and Internal Compiler Errors (ICE) in the backend and
path resolution logic when the compiler attempted to access the raw value.

This patch introduces `TyTy::ConstExprType`, a new type variant designed
to hold symbolic expressions that have not yet been evaluated. It updates
the core type system, substitution mapper, unification rules, call checkers,
and backend compilation visitors to handle this new type gracefully.

Key changes include:
1. Validating const generic arguments in path resolution to detect dependency
   using the name resolver.
2. Bridging the substitution mapper to clone symbolic expressions.
3. Updating backend type compilation (`TyTyResolveCompile`) to compile the
   underlying expression tree for symbolic types instead of crashing.
4. Handling non-value constants in path resolution by emitting a specific
   diagnostic ("cannot evaluate constant expression") before returning failure.
5. Updating existing tests to match the new `<const_expr>` string representation.

Fixes Rust-GCC#4341

gcc/rust/ChangeLog:

	* backend/rust-compile-resolve-path.cc (ResolvePathRef::resolve_with_node_id):
	Emit diagnostic and return error_mark_node for non-value constants.
	* backend/rust-compile-type.cc (TyTyResolveCompile::visit): Compile the
	underlying expression for ConstExprType.
	* backend/rust-compile-type.h: Declare visit method.
	* typecheck/rust-hir-type-check-path.cc (is_const_dependent): New helper.
	(TypeCheckExpr::resolve_root_path): Skip immediate resolution for
	dependent const arguments.
	(TypeCheckExpr::resolve_segments): Likewise.
	* typecheck/rust-hir-type-check-pattern.cc (TypeCheckPattern::visit):
	Handle ConstKind::Expr in switch to prevent fallthrough.
	* typecheck/rust-substitution-mapper.cc (SubstMapperInternal::visit):
	Implement cloning for ConstExprType.
	* typecheck/rust-substitution-mapper.h: Add visit declarations.
	* typecheck/rust-tyty-call.cc (TypeCheckCallExpr::visit): Implement stub
	for ConstExprType.
	* typecheck/rust-tyty-call.h: Declare visit method.
	* typecheck/rust-tyty-variance-analysis-private.h (VisitorBase::visit):
	Add stub implementation.
	* typecheck/rust-tyty-visitor.h: Add virtual visit methods.
	* typecheck/rust-tyty.cc (ConstExprType::const_kind): Implement.
	(ConstExprType::accept_vis): Implement.
	(ConstExprType::as_string): Implement.
	(ConstExprType::clone): Implement.
	(ConstExprType::is_equal): Implement.
	(ConstExprType::get_expr): Implement.
	* typecheck/rust-tyty.h (enum ConstKind): Add Expr variant.
	(class ConstExprType): New class definition.
	* typecheck/rust-unify.cc (UnifyRules::expect_const): Add unification
	logic for ConstExprType.

gcc/testsuite/ChangeLog:

	* rust/compile/const_generics_10.rs: Update expected error messages to
	match <const_expr> representation.
	* rust/compile/issue-4302.rs: New test.

Signed-off-by: Jayant Chauhan <[email protected]>

Author: Pasta-coder

gcc/rust/backend/rust-compile-resolve-path.cc

@@ -193,7 +193,12 @@ ResolvePathRef::resolve_with_node_id (
       auto d = lookup->destructure ();
       rust_assert (d->get_kind () == TyTy::TypeKind::CONST);
       auto c = d->as_const_type ();
-      rust_assert (c->const_kind () == TyTy::BaseConstType::ConstKind::Value);
+      if (c->const_kind () != TyTy::BaseConstType::ConstKind::Value)
+	{
+	  // Emit diagnostic so the test passes instead of silently failing
+	  rust_error_at (expr_locus, "cannot evaluate constant expression");
+	  return error_mark_node;
+	}
       auto val = static_cast<TyTy::ConstValueType *> (c);
       return val->get_value ();
     }

gcc/rust/backend/rust-compile-type.cc

@@ -19,6 +19,7 @@
 #include "rust-compile-type.h"
 #include "rust-constexpr.h"
 #include "rust-compile-base.h"
+#include "rust-compile-expr.h"
 
 #include "tree.h"
 #include "fold-const.h"
@@ -165,6 +166,12 @@ TyTyResolveCompile::visit (const TyTy::ConstErrorType &type)
   translated = error_mark_node;
 }
 
+void
+TyTyResolveCompile::visit (const TyTy::ConstExprType &type)
+{
+  translated = CompileExpr::Compile (*type.get_expr (), ctx);
+}
+
 void
 TyTyResolveCompile::visit (const TyTy::ProjectionType &type)
 {
@@ -488,9 +495,11 @@ TyTyResolveCompile::visit (const TyTy::ArrayType &type)
 {
   tree element_type
     = TyTyResolveCompile::compile (ctx, type.get_element_type ());
+
+  // 1. Get capacity
   auto const_capacity = type.get_capacity ();
 
-  // Check if capacity is a const type
+  // 2. CHECK if it is valid BEFORE using it
   if (const_capacity->get_kind () != TyTy::TypeKind::CONST)
     {
       rust_error_at (type.get_locus (), "array capacity is not a const type");
@@ -499,14 +508,23 @@ TyTyResolveCompile::visit (const TyTy::ArrayType &type)
     }
 
   auto *capacity_const = const_capacity->as_const_type ();
+  tree folded_capacity_expr = error_mark_node;
+  if (capacity_const->const_kind () == TyTy::BaseConstType::ConstKind::Expr)
+    {
+      auto &expr_type
+	= *static_cast<const TyTy::ConstExprType *> (capacity_const);
 
-  rust_assert (capacity_const->const_kind ()
-	       == TyTy::BaseConstType::ConstKind::Value);
-  auto &capacity_value = *static_cast<TyTy::ConstValueType *> (capacity_const);
-  auto folded_capacity_expr = capacity_value.get_value ();
+      folded_capacity_expr = CompileExpr::Compile (*expr_type.get_expr (), ctx);
+    }
+  else
+    {
+      rust_assert (capacity_const->const_kind ()
+		   == TyTy::BaseConstType::ConstKind::Value);
+      auto &capacity_value
+	= *static_cast<const TyTy::ConstValueType *> (capacity_const);
+      folded_capacity_expr = capacity_value.get_value ();
+    }
 
-  // build_index_type takes the maximum index, which is one less than
-  // the length.
   tree index_type_tree = build_index_type (
     fold_build2 (MINUS_EXPR, sizetype, folded_capacity_expr, size_one_node));
 

gcc/rust/backend/rust-compile-type.h

@@ -54,6 +54,7 @@ class TyTyResolveCompile : protected TyTy::TyConstVisitor
   void visit (const TyTy::ConstValueType &) override;
   void visit (const TyTy::ConstInferType &) override;
   void visit (const TyTy::ConstErrorType &) override;
+  void visit (const TyTy::ConstExprType &) override;
   void visit (const TyTy::StrType &) override;
   void visit (const TyTy::NeverType &) override;
   void visit (const TyTy::PlaceholderType &) override;

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

@@ -30,6 +30,8 @@
 #include "rust-hir-item.h"
 #include "rust-session-manager.h"
 #include "rust-immutable-name-resolution-context.h"
+#include "rust-name-resolver.h"
+#include "rust-hir-expr.h"
 
 namespace Rust {
 namespace Resolver {
@@ -241,6 +243,66 @@ 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 ())
+    {
+    case HIR::Expr::ExprType::Path:
+      {
+	// A path is only dependent if it resolves to a generic parameter.
+	// We use Resolver2_0 to find the definition ID.
+	auto &nr_ctx
+	  = Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
+	auto resolved = nr_ctx.lookup (expr.get_mappings ().get_nodeid ());
+
+	if (!resolved)
+	  return false;
+
+	return Analysis::Mappings::get ().lookup_hir_generic_param (*resolved)
+	       != nullptr;
+      }
+
+    case HIR::Expr::ExprType::Lit:
+      return false;
+
+    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::Operator:
+      {
+	auto &arith = static_cast<HIR::ArithmeticOrLogicalExpr &> (expr);
+
+	return is_const_dependent (arith.get_lhs ())
+	       || is_const_dependent (arith.get_rhs ());
+      }
+
+    default:
+      return true;
+    }
+}
+
 TyTy::BaseType *
 TypeCheckExpr::resolve_root_path (HIR::PathInExpression &expr, size_t *offset,
 				  NodeId *root_resolved_node_id)
@@ -366,6 +428,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 +605,21 @@ 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/rust/typecheck/rust-hir-type-check-pattern.cc

@@ -823,6 +823,7 @@ TypeCheckPattern::visit (HIR::SlicePattern &pattern)
 	  case TyTy::BaseConstType::ConstKind::Decl:
 	  case TyTy::BaseConstType::ConstKind::Infer:
 	  case TyTy::BaseConstType::ConstKind::Error:
+	  case TyTy::BaseConstType::ConstKind::Expr:
 	    cap = error_mark_node;
 	    break;
 	  }

gcc/rust/typecheck/rust-substitution-mapper.cc

@@ -291,6 +291,12 @@ SubstMapperInternal::visit (TyTy::ConstErrorType &type)
   resolved = type.clone ();
 }
 
+void
+SubstMapperInternal::visit (TyTy::ConstExprType &type)
+{
+  resolved = type.clone ();
+}
+
 void
 SubstMapperInternal::visit (TyTy::PlaceholderType &type)
 {

gcc/rust/typecheck/rust-substitution-mapper.h

@@ -65,6 +65,7 @@ class SubstMapper : public TyTy::TyVisitor
   void visit (TyTy::ConstValueType &) override { rust_unreachable (); }
   void visit (TyTy::ConstInferType &) override { rust_unreachable (); }
   void visit (TyTy::ConstErrorType &) override { rust_unreachable (); }
+  void visit (TyTy::ConstExprType &) override { rust_unreachable (); }
   void visit (TyTy::StrType &) override { rust_unreachable (); }
   void visit (TyTy::NeverType &) override { rust_unreachable (); }
   void visit (TyTy::DynamicObjectType &) override { rust_unreachable (); }
@@ -100,6 +101,7 @@ class SubstMapperInternal : public TyTy::TyVisitor
   void visit (TyTy::ConstValueType &type) override;
   void visit (TyTy::ConstInferType &type) override;
   void visit (TyTy::ConstErrorType &type) override;
+  void visit (TyTy::ConstExprType &type) override;
   void visit (TyTy::PlaceholderType &type) override;
   void visit (TyTy::ProjectionType &type) override;
   void visit (TyTy::ClosureType &type) override;
@@ -157,6 +159,7 @@ class SubstMapperFromExisting : public TyTy::TyVisitor
   void visit (TyTy::ConstValueType &) override { rust_unreachable (); }
   void visit (TyTy::ConstInferType &) override { rust_unreachable (); }
   void visit (TyTy::ConstErrorType &) override { rust_unreachable (); }
+  void visit (TyTy::ConstExprType &) override { rust_unreachable (); }
   void visit (TyTy::StrType &) override { rust_unreachable (); }
   void visit (TyTy::NeverType &) override { rust_unreachable (); }
   void visit (TyTy::PlaceholderType &) override { rust_unreachable (); }
@@ -201,6 +204,7 @@ class GetUsedSubstArgs : public TyTy::TyConstVisitor
   void visit (const TyTy::ConstValueType &) override {}
   void visit (const TyTy::ConstInferType &) override {}
   void visit (const TyTy::ConstErrorType &) override {}
+  void visit (const TyTy::ConstExprType &) override {}
   void visit (const TyTy::StrType &) override {}
   void visit (const TyTy::NeverType &) override {}
   void visit (const TyTy::PlaceholderType &) override {}

gcc/rust/typecheck/rust-tyty-call.cc

@@ -300,6 +300,13 @@ TypeCheckCallExpr::visit (FnPtr &type)
   resolved = type.get_return_type ()->monomorphized_clone ();
 }
 
+void
+TypeCheckCallExpr::visit (ConstExprType &type)
+{
+  // A constant expression is not a callable function.
+  // We do nothing, which leaves 'resolved' as nullptr and fails gracefully.
+}
+
 // method call checker
 
 TypeCheckMethodCallExpr::TypeCheckMethodCallExpr (

gcc/rust/typecheck/rust-tyty-call.h

@@ -67,6 +67,8 @@ class TypeCheckCallExpr : private TyVisitor
   void visit (ConstInferType &) override { rust_unreachable (); }
   void visit (ConstErrorType &) override { rust_unreachable (); }
 
+  void visit (ConstExprType &type) override;
+
   // tuple-structs
   void visit (ADTType &type) override;
 

gcc/rust/typecheck/rust-tyty-variance-analysis-private.h

@@ -165,6 +165,11 @@ template <typename VARIANCE> class VisitorBase final : public TyVisitor
 
   void visit (ErrorType &type) override {}
 
+  void visit (TyTy::ConstExprType &type) override
+  {
+    // TODO: Traverse expression for variance
+  }
+
   void visit (PlaceholderType &type) override { rust_unreachable (); }
   void visit (InferType &type) override { rust_unreachable (); }