Merge #288

288: Fix crash with zero length array r=philberty a=YizhePKU

This PR fixes the crash that results from zero-length arrays, such as `let arr = []`(issue #260). `ArrayExpr` now uses `ArrayElemsValues` to represent an empty array like that, instead of `nullptr`.

However, currently such code still doesn't compile. Four tests were added, two of which report an error:

```Rust
// compilable/array_empty_list.rs
fn main() {
    let arr = [];
}

// rust1: error: unable to determine type: please give this a type: 24
```

```Rust
// compilable/array_zero_length_fold.rs
fn main() {
    let arr = ["Hello"; 123 - 123];
}

// array_zero_length_fold.rs:2:25: fatal error: failed to fold capacity constant
```

I think these are best treated as separate bugs. We can merge first and fix later, or we can delay this PR. Either is OK.

Co-authored-by: Yizhe <[email protected]>
Co-authored-by: YizhePKU <[email protected]>
Co-authored-by: YizhePKU <[email protected]>

Author: bors[bot]

gcc/rust/ast/rust-ast-full-test.cc

@@ -2165,10 +2165,7 @@ ArrayExpr::as_string () const
   str += append_attributes (inner_attrs, INNER);
 
   str += "\n Array elems: ";
-  if (!has_array_elems ())
-    str += "none";
-  else
-    str += internal_elements->as_string ();
+  str += internal_elements->as_string ();
 
   return str;
 }

gcc/rust/ast/rust-expr.h

@@ -1099,26 +1099,25 @@ class ArrayExpr : public ExprWithoutBlock
     outer_attrs = std::move (new_attrs);
   }
 
-  // Returns whether array expr has array elems or if it is just empty.
-  bool has_array_elems () const { return internal_elements != nullptr; }
-
   // Constructor requires ArrayElems pointer
   ArrayExpr (std::unique_ptr<ArrayElems> array_elems,
 	     std::vector<Attribute> inner_attribs,
 	     std::vector<Attribute> outer_attribs, Location locus)
     : outer_attrs (std::move (outer_attribs)),
       inner_attrs (std::move (inner_attribs)),
       internal_elements (std::move (array_elems)), locus (locus)
-  {}
+  {
+    rust_assert (internal_elements != nullptr);
+  }
 
   // Copy constructor requires cloning ArrayElems for polymorphism to hold
   ArrayExpr (ArrayExpr const &other)
     : ExprWithoutBlock (other), outer_attrs (other.outer_attrs),
       inner_attrs (other.inner_attrs), locus (other.locus),
       marked_for_strip (other.marked_for_strip)
   {
-    if (other.has_array_elems ())
-      internal_elements = other.internal_elements->clone_array_elems ();
+    internal_elements = other.internal_elements->clone_array_elems ();
+    rust_assert (internal_elements != nullptr);
   }
 
   // Overload assignment operator to clone internal_elements
@@ -1130,11 +1129,9 @@ class ArrayExpr : public ExprWithoutBlock
     marked_for_strip = other.marked_for_strip;
     outer_attrs = other.outer_attrs;
 
-    if (other.has_array_elems ())
-      internal_elements = other.internal_elements->clone_array_elems ();
-    else
-      internal_elements = nullptr;
+    internal_elements = other.internal_elements->clone_array_elems ();
 
+    rust_assert (internal_elements != nullptr);
     return *this;
   }
 

gcc/rust/expand/rust-macro-expand.cc

@@ -727,8 +727,7 @@ class AttrVisitor : public AST::ASTVisitor
 
     /* assuming you can't strip away the ArrayElems type, but can strip
      * internal expressions and whatever */
-    if (expr.has_array_elems ())
-      expr.get_array_elems ()->accept_vis (*this);
+    expr.get_array_elems ()->accept_vis (*this);
   }
   void visit (AST::ArrayIndexExpr &expr) override
   {
@@ -3264,8 +3263,8 @@ MacroExpander::expand_invoc (std::unique_ptr<AST::MacroInvocation> &invoc)
     // how would errors be signalled? null fragment? something else?
     // what about error vs just not having stuff in rules definition yet?
 
-    /* replace macro invocation with ast frag. actually, don't have any context here. maybe attach ast 
-     * frag to macro invocation, and then have a method above get it? Or just return the ast frag from 
+    /* replace macro invocation with ast frag. actually, don't have any context here. maybe attach ast
+     * frag to macro invocation, and then have a method above get it? Or just return the ast frag from
      * this method. */
   }
 #endif