19 files changed, 733 insertions, 41 deletions

diff --git a/gcc/rust/ast/rust-expr.h b/gcc/rust/ast/rust-expr.h
index de011c1..8e60557 100644
--- a/gcc/rust/ast/rust-expr.h
+++ b/gcc/rust/ast/rust-expr.h
@@ -550,6 +550,8 @@ public:
     return right_expr;
   }
 
+  ExprType get_kind () { return expr_type; }
+
   /* TODO: implement via a function call to std::cmp::PartialEq::eq(&op1, &op2)
    * maybe? */
 protected:
@@ -628,6 +630,8 @@ public:
     return right_expr;
   }
 
+  ExprType get_kind () { return expr_type; }
+
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */
diff --git a/gcc/rust/backend/rust-compile-block.h b/gcc/rust/backend/rust-compile-block.h
new file mode 100644
index 0000000..b17fb05
--- /dev/null
+++ b/gcc/rust/backend/rust-compile-block.h
@@ -0,0 +1,112 @@
+// Copyright (C) 2020 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#ifndef RUST_COMPILE_BLOCK
+#define RUST_COMPILE_BLOCK
+
+#include "rust-compile-base.h"
+#include "rust-compile-tyty.h"
+
+namespace Rust {
+namespace Compile {
+
+class CompileBlock : public HIRCompileBase
+{
+public:
+  static Bblock *compile (HIR::BlockExpr *expr, Context *ctx)
+  {
+    CompileBlock compiler (ctx);
+    expr->accept_vis (compiler);
+    return compiler.translated;
+  }
+
+  ~CompileBlock () {}
+
+  void visit (HIR::BlockExpr &expr);
+
+private:
+  CompileBlock (Context *ctx) : HIRCompileBase (ctx), translated (nullptr) {}
+
+  Bblock *translated;
+};
+
+class CompileConditionalBlocks : public HIRCompileBase
+{
+public:
+  static Bstatement *compile (HIR::IfExpr *expr, Context *ctx)
+  {
+    CompileConditionalBlocks resolver (ctx);
+    expr->accept_vis (resolver);
+    return resolver.translated;
+  }
+
+  ~CompileConditionalBlocks () {}
+
+  void visit (HIR::IfExpr &expr);
+
+  void visit (HIR::IfExprConseqElse &expr);
+
+  void visit (HIR::IfExprConseqIf &expr);
+
+private:
+  CompileConditionalBlocks (Context *ctx)
+    : HIRCompileBase (ctx), translated (nullptr)
+  {}
+
+  Bstatement *translated;
+};
+
+class CompileExprWithBlock : public HIRCompileBase
+{
+public:
+  static Bstatement *compile (HIR::ExprWithBlock *expr, Context *ctx)
+  {
+    CompileExprWithBlock resolver (ctx);
+    expr->accept_vis (resolver);
+    return resolver.translated;
+  }
+
+  ~CompileExprWithBlock () {}
+
+  void visit (HIR::IfExpr &expr)
+  {
+    translated = CompileConditionalBlocks::compile (&expr, ctx);
+  }
+
+  void visit (HIR::IfExprConseqElse &expr)
+  {
+    translated = CompileConditionalBlocks::compile (&expr, ctx);
+  }
+
+  void visit (HIR::IfExprConseqIf &expr)
+  {
+    translated = CompileConditionalBlocks::compile (&expr, ctx);
+  }
+
+private:
+  CompileExprWithBlock (Context *ctx)
+    : HIRCompileBase (ctx), translated (nullptr)
+  {}
+
+  Bstatement *translated;
+};
+
+} // namespace Compile
+} // namespace Rust
+
+#endif // RUST_COMPILE_BLOCK
diff --git a/gcc/rust/backend/rust-compile-expr.h b/gcc/rust/backend/rust-compile-expr.h
index 7808af2..854fe5e 100644
--- a/gcc/rust/backend/rust-compile-expr.h
+++ b/gcc/rust/backend/rust-compile-expr.h
@@ -22,6 +22,7 @@
 #include "rust-compile-base.h"
 #include "rust-compile-tyty.h"
 #include "rust-compile-resolve-path.h"
+#include "rust-compile-block.h"
 
 namespace Rust {
 namespace Compile {
@@ -273,6 +274,31 @@ public:
 							 expr.get_locus ());
   }
 
+  void visit (HIR::IfExpr &expr)
+  {
+    auto stmt = CompileConditionalBlocks::compile (&expr, ctx);
+    ctx->add_statement (stmt);
+  }
+
+  void visit (HIR::IfExprConseqElse &expr)
+  {
+    auto stmt = CompileConditionalBlocks::compile (&expr, ctx);
+    ctx->add_statement (stmt);
+  }
+
+  void visit (HIR::IfExprConseqIf &expr)
+  {
+    auto stmt = CompileConditionalBlocks::compile (&expr, ctx);
+    ctx->add_statement (stmt);
+  }
+
+  void visit (HIR::BlockExpr &expr)
+  {
+    auto code_block = CompileBlock::compile (&expr, ctx);
+    auto block_stmt = ctx->get_backend ()->block_statement (code_block);
+    ctx->add_statement (block_stmt);
+  }
+
 private:
   CompileExpr (Context *ctx) : HIRCompileBase (ctx), translated (nullptr) {}
 
