Merge #775

775: Support const within block-expr's r=philberty a=philberty

This adds support for constant folding within block expr's and constant
ArrayIndexExpression.

Fixes #711 

Co-authored-by: Philip Herron <[email protected]>

Author: bors[bot]

gcc/rust/backend/rust-compile-stmt.h

@@ -48,6 +48,33 @@ class CompileStmt : public HIRCompileBase
     translated = CompileExpr::Compile (stmt.get_expr (), ctx);
   }
 
+  void visit (HIR::ConstantItem &constant) override
+  {
+    TyTy::BaseType *resolved_type = nullptr;
+    bool ok
+      = ctx->get_tyctx ()->lookup_type (constant.get_mappings ().get_hirid (),
+					&resolved_type);
+    rust_assert (ok);
+
+    ::Btype *type = TyTyResolveCompile::compile (ctx, resolved_type);
+    Bexpression *value = CompileExpr::Compile (constant.get_expr (), ctx);
+
+    const Resolver::CanonicalPath *canonical_path = nullptr;
+    rust_assert (ctx->get_mappings ()->lookup_canonical_path (
+      constant.get_mappings ().get_crate_num (),
+      constant.get_mappings ().get_nodeid (), &canonical_path));
+
+    std::string ident = canonical_path->get ();
+    Bexpression *const_expr
+      = ctx->get_backend ()->named_constant_expression (type, ident, value,
+							constant.get_locus ());
+
+    ctx->push_const (const_expr);
+    ctx->insert_const_decl (constant.get_mappings ().get_hirid (), const_expr);
+
+    translated = const_expr;
+  }
+
   void visit (HIR::LetStmt &stmt) override
   {
     // nothing to do

gcc/rust/hir/rust-ast-lower-stmt.h

@@ -83,6 +83,34 @@ class ASTLoweringStmt : public ASTLoweringBase
     mappings->insert_hir_stmt (crate_num, mapping.get_hirid (), translated);
   }
 
+  void visit (AST::ConstantItem &constant) override
+  {
+    HIR::Visibility vis = HIR::Visibility::create_public ();
+
+    HIR::Type *type = ASTLoweringType::translate (constant.get_type ().get ());
+    HIR::Expr *expr = ASTLoweringExpr::translate (constant.get_expr ().get ());
+
+    auto crate_num = mappings->get_current_crate ();
+    Analysis::NodeMapping mapping (crate_num, constant.get_node_id (),
+				   mappings->get_next_hir_id (crate_num),
+				   mappings->get_next_localdef_id (crate_num));
+
+    HIR::ConstantItem *constant_item
+      = new HIR::ConstantItem (mapping, constant.get_identifier (), vis,
+			       std::unique_ptr<HIR::Type> (type),
+			       std::unique_ptr<HIR::Expr> (expr),
+			       constant.get_outer_attrs (),
+			       constant.get_locus ());
+    translated = constant_item;
+
+    mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (),
+			       constant_item);
+    mappings->insert_hir_stmt (mapping.get_crate_num (), mapping.get_hirid (),
+			       constant_item);
+    mappings->insert_location (crate_num, mapping.get_hirid (),
+			       constant.get_locus ());
+  }
+
   void visit (AST::LetStmt &stmt) override
   {
     HIR::Pattern *variables

gcc/rust/resolve/rust-ast-resolve-stmt.h

@@ -51,6 +51,30 @@ class ResolveStmt : public ResolverBase
     ResolveExpr::go (stmt.get_expr ().get (), stmt.get_node_id ());
   }
 
+  void visit (AST::ConstantItem &constant) override
+  {
+    auto path = ResolveConstantItemToCanonicalPath::resolve (constant);
+    resolver->get_name_scope ().insert (
+      path, constant.get_node_id (), constant.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	RichLocation r (constant.get_locus ());
+	r.add_range (locus);
+	rust_error_at (r, "redefined multiple times");
+      });
+    resolver->insert_new_definition (constant.get_node_id (),
+				     Definition{constant.get_node_id (),
+						constant.get_node_id ()});
+
+    ResolveType::go (constant.get_type ().get (), constant.get_node_id ());
+    ResolveExpr::go (constant.get_expr ().get (), constant.get_node_id ());
+
+    // the mutability checker needs to verify for immutable decls the number
+    // of assignments are <1. This marks an implicit assignment
+    resolver->mark_decl_mutability (constant.get_node_id (), false);
+    resolver->mark_assignment_to_decl (constant.get_node_id (),
+				       constant.get_node_id ());
+  }
+
   void visit (AST::LetStmt &stmt) override
   {
     if (stmt.has_init_expr ())

gcc/rust/typecheck/rust-hir-const-fold.h

@@ -427,6 +427,15 @@ class ConstFoldExpr : public ConstFoldBase
       = ctx->get_backend ()->negation_expression (op, negated_expr, location);
   }
 
+  void visit (HIR::ArrayIndexExpr &expr) override
+  {
+    Bexpression *array = ConstFoldExpr::fold (expr.get_array_expr ());
+    Bexpression *index = ConstFoldExpr::fold (expr.get_index_expr ());
+
+    folded = ctx->get_backend ()->array_index_expression (array, index,
+							  expr.get_locus ());
+  }
+
 private:
   ConstFoldExpr ()
     : ConstFoldBase (), folded (ctx->get_backend ()->error_expression ())

gcc/rust/typecheck/rust-hir-type-check-stmt.h

@@ -55,6 +55,19 @@ class TypeCheckStmt : public TypeCheckBase
       = TyTy::TupleType::get_unit_type (stmt.get_mappings ().get_hirid ());
   }
 
+  void visit (HIR::ConstantItem &constant) override
+  {
+    TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ());
+    TyTy::BaseType *expr_type
+      = TypeCheckExpr::Resolve (constant.get_expr (), false);
+
+    infered = type->unify (expr_type);
+    context->insert_type (constant.get_mappings (), infered);
+
+    // notify the constant folder of this
+    ConstFold::ConstFoldItem::fold (constant);
+  }
+
   void visit (HIR::LetStmt &stmt) override
   {
     infered = new TyTy::TupleType (stmt.get_mappings ().get_hirid ());

gcc/testsuite/rust/compile/torture/constant2.rs

@@ -0,0 +1,6 @@
+fn main() {
+    const C: usize = 42;
+
+    let _a = C;
+    let _b: [i32; C] = [0; C];
+}

gcc/testsuite/rust/compile/torture/constant3.rs

@@ -0,0 +1,10 @@
+fn main() {
+    const A: [i32; 3] = [1, 2, 3];
+    const B: i32 = A[1];
+    const C: usize = 42;
+    const D: i32 = 7;
+
+    let _a = C;
+    let _b: [i32; C] = [0; C];
+    let _c = B + D;
+}