Rollup of 11 pull requests

compiler/rustc_ast/src/ast.rs

@@ -1378,15 +1378,6 @@ pub enum UnsafeSource {
     UserProvided,
 }
 
-/// Track whether under `feature(min_generic_const_args)` this anon const
-/// was explicitly disambiguated as an anon const or not through the use of
-/// `const { ... }` syntax.
-#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy, Walkable)]
-pub enum MgcaDisambiguation {
-    AnonConst,
-    Direct,
-}
-
 /// A constant (expression) that's not an item or associated item,
 /// but needs its own `DefId` for type-checking, const-eval, etc.
 /// These are usually found nested inside types (e.g., array lengths)
@@ -1396,7 +1387,6 @@ pub enum MgcaDisambiguation {
 pub struct AnonConst {
     pub id: NodeId,
     pub value: Box<Expr>,
-    pub mgca_disambiguation: MgcaDisambiguation,
 }
 
 /// An expression.
@@ -1627,6 +1617,7 @@ impl Expr {
             | ExprKind::UnsafeBinderCast(..)
             | ExprKind::While(..)
             | ExprKind::Yield(YieldKind::Postfix(..))
+            | ExprKind::DirectConstArg(..)
             | ExprKind::Err(_)
             | ExprKind::Dummy => prefix_attrs_precedence(&self.attrs),
         }
@@ -1920,6 +1911,9 @@ pub enum ExprKind {
 
     UnsafeBinderCast(UnsafeBinderCastKind, Box<Expr>, Option<Box<Ty>>),
 
+    /// An mGCA `direct_const_arg!()` expression.
+    DirectConstArg(Box<Expr>),
+
     /// Placeholder for an expression that wasn't syntactically well formed in some way.
     Err(ErrorGuaranteed),
 
@@ -2564,6 +2558,8 @@ pub enum TyKind {
     /// Usually not written directly in user code but indirectly via the macro
     /// `core::field::field_of!(...)`.
     FieldOf(Box<Ty>, Option<Ident>, Ident),
+    /// An mGCA `direct_const_arg!()` expression.
+    DirectConstArg(Box<Expr>),
     /// Sometimes we need a dummy value when no error has occurred.
     Dummy,
     /// Placeholder for a kind that has failed to be defined.

compiler/rustc_ast/src/expand/typetree.rs

@@ -28,6 +28,9 @@ pub enum Kind {
     Anything,
     Integer,
     Pointer,
+    // We prefer to directly lower to things that our Enzyme backend supports.
+    // However, it's sometimes convenient to pass ptr+int as one type.
+    RustSlice,
     Half,
     Float,
     Double,
@@ -57,6 +60,9 @@ impl TypeTree {
         }
         Self(ints)
     }
+    pub fn add_indirection(self) -> Self {
+        Self(vec![Type { offset: 0, size: 1, kind: Kind::Pointer, child: self }])
+    }
 }
 
 #[derive(Clone, Eq, PartialEq, Encodable, Decodable, Debug, StableHash)]
@@ -72,6 +78,11 @@ pub struct Type {
     pub kind: Kind,
     pub child: TypeTree,
 }
+impl Type {
+    pub fn from_ty(offset: isize, other: &Type) -> Self {
+        Self { offset, size: other.size, kind: other.kind, child: other.child.clone() }
+    }
+}
 
 impl Type {
     pub fn add_offset(self, add: isize) -> Self {

compiler/rustc_ast/src/util/classify.rs

@@ -155,6 +155,7 @@ pub fn leading_labeled_expr(mut expr: &ast::Expr) -> bool {
             | Yeet(..)
             | Yield(..)
             | UnsafeBinderCast(..)
+            | DirectConstArg(..)
             | Err(..)
             | Dummy => return false,
         }
@@ -240,6 +241,7 @@ pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
             | Try(_)
             | Yeet(None)
             | UnsafeBinderCast(..)
+            | DirectConstArg(..)
             | Err(_)
             | Dummy => {
                 break None;
@@ -301,6 +303,7 @@ fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
             | ast::TyKind::CVarArgs
             | ast::TyKind::Pat(..)
             | ast::TyKind::FieldOf(..)
+            | ast::TyKind::DirectConstArg(..)
             | ast::TyKind::Dummy
             | ast::TyKind::Err(..) => break None,
         }

compiler/rustc_ast/src/visit.rs

@@ -418,7 +418,6 @@ macro_rules! common_visitor_and_walkers {
             UnsafeBinderCastKind,
             BinOpKind,
             BlockCheckMode,
-            MgcaDisambiguation,
             BorrowKind,
             BoundAsyncness,
             BoundConstness,
@@ -1074,6 +1073,8 @@ macro_rules! common_visitor_and_walkers {
                     visit_visitable!($($mut)? vis, bytes),
                 ExprKind::UnsafeBinderCast(kind, expr, ty) =>
                     visit_visitable!($($mut)? vis, kind, expr, ty),
+                ExprKind::DirectConstArg(expr) =>
+                    visit_visitable!($($mut)? vis, expr),
                 ExprKind::Err(_guar) => {}
                 ExprKind::Dummy => {}
             }

compiler/rustc_ast_lowering/src/delegation/generics.rs

@@ -7,7 +7,7 @@ use rustc_hir::def_id::DefId;
 use rustc_middle::ty::{GenericParamDefKind, TyCtxt};
 use rustc_middle::{bug, ty};
 use rustc_span::symbol::kw;
-use rustc_span::{Ident, Span, sym};
+use rustc_span::{ErrorGuaranteed, Ident, Span, sym};
 
 use crate::LoweringContext;
 use crate::delegation::resolution::resolver::DelegationResolver;
@@ -281,7 +281,7 @@ impl<'hir> DelegationResolver<'_, 'hir> {
         &self,
         delegation: &'a Delegation,
         sig_id: DefId,
-    ) -> GenericsResolution<'a, 'hir> {
+    ) -> Result<GenericsResolution<'a, 'hir>, ErrorGuaranteed> {
         let tcx = self.tcx();
         let delegation_parent_kind = tcx.def_kind(tcx.local_parent(self.owner_id()));
 
@@ -300,9 +300,8 @@ impl<'hir> DelegationResolver<'_, 'hir> {
         let qself_is_none = delegation.qself.is_none();
 
         let parent_args = if let [.., parent_segment, _] = &delegation.path.segments[..] {
-            if let Some(res) = self.get_resolution_id(parent_segment.id)
-                && matches!(tcx.def_kind(res), DefKind::Trait | DefKind::TraitAlias)
-            {
+            let res = self.get_resolution_id(parent_segment.id)?;
+            if matches!(tcx.def_kind(res), DefKind::Trait | DefKind::TraitAlias) {
                 sig_parent_params = &tcx.generics_of(sig_parent).own_params;
                 self.get_user_args(parent_segment)
                     .map(|args| ParentSegmentArgs::Specified(args))
@@ -314,7 +313,7 @@ impl<'hir> DelegationResolver<'_, 'hir> {
             ParentSegmentArgs::Invalid
         };
 
-        GenericsResolution {
+        Ok(GenericsResolution {
             parent_args,
             sig_parent_params,
             qself_is_none,
@@ -326,7 +325,7 @@ impl<'hir> DelegationResolver<'_, 'hir> {
             child_args: self.get_user_args(
                 delegation.path.segments.last().expect("must be at least one segment"),
             ),
-        }
+        })
     }
 
     fn get_user_args<'a>(&self, segment: &'a PathSegment) -> Option<&'a AngleBracketedArgs> {
@@ -350,14 +349,14 @@ impl<'hir> DelegationResolver<'_, 'hir> {
         &self,
         delegation: &Delegation,
         sig_id: DefId,
-    ) -> GenericsGenerationResults<'hir> {
+    ) -> Result<GenericsGenerationResults<'hir>, ErrorGuaranteed> {
         let res @ GenericsResolution {
             trait_impl,
             generate_self,
             sig_child_params,
             sig_parent_params,
             ..
-        } = self.resolve_generics(delegation, sig_id);
+        } = self.resolve_generics(delegation, sig_id)?;
 
         // If we are in trait impl always generate function whose generics matches
         // those that are defined in trait.
@@ -374,7 +373,7 @@ impl<'hir> DelegationResolver<'_, 'hir> {
 
             let child = GenericsGenerationResult::new(child);
 
-            return GenericsGenerationResults { parent, child, self_ty_propagation_kind: None };
+            return Ok(GenericsGenerationResults { parent, child, self_ty_propagation_kind: None });
         }
 
         let tcx = self.tcx();
@@ -421,7 +420,7 @@ impl<'hir> DelegationResolver<'_, 'hir> {
             DelegationGenerics::generate_all(sig_child_params, GenericsPosition::Child, trait_impl)
         };
 
-        GenericsGenerationResults {
+        Ok(GenericsGenerationResults {
             parent: GenericsGenerationResult::new(parent_generics),
             child: GenericsGenerationResult::new(child_generics),
             self_ty_propagation_kind: match res.free_to_trait_delegation {
@@ -435,7 +434,7 @@ impl<'hir> DelegationResolver<'_, 'hir> {
                 }),
                 false => None,
             },
-        }
+        })
     }
 
     /// Generates generic argument slots for user-specified `args` and