simplify array being a string literal

Author: folkertdev

c2rust-transpile/src/translator/literals.rs

@@ -173,20 +173,6 @@ impl<'c> Translation<'c> {
             CTypeKind::ConstantArray(ty, n) => {
                 // Convert all of the provided initializer values
 
-                // Need to check to see if the next item is a string literal,
-                // if it is need to treat it as a declaration, rather than
-                // an init list. https://github.com/GaloisInc/C2Rust/issues/40
-                let mut is_string = false;
-
-                if ids.len() == 1 {
-                    let v = ids.first().unwrap();
-                    if let CExprKind::Literal(_, CLiteral::String { .. }) =
-                        self.ast_context.index(*v).kind
-                    {
-                        is_string = true;
-                    }
-                }
-
                 let to_array_element = |id: &CExprId| -> TranslationResult<_> {
                     self.convert_expr(ctx.used(), *id)?.result_map(|x| {
                         // Array literals require all of their elements to be
@@ -208,38 +194,42 @@ impl<'c> Translation<'c> {
                     })
                 };
 
-                if is_string {
-                    let v = ids.first().unwrap();
-                    self.convert_expr(ctx.used(), *v)
-                } else {
-                    match ids {
-                        [] => {
-                            // this was likely a C array of the form `int x[16] = {}`,
-                            // we'll emit that as [0; 16].
-                            let len = mk().lit_expr(mk().int_unsuffixed_lit(n as u128));
-                            Ok(self
-                                .implicit_default_expr(ty, ctx.is_static)?
-                                .map(|default_value| mk().repeat_expr(default_value, len)))
-                        }
-                        [single] => {
+                match ids {
+                    [] => {
+                        // this was likely a C array of the form `int x[16] = {}`,
+                        // we'll emit that as [0; 16].
+                        let len = mk().lit_expr(mk().int_unsuffixed_lit(n as u128));
+                        Ok(self
+                            .implicit_default_expr(ty, ctx.is_static)?
+                            .map(|default_value| mk().repeat_expr(default_value, len)))
+                    }
+                    [single] => {
+                        // Need to check to see if the next item is a string literal,
+                        // if it is need to treat it as a declaration, rather than
+                        // an init list. https://github.com/GaloisInc/C2Rust/issues/40
+                        if let CExprKind::Literal(_, CLiteral::String { .. }) =
+                            self.ast_context.index(*single).kind
+                        {
+                            self.convert_expr(ctx.used(), *single)
+                        } else {
                             // this was likely a C array of the form `int x[16] = { default }`,
                             // we'll emit that as [default; 16].
                             let len = mk().lit_expr(mk().int_unsuffixed_lit(n as u128));
                             Ok(to_array_element(single)?
                                 .map(|default_value| mk().repeat_expr(default_value, len)))
                         }
-                        [..] => {
-                            Ok(ids
-                                .iter()
-                                .map(to_array_element)
-                                .chain(
-                                    // Pad out the array literal with default values to the desired size
-                                    iter::repeat(self.implicit_default_expr(ty, ctx.is_static))
-                                        .take(n - ids.len()),
-                                )
-                                .collect::<TranslationResult<WithStmts<_>>>()?
-                                .map(|vals| mk().array_expr(vals)))
-                        }
+                    }
+                    [..] => {
+                        Ok(ids
+                            .iter()
+                            .map(to_array_element)
+                            .chain(
+                                // Pad out the array literal with default values to the desired size
+                                iter::repeat(self.implicit_default_expr(ty, ctx.is_static))
+                                    .take(n - ids.len()),
+                            )
+                            .collect::<TranslationResult<WithStmts<_>>>()?
+                            .map(|vals| mk().array_expr(vals)))
                     }
                 }
             }