transpile: Split off new pointers.rs module (#1495)

Working with pointer-related stuff, I found that related code was kinda
scattered all over, making it difficult to find at times. This creates a
new pointers.rs module, moves some existing functions there, and creates
new functions to wrap some other bits of code. I've tried to not make
too many semantic changes.

In `convert_assignment_operator_with_rhs` there was a bit of dead code
that I removed. Since `AssignAdd` and `AssignSubtract` are handled by
the match arms, the `if` that checks for them below a second time wasn't
doing anything (and it did the same thing anyway).

Author: kkysen

c2rust-transpile/src/translator/mod.rs

@@ -49,6 +49,7 @@ mod literals;
 mod main_function;
 mod named_references;
 mod operators;
+mod pointers;
 mod simd;
 mod structs;
 mod variadic;
@@ -302,34 +303,6 @@ fn cast_int(val: Box<Expr>, name: &str, need_lit_suffix: bool) -> Box<Expr> {
     }
 }
 
-/// Pointer offset that casts its argument to isize
-fn pointer_offset(
-    ptr: Box<Expr>,
-    offset: Box<Expr>,
-    multiply_by: Option<Box<Expr>>,
-    neg: bool,
-    mut deref: bool,
-) -> Box<Expr> {
-    let mut offset = cast_int(offset, "isize", false);
-
-    if let Some(mul) = multiply_by {
-        let mul = cast_int(mul, "isize", false);
-        offset = mk().binary_expr(BinOp::Mul(Default::default()), offset, mul);
-        deref = false;
-    }
-
-    if neg {
-        offset = mk().unary_expr(UnOp::Neg(Default::default()), offset);
-    }
-
-    let res = mk().method_call_expr(ptr, "offset", vec![offset]);
-    if deref {
-        mk().unary_expr(UnOp::Deref(Default::default()), res)
-    } else {
-        res
-    }
-}
-
 /// Given an expression with type Option<fn(...)->...>, unwrap
 /// the Option and return the function.
 fn unwrap_function_pointer(ptr: Box<Expr>) -> Box<Expr> {
@@ -3082,54 +3055,6 @@ impl<'c> Translation<'c> {
             .convert(&self.ast_context, type_id)
     }
 
-    fn convert_pointee_type(&self, type_id: CTypeId) -> TranslationResult<Box<Type>> {
-        self.import_type(type_id);
-
-        self.type_converter
-            .borrow_mut()
-            .convert_pointee(&self.ast_context, type_id)
-    }
-
-    /// Construct an expression for a NULL at any type, including forward declarations,
-    /// function pointers, and normal pointers.
-    fn null_ptr(&self, type_id: CTypeId, is_static: bool) -> TranslationResult<Box<Expr>> {
-        if self.ast_context.is_function_pointer(type_id) {
-            return Ok(mk().path_expr(vec!["None"]));
-        }
-
-        let pointer_qty = self
-            .ast_context
-            .get_pointee_qual_type(type_id)
-            .ok_or_else(|| TranslationError::generic("null_ptr requires a pointer"))?;
-
-        let func = if pointer_qty.qualifiers.is_const
-            // static variable initializers aren't able to use null_mut
-            // TODO: Rust 1.83: Allowed, so this can be removed.
-            || is_static
-        {
-            "null"
-        } else {
-            "null_mut"
-        };
-        let pointee_ty = self.convert_pointee_type(pointer_qty.ctype)?;
-        let type_args = mk().angle_bracketed_args(vec![pointee_ty.clone()]);
-        let mut val = mk().call_expr(
-            mk().abs_path_expr(vec![
-                mk().path_segment("core"),
-                mk().path_segment("ptr"),
-                mk().path_segment_with_args(func, type_args),
-            ]),
-            vec![],
-        );
-
-        // TODO: Rust 1.83: Remove.
-        if is_static && !pointer_qty.qualifiers.is_const {
-            val = mk().cast_expr(val, mk().mutbl().ptr_ty(pointee_ty));
-        }
-
-        Ok(val)
-    }
-
     fn addr_lhs(
         &self,
         lhs: Box<Expr>,
@@ -3865,151 +3790,9 @@ impl<'c> Translation<'c> {
                 )
                 .map_err(|e| e.add_loc(self.ast_context.display_loc(src_loc))),
 
-            ArraySubscript(_, ref lhs, ref rhs, _) => {
-                let lhs_node = &self.ast_context.index(*lhs).kind;
-                let rhs_node = &self.ast_context.index(*rhs).kind;
-
-                let lhs_node_type = lhs_node
-                    .get_type()
-                    .ok_or_else(|| format_err!("lhs node bad type"))?;
-                let lhs_node_kind = &self.ast_context.resolve_type(lhs_node_type).kind;
-                let lhs_is_indexable = lhs_node_kind.is_pointer() || lhs_node_kind.is_vector();
-
-                // From here on in, the LHS is the pointer/array and the RHS the index
-                let (lhs, rhs, lhs_node) = if lhs_is_indexable {
-                    (lhs, rhs, lhs_node)
-                } else {
-                    (rhs, lhs, rhs_node)
-                };
-
-                let lhs_node_type = lhs_node
-                    .get_type()
-                    .ok_or_else(|| format_err!("lhs node bad type"))?;
-                if self
-                    .ast_context
-                    .resolve_type(lhs_node_type)
-                    .kind
-                    .is_vector()
-                {
-                    return Err(TranslationError::new(
-                        self.ast_context.display_loc(src_loc),
-                        err_msg("Attempting to index a vector type")
-                            .context(TranslationErrorKind::OldLLVMSimd),
-                    ));
-                }
-
-                let rhs = self.convert_expr(ctx.used(), *rhs, None)?;
-                rhs.and_then(|rhs| {
-                    let simple_index_array = if ctx.needs_address() {
-                        // We can't necessarily index into an array if we're using
-                        // that element to compute an address.
-                        None
-                    } else {
-                        match lhs_node {
-                            &CExprKind::ImplicitCast(
-                                _,
-                                arr,
-                                CastKind::ArrayToPointerDecay,
-                                _,
-                                _,
-                            ) => {
-                                match self.ast_context[arr].kind {
-                                    CExprKind::Member(_, _, field_decl, _, _)
-                                        if self
-                                            .potential_flexible_array_members
-                                            .borrow()
-                                            .contains(&field_decl) =>
-                                    {
-                                        None
-                                    }
-                                    ref kind => {
-                                        let arr_type = kind
-                                            .get_type()
-                                            .ok_or_else(|| format_err!("bad arr type"))?;
-                                        match self.ast_context.resolve_type(arr_type).kind {
-                                            // These get translated to 0-element arrays, this avoids the bounds check
-                                            // that using an array subscript in Rust would cause
-                                            CTypeKind::IncompleteArray(_) => None,
-                                            _ => Some(arr),
-                                        }
-                                    }
-                                }
-                            }
-                            _ => None,
-                        }
-                    };
-
-                    if let Some(arr) = simple_index_array {
-                        // If the LHS just underwent an implicit cast from array to pointer, bypass that
-                        // to make an actual Rust indexing operation
-
-                        let t = self.ast_context[arr]
-                            .kind
-                            .get_type()
-                            .ok_or_else(|| format_err!("bad arr type"))?;
-                        let var_elt_type_id = match self.ast_context.resolve_type(t).kind {
-                            CTypeKind::ConstantArray(..) => None,
-                            CTypeKind::IncompleteArray(..) => None,
-                            CTypeKind::VariableArray(elt, _) => Some(elt),
-                            ref other => panic!("Unexpected array type {:?}", other),
-                        };
-
-                        let lhs = self.convert_expr(ctx.used(), arr, None)?;
-                        lhs.and_then(|lhs| {
-                            // stmts.extend(lhs.stmts_mut());
-                            // is_unsafe = is_unsafe || lhs.is_unsafe();
-
-                            // Don't dereference the offset if we're still within the variable portion
-                            if let Some(elt_type_id) = var_elt_type_id {
-                                let mul = self.compute_size_of_expr(elt_type_id);
-                                Ok(WithStmts::new_unsafe_val(pointer_offset(
-                                    lhs, rhs, mul, false, true,
-                                )))
-                            } else {
-                                Ok(WithStmts::new_val(
-                                    mk().index_expr(lhs, cast_int(rhs, "usize", false)),
-                                ))
-                            }
-                        })
-                    } else {
-                        // LHS must be ref decayed for the offset method call's self param
-                        let mut lhs = self.convert_expr(ctx.used().decay_ref(), *lhs, None)?;
-                        lhs.set_unsafe(); // `pointer_offset` is unsafe.
-                        lhs.result_map(|lhs| {
-                            // stmts.extend(lhs.stmts_mut());
-                            // is_unsafe = is_unsafe || lhs.is_unsafe();
-
-                            let lhs_type_id = lhs_node
-                                .get_type()
-                                .ok_or_else(|| format_err!("bad lhs type"))?;
-
-                            // Determine the type of element being indexed
-                            let pointee_type_id =
-                                match self.ast_context.resolve_type(lhs_type_id).kind {
-                                    CTypeKind::Pointer(pointee_id) => pointee_id,
-                                    _ => {
-                                        return Err(format_err!(
-                                            "Subscript applied to non-pointer: {:?}",
-                                            lhs
-                                        )
-                                        .into());
-                                    }
-                                };
-
-                            let mul = self.compute_size_of_expr(pointee_type_id.ctype);
-                            let mut val = pointer_offset(lhs, rhs, mul, false, true);
-                            // if the context wants a different type, add a cast
-                            if let Some(expected_ty) = override_ty {
-                                if expected_ty != pointee_type_id {
-                                    val =
-                                        mk().cast_expr(val, self.convert_type(expected_ty.ctype)?);
-                                }
-                            }
-                            Ok(val)
-                        })
-                    }
-                })
-            }
+            ArraySubscript(_, lhs, rhs, _) => self
+                .convert_array_subscript(ctx, lhs, rhs, override_ty)
+                .map_err(|e| e.add_loc(self.ast_context.display_loc(src_loc))),
 
             Call(call_expr_ty, func, ref args) => {
                 let fn_ty =
@@ -4739,21 +4522,7 @@ impl<'c> Translation<'c> {
             }
 
             CastKind::ArrayToPointerDecay => {
-                // Because va_list is sometimes defined as a single-element
-                // array in order for it to allocate memory as a local variable
-                // and to be a pointer as a function argument we would get
-                // spurious casts when trying to treat it like a VaList which
-                // has reference semantics.
-                if self.ast_context.is_va_list(target_cty.ctype) {
-                    return Ok(val);
-                }
-
-                // Variable length arrays are already represented as pointers.
-                if let CTypeKind::VariableArray(..) = source_ty_kind {
-                    return Ok(val);
-                }
-
-                self.convert_address_of(ctx, expr, source_cty, target_cty, val, true)
+                self.convert_array_to_pointer_decay(ctx, source_cty, target_cty, val, expr)
             }
 
             CastKind::NullToPointer => {
@@ -4913,106 +4682,6 @@ impl<'c> Translation<'c> {
         val.map(|x| mk().cast_expr(x, target_ty))
     }
 
-    pub fn convert_address_of(
-        &self,
-        ctx: ExprContext,
-        arg: Option<CExprId>,
-        arg_cty: CQualTypeId,
-        pointer_cty: CQualTypeId,
-        mut val: WithStmts<Box<Expr>>,
-        is_array_decay: bool,
-    ) -> TranslationResult<WithStmts<Box<Expr>>> {
-        let arg_expr_kind = arg.map(|arg| {
-            let arg = self.ast_context.unwrap_predefined_ident(arg);
-            &self.ast_context.index(arg).kind
-        });
-        let pointee_cty = self
-            .ast_context
-            .get_pointee_qual_type(pointer_cty.ctype)
-            .ok_or_else(|| TranslationError::generic("Address-of should return a pointer"))?;
-        let arg_is_macro = arg.map_or(false, |arg| {
-            matches!(
-                self.convert_const_macro_expansion(ctx, arg, None),
-                Ok(Some(_))
-            )
-        });
-
-        let mut needs_cast = false;
-        let mut ref_cast_pointee_ty = None;
-        let mutbl = if pointee_cty.qualifiers.is_const {
-            Mutability::Immutable
-        } else if ctx.is_static {
-            // static variable initializers aren't able to use &mut, so we work around that
-            // by using & and an extra cast through & to *const to *mut
-            // TODO: Rust 1.83: Allowed, so this can be removed.
-            needs_cast = true;
-            Mutability::Immutable
-        } else {
-            Mutability::Mutable
-        };
-
-        // String literals are translated with a transmute, which produces a temporary.
-        // Taking the address of a temporary leaves a dangling pointer. So instead,
-        // cast the string literal directly so that its 'static lifetime is preserved.
-        if let (
-            Some(&CExprKind::Literal(literal_cty, CLiteral::String(ref bytes, element_size @ 1))),
-            false,
-        ) = (arg_expr_kind, arg_is_macro)
-        {
-            let bytes_padded = self.string_literal_bytes(literal_cty.ctype, bytes, element_size);
-            let len = bytes_padded.len();
-            val = WithStmts::new_val(mk().lit_expr(bytes_padded));
-
-            if is_array_decay {
-                ref_cast_pointee_ty = Some(mk().ident_ty("u8"));
-            } else {
-                ref_cast_pointee_ty =
-                    Some(mk().array_ty(mk().ident_ty("u8"), mk().lit_expr(len as u128)));
-            }
-            needs_cast = true;
-        } else {
-            let arg_cty_kind = &self.ast_context.resolve_type(arg_cty.ctype).kind;
-
-            if is_array_decay {
-                let method = match mutbl {
-                    Mutability::Mutable => "as_mut_ptr",
-                    Mutability::Immutable => "as_ptr",
-                };
-                val = val.map(|val| mk().method_call_expr(val, method, vec![]));
-
-                // If the target pointee type is different from the source element type,
-                // then we need to cast the ptr type as well.
-                if arg_cty_kind.element_ty().map_or(false, |arg_element_cty| {
-                    arg_element_cty != pointee_cty.ctype
-                }) {
-                    needs_cast = true;
-                }
-            } else {
-                val = val.map(|val| mk().set_mutbl(mutbl).addr_of_expr(val));
-
-                // Add an intermediate reference-to-pointer cast if the context needs
-                // reference-to-pointer decay, or if another cast follows.
-                if ctx.decay_ref.is_yes() || needs_cast {
-                    ref_cast_pointee_ty = Some(self.convert_pointee_type(arg_cty.ctype)?);
-                }
-            }
-        }
-
-        // Perform an intermediate reference-to-pointer cast if needed.
-        // TODO: Rust 1.76: Use `ptr::from_ref`.
-        if let Some(pointee_ty) = ref_cast_pointee_ty {
-            val = val.map(|val| mk().cast_expr(val, mk().set_mutbl(mutbl).ptr_ty(pointee_ty)));
-        }
-
-        // Perform a final cast to the target type if needed.
-        if needs_cast {
-            let pointer_ty = self.convert_type(pointer_cty.ctype)?;
-            val = val.map(|val| mk().cast_expr(val, pointer_ty));
-        }
-
-        Ok(val)
-    }
-
     pub fn implicit_default_expr(
         &self,
         ty_id: CTypeId,