diff --git a/gcc/rust/backend/rust-compile-stmt.h b/gcc/rust/backend/rust-compile-stmt.h
index 0a08130..5f7decb 100644
--- a/gcc/rust/backend/rust-compile-stmt.h
+++ b/gcc/rust/backend/rust-compile-stmt.h
@@ -38,6 +38,18 @@ public:
 
   virtual ~CompileStmt () {}
 
+  void visit (HIR::ExprStmtWithBlock &stmt)
+  {
+    ok = true;
+    auto translated = CompileExpr::Compile (stmt.get_expr (), ctx);
+
+    // these can be null
+    if (translated == nullptr)
+      return;
+
+    gcc_unreachable ();
+  }
+
   void visit (HIR::ExprStmtWithoutBlock &stmt)
   {
     ok = true;
diff --git a/gcc/rust/backend/rust-compile.cc b/gcc/rust/backend/rust-compile.cc
index 11c380b..02fa3a0 100644
--- a/gcc/rust/backend/rust-compile.cc
+++ b/gcc/rust/backend/rust-compile.cc
@@ -18,6 +18,7 @@
 
 #include "rust-compile.h"
 #include "rust-compile-item.h"
+#include "rust-compile-expr.h"
 
 namespace Rust {
 namespace Compile {
@@ -43,5 +44,113 @@ CompileCrate::go ()
     CompileItem::compile (it->get (), ctx);
 }
 
+// rust-compile-block.h
+
+void
+CompileBlock::visit (HIR::BlockExpr &expr)
+{
+  fncontext fnctx = ctx->peek_fn ();
+  Bfunction *fndecl = fnctx.fndecl;
+  Location start_location = expr.get_locus ();
+  Location end_location = expr.get_closing_locus ();
+  auto body_mappings = expr.get_mappings ();
+
+  Resolver::Rib *rib = nullptr;
+  if (!ctx->get_resolver ()->find_name_rib (body_mappings.get_nodeid (), &rib))
+    {
+      rust_fatal_error (expr.get_locus (), "failed to setup locals per block");
+      return;
+    }
+
+  std::vector<Bvariable *> locals;
+  rib->iterate_decls ([&] (NodeId n) mutable -> bool {
+    Resolver::Definition d;
+    bool ok = ctx->get_resolver ()->lookup_definition (n, &d);
+    rust_assert (ok);
+
+    HIR::Stmt *decl = nullptr;
+    ok = ctx->get_mappings ()->resolve_nodeid_to_stmt (d.parent, &decl);
+    rust_assert (ok);
+
+    Bvariable *compiled = CompileVarDecl::compile (fndecl, decl, ctx);
+    locals.push_back (compiled);
+
+    return true;
+  });
+
+  Bblock *enclosing_scope = ctx->peek_enclosing_scope ();
+  Bblock *new_block
+    = ctx->get_backend ()->block (fndecl, enclosing_scope, locals,
+				  start_location, end_location);
+  ctx->push_block (new_block);
+
+  expr.iterate_stmts ([&] (HIR::Stmt *s) mutable -> bool {
+    CompileStmt::Compile (s, ctx);
+    return true;
+  });
+
+  ctx->pop_block ();
+  translated = new_block;
+}
+
+void
+CompileConditionalBlocks::visit (HIR::IfExpr &expr)
+{
+  fncontext fnctx = ctx->peek_fn ();
+  Bfunction *fndecl = fnctx.fndecl;
+  Bexpression *condition_expr
+    = CompileExpr::Compile (expr.get_if_condition (), ctx);
+  Bblock *then_block = CompileBlock::compile (expr.get_if_block (), ctx);
+
+  translated
+    = ctx->get_backend ()->if_statement (fndecl, condition_expr, then_block,
+					 NULL, expr.get_locus ());
+}
+
+void
+CompileConditionalBlocks::visit (HIR::IfExprConseqElse &expr)
+{
+  fncontext fnctx = ctx->peek_fn ();
+  Bfunction *fndecl = fnctx.fndecl;
+  Bexpression *condition_expr
+    = CompileExpr::Compile (expr.get_if_condition (), ctx);
+  Bblock *then_block = CompileBlock::compile (expr.get_if_block (), ctx);
+  Bblock *else_block = CompileBlock::compile (expr.get_else_block (), ctx);
+
+  translated
+    = ctx->get_backend ()->if_statement (fndecl, condition_expr, then_block,
+					 else_block, expr.get_locus ());
+}
+
+void
+CompileConditionalBlocks::visit (HIR::IfExprConseqIf &expr)
+{
+  fncontext fnctx = ctx->peek_fn ();
+  Bfunction *fndecl = fnctx.fndecl;
+  Bexpression *condition_expr
+    = CompileExpr::Compile (expr.get_if_condition (), ctx);
+  Bblock *then_block = CompileBlock::compile (expr.get_if_block (), ctx);
+
+  // else block
+  std::vector<Bvariable *> locals;
+  Location start_location = expr.get_conseq_if_expr ()->get_locus ();
+  Location end_location = expr.get_conseq_if_expr ()->get_locus (); // FIXME
+  Bblock *enclosing_scope = ctx->peek_enclosing_scope ();
+  Bblock *else_block
+    = ctx->get_backend ()->block (fndecl, enclosing_scope, locals,
+				  start_location, end_location);
+  ctx->push_block (else_block);
+
+  Bstatement *else_stmt_decl
+    = CompileConditionalBlocks::compile (expr.get_conseq_if_expr (), ctx);
+  ctx->add_statement (else_stmt_decl);
+
+  ctx->pop_block ();
+
+  translated
+    = ctx->get_backend ()->if_statement (fndecl, condition_expr, then_block,
+					 else_block, expr.get_locus ());
+}
+
 } // namespace Compile
 } // namespace Rust
