GIMPLE coversions for ArrayIndexExpr and Arrays with values

This compiles the ArrayIndexExpressions and Arrays such as:
  let x = [1,2,3];
  let a = x[0];

Addresses: gcc-mirror#55

gcc/rust/analysis/rust-type-resolution.cc

@@ -466,7 +466,17 @@ void
 TypeResolution::visit (AST::ArrayExpr &expr)
 {
  auto elements = expr.get_internal_elements ();
+
+ auto before = typeBuffer.size ();
  elements->accept_vis (*this);
+ if (typeBuffer.size () <= before)
+ {
+ rust_error_at (expr.get_locus_slow (),
+ "unable to determine type for ArrayExpr");
+ return;
+ }
+
+ expr.set_inferred_type (typeBuffer.back ());
 }
 
 void

gcc/rust/ast/rust-expr.h

@@ -1000,6 +1000,10 @@ class ArrayExpr : public ExprWithoutBlock
 
  Location locus;
 
+ // this is a reference to what the inferred type is based on
+ // this init expression
+ Type *inferredType;
+
 public:
  std::string as_string () const override;
 
@@ -1050,6 +1054,9 @@ class ArrayExpr : public ExprWithoutBlock
 
  ArrayElems *get_internal_elements () { return internal_elements.get (); };
 
+ Type *get_inferred_type () { return inferredType; }
+ void set_inferred_type (Type *type) { inferredType = type; }
+
 protected:
  /* Use covariance to implement clone function as returning this object rather
  * than base */

gcc/rust/ast/rust-type.h

@@ -576,6 +576,10 @@ class ArrayType : public TypeNoBounds
 
  Type *get_element_type () { return elem_type.get (); }
 
+ Expr *get_size_expr () { return size.get (); }
+
+ Location &get_locus () { return locus; }
+
 protected:
  /* Use covariance to implement clone function as returning this object rather
  * than base */

gcc/rust/backend/rust-compile.cc

@@ -503,19 +503,102 @@ Compilation::visit (AST::CompoundAssignmentExpr &expr)
 void
 Compilation::visit (AST::GroupedExpr &expr)
 {}
-// void Compilation::visit(ArrayElems& elems) {}
+
 void
 Compilation::visit (AST::ArrayElemsValues &elems)
-{}
+{
+ std::vector< ::Bexpression *> elements;
+
+ bool failed = false;
+ elems.iterate ([&] (AST::Expr *expr) mutable -> bool {
+ Bexpression *value = nullptr;
+ VISIT_POP (expr.get_locus_slow (), expr, value, exprs);
+ if (value == nullptr)
+ {
+ rust_fatal_error (expr->get_locus_slow (),
+ "failed to compile value to array initialiser");
+ return false;
+ }
+ elements.push_back (value);
+ return true;
+ });
+
+ // nothing to do when its failed
+ if (failed)
+ return;
+
+ arrayConsStack.push_back (elements);
+}
+
 void
 Compilation::visit (AST::ArrayElemsCopied &elems)
 {}
+
 void
 Compilation::visit (AST::ArrayExpr &expr)
-{}
+{
+ translatedType = nullptr;
+ expr.get_inferred_type ()->accept_vis (*this);
+ if (translatedType == nullptr)
+ {
+ rust_error_at (expr.get_locus_slow (),
+ "failed to compile array type for ArrayExpr");
+ return;
+ }
+
+ ::Btype *compiledType = translatedType;
+ translatedType = nullptr;
+
+ auto before = arrayConsStack.size ();
+ expr.get_internal_elements ()->accept_vis (*this);
+ if (arrayConsStack.size () <= before)
+ {
+ rust_error_at (expr.get_locus_slow (),
+ "failed to compile the array constructor");
+ return;
+ }
+ std::vector< ::Bexpression *> initializer = arrayConsStack.back ();
+ arrayConsStack.pop_back ();
+
+ std::vector<unsigned long> indexes;
+ for (unsigned long i = 0; i < initializer.size (); ++i)
+ indexes.push_back (i);
+
+ Bexpression *cons
+ = backend->array_constructor_expression (compiledType, indexes, initializer,
+ expr.get_locus_slow ());
+ exprs.push_back (cons);
+}
+
 void
 Compilation::visit (AST::ArrayIndexExpr &expr)
-{}
+{
+ Bexpression *arrayExpr = nullptr;
+ VISIT_POP (expr.get_array_expr ()->get_locus_slow (), expr.get_array_expr (),
+ arrayExpr, exprs);
+ if (arrayExpr == nullptr)
+ {
+ rust_error_at (expr.get_locus_slow (),
+ "failed to compile value to array expression reference");
+ return;
+ }
+
+ Bexpression *indexExpr = nullptr;
+ VISIT_POP (expr.get_index_expr ()->get_locus_slow (), expr.get_index_expr (),
+ indexExpr, exprs);
+ if (indexExpr == nullptr)
+ {
+ rust_error_at (expr.get_locus_slow (),
+ "failed to compile value to array index expression");
+ return;
+ }
+
+ Bexpression *indexExpression
+ = backend->array_index_expression (arrayExpr, indexExpr,
+ expr.get_locus_slow ());
+ exprs.push_back (indexExpression);
+}
+
 void
 Compilation::visit (AST::TupleExpr &expr)
 {}
@@ -1376,9 +1459,34 @@ Compilation::visit (AST::RawPointerType &type)
 void
 Compilation::visit (AST::ReferenceType &type)
 {}
+
 void
 Compilation::visit (AST::ArrayType &type)
-{}
+{
+ Btype *elementType;
+ translatedType = nullptr;
+ type.get_element_type ()->accept_vis (*this);
+ if (translatedType == nullptr)
+ {
+ rust_error_at (type.get_locus (),
+ "Failed to compile element type for array");
+ return;
+ }
+ elementType = translatedType;
+
+ Bexpression *length = nullptr;
+ VISIT_POP (type.get_size_expr ()->get_locus_slow (), type.get_size_expr (),
+ length, exprs);
+ if (length == nullptr)
+ {
+ rust_error_at (type.get_size_expr ()->get_locus_slow (),
+ "failed to size for array type");
+ return;
+ }
+
+ translatedType = backend->array_type (elementType, length);
+}
+
 void
 Compilation::visit (AST::SliceType &type)
 {}

gcc/rust/backend/rust-compile.h

@@ -243,7 +243,8 @@ class Compilation : public AST::ASTVisitor
  std::vector< ::Bexpression *> exprs;
  std::vector< ::Bstatement *> stmts;
  std::vector< ::Bvariable *> varBuffer;
- std::vector<AST::StructStruct*> structBuffer;
+ std::vector<AST::StructStruct *> structBuffer;
+ std::vector<std::vector< ::Bexpression *> > arrayConsStack;
 
  // careful these are the vectors we pass into the GCC middle-end
  std::vector< ::Btype *> type_decls;

gcc/testsuite/rust.test/compilable/arrays1.rs

@@ -0,0 +1,7 @@
+fn main() {
+ let xs: [i32; 5] = [1, 2, 3, 4, 5];
+ let xy = [6, 7, 8];
+
+ let a = xs[0];
+ let b = xy[2];
+}