diff --git a/gcc/rust/hir/rust-ast-lower-block.h b/gcc/rust/hir/rust-ast-lower-block.h
new file mode 100644
index 0000000..11f1ab8
--- /dev/null
+++ b/gcc/rust/hir/rust-ast-lower-block.h
@@ -0,0 +1,132 @@
+// Copyright (C) 2020 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#ifndef RUST_AST_LOWER_BLOCK
+#define RUST_AST_LOWER_BLOCK
+
+#include "rust-diagnostics.h"
+#include "rust-ast-lower-base.h"
+
+namespace Rust {
+namespace HIR {
+
+class ASTLoweringBlock : public ASTLoweringBase
+{
+public:
+  static HIR::BlockExpr *translate (AST::BlockExpr *expr)
+  {
+    ASTLoweringBlock resolver;
+    expr->accept_vis (resolver);
+    if (resolver.translated != nullptr)
+      {
+	resolver.mappings->insert_hir_expr (
+	  resolver.translated->get_mappings ().get_crate_num (),
+	  resolver.translated->get_mappings ().get_hirid (),
+	  resolver.translated);
+      }
+
+    return resolver.translated;
+  }
+
+  ~ASTLoweringBlock () {}
+
+  void visit (AST::BlockExpr &expr);
+
+private:
+  ASTLoweringBlock () : ASTLoweringBase (), translated (nullptr) {}
+
+  HIR::BlockExpr *translated;
+};
+
+class ASTLoweringIfBlock : public ASTLoweringBase
+{
+public:
+  static HIR::IfExpr *translate (AST::IfExpr *expr)
+  {
+    ASTLoweringIfBlock resolver;
+    expr->accept_vis (resolver);
+    if (resolver.translated != nullptr)
+      {
+	resolver.mappings->insert_hir_expr (
+	  resolver.translated->get_mappings ().get_crate_num (),
+	  resolver.translated->get_mappings ().get_hirid (),
+	  resolver.translated);
+      }
+
+    return resolver.translated;
+  }
+
+  ~ASTLoweringIfBlock () {}
+
+  void visit (AST::IfExpr &expr);
+
+  void visit (AST::IfExprConseqElse &expr);
+
+  void visit (AST::IfExprConseqIf &expr);
+
+private:
+  ASTLoweringIfBlock () : ASTLoweringBase (), translated (nullptr) {}
+
+  HIR::IfExpr *translated;
+};
+
+class ASTLoweringExprWithBlock : public ASTLoweringBase
+{
+public:
+  static HIR::ExprWithBlock *translate (AST::ExprWithBlock *expr)
+  {
+    ASTLoweringExprWithBlock resolver;
+    expr->accept_vis (resolver);
+    if (resolver.translated != nullptr)
+      {
+	resolver.mappings->insert_hir_expr (
+	  resolver.translated->get_mappings ().get_crate_num (),
+	  resolver.translated->get_mappings ().get_hirid (),
+	  resolver.translated);
+      }
+
+    return resolver.translated;
+  }
+
+  ~ASTLoweringExprWithBlock () {}
+
+  void visit (AST::IfExpr &expr)
+  {
+    translated = ASTLoweringIfBlock::translate (&expr);
+  }
+
+  void visit (AST::IfExprConseqElse &expr)
+  {
+    translated = ASTLoweringIfBlock::translate (&expr);
+  }
+
+  void visit (AST::IfExprConseqIf &expr)
+  {
+    translated = ASTLoweringIfBlock::translate (&expr);
+  }
+
+private:
+  ASTLoweringExprWithBlock () : ASTLoweringBase (), translated (nullptr) {}
+
+  HIR::ExprWithBlock *translated;
+};
+
+} // namespace HIR
+} // namespace Rust
+
+#endif // RUST_AST_LOWER_BLOCK
diff --git a/gcc/rust/hir/rust-ast-lower-expr.h b/gcc/rust/hir/rust-ast-lower-expr.h
index 50e67a8..19d599a 100644
--- a/gcc/rust/hir/rust-ast-lower-expr.h
+++ b/gcc/rust/hir/rust-ast-lower-expr.h
@@ -20,8 +20,8 @@
 #define RUST_AST_LOWER_EXPR
 
 #include "rust-diagnostics.h"
-
 #include "rust-ast-lower-base.h"
+#include "rust-ast-lower-block.h"
 
 namespace Rust {
 namespace HIR {
@@ -33,19 +33,42 @@ public:
   {
     ASTLoweringExpr resolver;
     expr->accept_vis (resolver);
-    if (resolver.translated != nullptr)
+    if (resolver.translated == nullptr)
       {
-	resolver.mappings->insert_hir_expr (
-	  resolver.translated->get_mappings ().get_crate_num (),
-	  resolver.translated->get_mappings ().get_hirid (),
-	  resolver.translated);
+	rust_fatal_error (expr->get_locus_slow (), "Failed to lower expr: [%s]",
+			  expr->as_string ().c_str ());
+	return nullptr;
       }
 
+    resolver.mappings->insert_hir_expr (
+      resolver.translated->get_mappings ().get_crate_num (),
+      resolver.translated->get_mappings ().get_hirid (), resolver.translated);
+
     return resolver.translated;
   }
 
   virtual ~ASTLoweringExpr () {}
 
+  void visit (AST::IfExpr &expr)
+  {
+    translated = ASTLoweringIfBlock::translate (&expr);
+  }
+
+  void visit (AST::IfExprConseqElse &expr)
+  {
+    translated = ASTLoweringIfBlock::translate (&expr);
+  }
+
+  void visit (AST::IfExprConseqIf &expr)
+  {
+    translated = ASTLoweringIfBlock::translate (&expr);
+  }
+
+  void visit (AST::BlockExpr &expr)
+  {
+    translated = ASTLoweringBlock::translate (&expr);
+  }
+
   void visit (AST::PathInExpression &expr)
   {
     std::vector<HIR::PathExprSegment> path_segments;
@@ -230,6 +253,76 @@ public:
 					  kind, expr.get_locus ());
   }
 
+  void visit (AST::ComparisonExpr &expr)
+  {
+    HIR::ComparisonExpr::ExprType kind;
+    switch (expr.get_kind ())
+      {
+      case AST::ComparisonExpr::ExprType::EQUAL:
+	kind = HIR::ComparisonExpr::ExprType::EQUAL;
+	break;
+      case AST::ComparisonExpr::ExprType::NOT_EQUAL:
+	kind = HIR::ComparisonExpr::ExprType::NOT_EQUAL;
+	break;
+      case AST::ComparisonExpr::ExprType::GREATER_THAN:
+	kind = HIR::ComparisonExpr::ExprType::GREATER_THAN;
+	break;
+      case AST::ComparisonExpr::ExprType::LESS_THAN:
+	kind = HIR::ComparisonExpr::ExprType::LESS_THAN;
+	break;
+      case AST::ComparisonExpr::ExprType::GREATER_OR_EQUAL:
+	kind = HIR::ComparisonExpr::ExprType::GREATER_OR_EQUAL;
+	break;
+      case AST::ComparisonExpr::ExprType::LESS_OR_EQUAL:
+	kind = HIR::ComparisonExpr::ExprType::LESS_OR_EQUAL;
+	break;
+      }
+
+    HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ().get ());
+    rust_assert (lhs != nullptr);
+    HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ().get ());
+    rust_assert (rhs != nullptr);
+
+    auto crate_num = mappings->get_current_crate ();
+    Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
+				   mappings->get_next_hir_id (crate_num),
+				   UNKNOWN_LOCAL_DEFID);
+
+    translated
+      = new HIR::ComparisonExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
+				 std::unique_ptr<HIR::Expr> (rhs), kind,
+				 expr.get_locus ());
+  }
+
+  void visit (AST::LazyBooleanExpr &expr)
+  {
+    HIR::LazyBooleanExpr::ExprType kind;
+    switch (expr.get_kind ())
+      {
+      case AST::LazyBooleanExpr::ExprType::LOGICAL_AND:
+	kind = HIR::LazyBooleanExpr::ExprType::LOGICAL_AND;
+	break;
+      case AST::LazyBooleanExpr::ExprType::LOGICAL_OR:
+	kind = HIR::LazyBooleanExpr::ExprType::LOGICAL_OR;
+	break;
+      }
+
+    HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ().get ());
+    rust_assert (lhs != nullptr);
+    HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ().get ());
+    rust_assert (rhs != nullptr);
+
+    auto crate_num = mappings->get_current_crate ();
+    Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
+				   mappings->get_next_hir_id (crate_num),
+				   UNKNOWN_LOCAL_DEFID);
+
+    translated
+      = new HIR::LazyBooleanExpr (mapping, std::unique_ptr<HIR::Expr> (lhs),
+				  std::unique_ptr<HIR::Expr> (rhs), kind,
+				  expr.get_locus ());
+  }
+
 private:
   ASTLoweringExpr () : translated (nullptr) {}
 
diff --git a/gcc/rust/hir/rust-ast-lower-item.h b/gcc/rust/hir/rust-ast-lower-item.h
index e6c86b8..f57ac86 100644
--- a/gcc/rust/hir/rust-ast-lower-item.h
+++ b/gcc/rust/hir/rust-ast-lower-item.h
@@ -25,6 +25,7 @@
 #include "rust-ast-lower-type.h"
 #include "rust-ast-lower-stmt.h"
 #include "rust-ast-lower-pattern.h"
+#include "rust-ast-lower-block.h"
 
 namespace Rust {
 namespace HIR {
@@ -83,7 +84,7 @@ public:
 
     std::unique_ptr<HIR::BlockExpr> function_body
       = std::unique_ptr<HIR::BlockExpr> (
-	translate (function.get_definition ().get ()));
+	ASTLoweringBlock::translate (function.get_definition ().get ()));
 
     auto crate_num = mappings->get_current_crate ();
     Analysis::NodeMapping mapping (crate_num, function.get_node_id (),
@@ -116,33 +117,6 @@ public:
     translated = fn;
   }
 
-  // Helpers
-
-  HIR::BlockExpr *translate (AST::BlockExpr *function_body)
-  {
-    std::vector<std::unique_ptr<HIR::Stmt> > block_stmts;
-    std::unique_ptr<HIR::ExprWithoutBlock> block_expr;
-    std::vector<HIR::Attribute> inner_attribs;
-    std::vector<HIR::Attribute> outer_attribs;
-
-    function_body->iterate_stmts ([&] (AST::Stmt *s) mutable -> bool {
-      auto translated_stmt = ASTLoweringStmt::translate (s);
-      block_stmts.push_back (std::unique_ptr<HIR::Stmt> (translated_stmt));
-      return true;
-    });
-
-    auto crate_num = mappings->get_current_crate ();
-    Analysis::NodeMapping mapping (crate_num, function_body->get_node_id (),
-				   mappings->get_next_hir_id (crate_num),
-				   UNKNOWN_LOCAL_DEFID);
-
-    return new HIR::BlockExpr (mapping, std::move (block_stmts),
-			       std::move (block_expr),
-			       std::move (inner_attribs),
-			       std::move (outer_attribs),
-			       function_body->get_locus ());
-  }
-
 private:
   ASTLoweringItem () : translated (nullptr) {}
 
diff --git a/gcc/rust/hir/rust-ast-lower-stmt.h b/gcc/rust/hir/rust-ast-lower-stmt.h
index c57d14f..f4ecd8e 100644
--- a/gcc/rust/hir/rust-ast-lower-stmt.h
+++ b/gcc/rust/hir/rust-ast-lower-stmt.h
@@ -23,6 +23,7 @@
 
 #include "rust-ast-lower-base.h"
 #include "rust-ast-lower-type.h"
+#include "rust-ast-lower-block.h"
 #include "rust-ast-lower-expr.h"
 #include "rust-ast-lower-pattern.h"
 
@@ -46,6 +47,24 @@ public:
 
   virtual ~ASTLoweringStmt () {}
 
+  void visit (AST::ExprStmtWithBlock &stmt)
+  {
+    HIR::ExprWithBlock *expr
+      = ASTLoweringExprWithBlock::translate (stmt.get_expr ().get ());
+
+    auto crate_num = mappings->get_current_crate ();
+    Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (),
+				   mappings->get_next_hir_id (crate_num),
+				   UNKNOWN_LOCAL_DEFID);
+    translated
+      = new HIR::ExprStmtWithBlock (mapping,
+				    std::unique_ptr<HIR::ExprWithBlock> (expr),
+				    stmt.get_locus ());
+    mappings->insert_location (crate_num, mapping.get_hirid (),
+			       stmt.get_locus ());
+    mappings->insert_hir_stmt (crate_num, mapping.get_hirid (), translated);
+  }
+
   void visit (AST::ExprStmtWithoutBlock &stmt)
   {
     HIR::Expr *expr = ASTLoweringExpr::translate (stmt.get_expr ().get ());
diff --git a/gcc/rust/hir/rust-ast-lower.cc b/gcc/rust/hir/rust-ast-lower.cc
index 8a514ce..93288c3 100644
--- a/gcc/rust/hir/rust-ast-lower.cc
+++ b/gcc/rust/hir/rust-ast-lower.cc
@@ -18,6 +18,8 @@
 
 #include "rust-ast-lower.h"
 #include "rust-ast-lower-item.h"
+#include "rust-ast-lower-expr.h"
+#include "rust-ast-lower-block.h"
 
 namespace Rust {
 namespace HIR {
@@ -58,5 +60,94 @@ ASTLowering::go ()
 		     has_utf8bom, has_shebang);
 }
 
+// rust-ast-lower-block.h
+void
+ASTLoweringBlock::visit (AST::BlockExpr &expr)
+{
+  std::vector<std::unique_ptr<HIR::Stmt> > block_stmts;
+  std::unique_ptr<HIR::ExprWithoutBlock> block_expr;
+  std::vector<HIR::Attribute> inner_attribs;
+  std::vector<HIR::Attribute> outer_attribs;
+
+  expr.iterate_stmts ([&] (AST::Stmt *s) mutable -> bool {
+    auto translated_stmt = ASTLoweringStmt::translate (s);
+    block_stmts.push_back (std::unique_ptr<HIR::Stmt> (translated_stmt));
+    return true;
+  });
+
+  auto crate_num = mappings->get_current_crate ();
+  Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
+				 mappings->get_next_hir_id (crate_num),
+				 UNKNOWN_LOCAL_DEFID);
+
+  translated
+    = new HIR::BlockExpr (mapping, std::move (block_stmts),
+			  std::move (block_expr), std::move (inner_attribs),
+			  std::move (outer_attribs), expr.get_locus ());
+}
+
+void
+ASTLoweringIfBlock::visit (AST::IfExpr &expr)
+{
+  HIR::Expr *condition
+    = ASTLoweringExpr::translate (expr.get_condition_expr ().get ());
+  HIR::BlockExpr *block
+    = ASTLoweringBlock::translate (expr.get_if_block ().get ());
+
+  auto crate_num = mappings->get_current_crate ();
+  Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
+				 mappings->get_next_hir_id (crate_num),
+				 UNKNOWN_LOCAL_DEFID);
+
+  translated = new HIR::IfExpr (mapping, std::unique_ptr<HIR::Expr> (condition),
+				std::unique_ptr<HIR::BlockExpr> (block),
+				expr.get_locus ());
+}
+
+void
+ASTLoweringIfBlock::visit (AST::IfExprConseqElse &expr)
+{
+  HIR::Expr *condition
+    = ASTLoweringExpr::translate (expr.get_condition_expr ().get ());
+  HIR::BlockExpr *if_block
+    = ASTLoweringBlock::translate (expr.get_if_block ().get ());
+  HIR::BlockExpr *else_block
+    = ASTLoweringBlock::translate (expr.get_else_block ().get ());
+
+  auto crate_num = mappings->get_current_crate ();
+  Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
+				 mappings->get_next_hir_id (crate_num),
+				 UNKNOWN_LOCAL_DEFID);
+
+  translated
+    = new HIR::IfExprConseqElse (mapping,
+				 std::unique_ptr<HIR::Expr> (condition),
+				 std::unique_ptr<HIR::BlockExpr> (if_block),
+				 std::unique_ptr<HIR::BlockExpr> (else_block),
+				 expr.get_locus ());
+}
+
+void
+ASTLoweringIfBlock::visit (AST::IfExprConseqIf &expr)
+{
+  HIR::Expr *condition
+    = ASTLoweringExpr::translate (expr.get_condition_expr ().get ());
+  HIR::BlockExpr *block
+    = ASTLoweringBlock::translate (expr.get_if_block ().get ());
+  HIR::IfExpr *conseq_if_expr
+    = ASTLoweringIfBlock::translate (expr.get_conseq_if_expr ().get ());
+
+  auto crate_num = mappings->get_current_crate ();
+  Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
+				 mappings->get_next_hir_id (crate_num),
+				 UNKNOWN_LOCAL_DEFID);
+
+  translated
+    = new HIR::IfExprConseqIf (mapping, std::unique_ptr<HIR::Expr> (condition),
+			       std::unique_ptr<HIR::BlockExpr> (block),
+			       std::unique_ptr<HIR::IfExpr> (conseq_if_expr),
+			       expr.get_locus ());
+}
+
 } // namespace HIR
 } // namespace Rust
diff --git a/gcc/rust/hir/tree/rust-hir-expr.h b/gcc/rust/hir/tree/rust-hir-expr.h
index 36c2085..7e1c76b 100644
--- a/gcc/rust/hir/tree/rust-hir-expr.h
+++ b/gcc/rust/hir/tree/rust-hir-expr.h
@@ -538,6 +538,8 @@ public:
   Expr *get_lhs () { return main_or_left_expr.get (); }
   Expr *get_rhs () { return right_expr.get (); }
 
+  ExprType get_kind () { return expr_type; }
+
   /* TODO: implement via a function call to std::cmp::PartialEq::eq(&op1, &op2)
    * maybe? */
 protected:
@@ -3647,6 +3649,8 @@ public:
 
   void vis_else_block (HIRVisitor &vis) { else_block->accept_vis (vis); }
 
+  BlockExpr *get_else_block () { return else_block.get (); }
+
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */
@@ -3715,6 +3719,8 @@ public:
     conseq_if_expr->accept_vis (vis);
   }
 
+  IfExpr *get_conseq_if_expr () { return conseq_if_expr.get (); }
+
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */
diff --git a/gcc/rust/hir/tree/rust-hir-stmt.h b/gcc/rust/hir/tree/rust-hir-stmt.h
index 9a0e0f2..be4ff7d 100644
--- a/gcc/rust/hir/tree/rust-hir-stmt.h
+++ b/gcc/rust/hir/tree/rust-hir-stmt.h
@@ -192,13 +192,11 @@ protected:
 // Statement containing an expression with a block
 class ExprStmtWithBlock : public ExprStmt
 {
-public:
   std::unique_ptr<ExprWithBlock> expr;
 
+public:
   std::string as_string () const override;
 
-  std::vector<LetStmt *> locals;
-
   ExprStmtWithBlock (Analysis::NodeMapping mappings,
 		     std::unique_ptr<ExprWithBlock> expr, Location locus)
     : ExprStmt (std::move (mappings), locus), expr (std::move (expr))
@@ -224,6 +222,8 @@ public:
 
   void accept_vis (HIRVisitor &vis) override;
 
+  ExprWithBlock *get_expr () { return expr.get (); }
+
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */
diff --git a/gcc/rust/resolve/rust-ast-resolve-expr.h b/gcc/rust/resolve/rust-ast-resolve-expr.h
index 9e98fda..3316b2a 100644
--- a/gcc/rust/resolve/rust-ast-resolve-expr.h
+++ b/gcc/rust/resolve/rust-ast-resolve-expr.h
@@ -95,6 +95,40 @@ public:
     ResolveExpr::go (expr.get_right_expr ().get (), expr.get_node_id ());
   }
 
+  void visit (AST::ComparisonExpr &expr)
+  {
+    ResolveExpr::go (expr.get_left_expr ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_right_expr ().get (), expr.get_node_id ());
+  }
+
+  void visit (AST::LazyBooleanExpr &expr)
+  {
+    ResolveExpr::go (expr.get_left_expr ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_right_expr ().get (), expr.get_node_id ());
+  }
+
+  void visit (AST::IfExpr &expr)
+  {
+    ResolveExpr::go (expr.get_condition_expr ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_if_block ().get (), expr.get_node_id ());
+  }
+
+  void visit (AST::IfExprConseqElse &expr)
+  {
+    ResolveExpr::go (expr.get_condition_expr ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_if_block ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_else_block ().get (), expr.get_node_id ());
+  }
+
+  void visit (AST::IfExprConseqIf &expr)
+  {
+    ResolveExpr::go (expr.get_condition_expr ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_if_block ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_conseq_if_expr ().get (), expr.get_node_id ());
+  }
+
+  void visit (AST::BlockExpr &expr);
+
 private:
   ResolveExpr (NodeId parent) : ResolverBase (parent) {}
 };
diff --git a/gcc/rust/resolve/rust-ast-resolve-stmt.h b/gcc/rust/resolve/rust-ast-resolve-stmt.h
index 20d40f1..87b3cf3 100644
--- a/gcc/rust/resolve/rust-ast-resolve-stmt.h
+++ b/gcc/rust/resolve/rust-ast-resolve-stmt.h
@@ -39,6 +39,11 @@ public:
 
   ~ResolveStmt () {}
 
+  void visit (AST::ExprStmtWithBlock &stmt)
+  {
+    ResolveExpr::go (stmt.get_expr ().get (), stmt.get_node_id ());
+  }
+
   void visit (AST::ExprStmtWithoutBlock &stmt)
   {
     ResolveExpr::go (stmt.get_expr ().get (), stmt.get_node_id ());
diff --git a/gcc/rust/resolve/rust-ast-resolve.cc b/gcc/rust/resolve/rust-ast-resolve.cc
index ba4ee21..8370a5b 100644
--- a/gcc/rust/resolve/rust-ast-resolve.cc
+++ b/gcc/rust/resolve/rust-ast-resolve.cc
@@ -17,10 +17,11 @@
 // <http://www.gnu.org/licenses/>.
 
 #include "rust-ast-resolve.h"
-#include "rust-ast-resolve-toplevel.h"
-#include "rust-ast-resolve-item.h"
 #include "rust-ast-full.h"
 #include "rust-tyty.h"
+#include "rust-ast-resolve-toplevel.h"
+#include "rust-ast-resolve-item.h"
+#include "rust-ast-resolve-expr.h"
 
 #define MKBUILTIN_TYPE(_X, _R, _TY)                                            \
   do                                                                           \
@@ -250,5 +251,25 @@ NameResolution::go (AST::Crate &crate)
     ResolveItem::go (it->get ());
 }
 
+// rust-ast-resolve-expr.h
+
+void
+ResolveExpr::visit (AST::BlockExpr &expr)
+{
+  NodeId scope_node_id = expr.get_node_id ();
+  resolver->get_name_scope ().push (scope_node_id);
+  resolver->get_type_scope ().push (scope_node_id);
+  resolver->push_new_name_rib (resolver->get_name_scope ().peek ());
+  resolver->push_new_type_rib (resolver->get_type_scope ().peek ());
+
+  expr.iterate_stmts ([&] (AST::Stmt *s) mutable -> bool {
+    ResolveStmt::go (s, s->get_node_id ());
+    return true;
+  });
+
+  resolver->get_name_scope ().pop ();
+  resolver->get_type_scope ().pop ();
+}
+
 } // namespace Resolver
 } // namespace Rust
diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.h b/gcc/rust/typecheck/rust-hir-type-check-expr.h
index c9a0fde..8be2dbf 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-expr.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-expr.h
@@ -179,6 +179,46 @@ public:
     infered = lhs->combine (rhs);
   }
 
+  void visit (HIR::ComparisonExpr &expr)
+  {
+    auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ());
+    auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ());
+
+    infered = lhs->combine (rhs);
+    // FIXME this will need to turn into bool
+  }
+
+  void visit (HIR::LazyBooleanExpr &expr)
+  {
+    auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ());
+    auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ());
+
+    infered = lhs->combine (rhs);
+    // FIXME this will need to turn into bool
+  }
+
+  void visit (HIR::IfExpr &expr)
+  {
+    TypeCheckExpr::Resolve (expr.get_if_condition ());
+    TypeCheckExpr::Resolve (expr.get_if_block ());
+  }
+
+  void visit (HIR::IfExprConseqElse &expr)
+  {
+    TypeCheckExpr::Resolve (expr.get_if_condition ());
+    TypeCheckExpr::Resolve (expr.get_if_block ());
+    TypeCheckExpr::Resolve (expr.get_else_block ());
+  }
+
+  void visit (HIR::IfExprConseqIf &expr)
+  {
+    TypeCheckExpr::Resolve (expr.get_if_condition ());
+    TypeCheckExpr::Resolve (expr.get_if_block ());
+    TypeCheckExpr::Resolve (expr.get_conseq_if_expr ());
+  }
+
+  void visit (HIR::BlockExpr &expr);
+
 private:
   TypeCheckExpr () : TypeCheckBase (), infered (nullptr) {}
 
diff --git a/gcc/rust/typecheck/rust-hir-type-check-stmt.h b/gcc/rust/typecheck/rust-hir-type-check-stmt.h
index ccf1138..d3189cc 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-stmt.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-stmt.h
@@ -36,6 +36,11 @@ public:
     stmt->accept_vis (resolver);
   }
 
+  void visit (HIR::ExprStmtWithBlock &stmt)
+  {
+    TypeCheckExpr::Resolve (stmt.get_expr ());
+  }
+
   void visit (HIR::ExprStmtWithoutBlock &stmt)
   {
     TypeCheckExpr::Resolve (stmt.get_expr ());
diff --git a/gcc/rust/typecheck/rust-hir-type-check.cc b/gcc/rust/typecheck/rust-hir-type-check.cc
index f9dbe49..79e0190 100644
--- a/gcc/rust/typecheck/rust-hir-type-check.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check.cc
@@ -20,6 +20,7 @@
 #include "rust-hir-full.h"
 #include "rust-hir-type-check-toplevel.h"
 #include "rust-hir-type-check-item.h"
+#include "rust-hir-type-check-expr.h"
 
 namespace Rust {
 namespace Resolver {
@@ -34,5 +35,15 @@ TypeResolution::Resolve (HIR::Crate &crate)
     TypeCheckItem::Resolve (it->get ());
 }
 
+// RUST_HIR_TYPE_CHECK_EXPR
+void
+TypeCheckExpr::visit (HIR::BlockExpr &expr)
+{
+  expr.iterate_stmts ([&] (HIR::Stmt *s) mutable -> bool {
+    TypeCheckStmt::Resolve (s);
+    return true;
+  });
+}
+
 } // namespace Resolver
 } // namespace Rust
diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc
index bdf487e..238689c 100644
--- a/gcc/rust/util/rust-hir-map.cc
+++ b/gcc/rust/util/rust-hir-map.cc
@@ -260,8 +260,6 @@ Mappings::lookup_hir_item (CrateNum crateNum, HirId id)
 void
 Mappings::insert_hir_expr (CrateNum crateNum, HirId id, HIR::Expr *expr)
 {
-  rust_assert (lookup_hir_expr (crateNum, id) == nullptr);
-
   hirExprMappings[crateNum][id] = expr;
   nodeIdToHirMappings[crateNum][expr->get_mappings ().get_nodeid ()] = id;
   insert_location (crateNum, id, expr->get_locus_slow ());