Desugar AST::ForLoopExprs as part of HIR lowering

gcc/rust/Make-lang.in

@@ -230,6 +230,7 @@ GRS_OBJS = \
 	rust/rust-expand-format-args.o \
 	rust/rust-lang-item.o \
 	rust/rust-collect-lang-items.o \
+	rust/rust-desugar-for-loops.o \
     $(END)
 # removed object files from here
 

gcc/rust/ast/rust-ast-builder.cc

@@ -20,6 +20,7 @@
 #include "rust-ast-builder-type.h"
 #include "rust-common.h"
 #include "rust-expr.h"
+#include "rust-path.h"
 #include "rust-token.h"
 #include "rust-make-unique.h"
 
@@ -42,6 +43,33 @@ Builder::call (std::unique_ptr<Expr> &&path,
     new CallExpr (std::move (path), std::move (args), {}, loc));
 }
 
+std::unique_ptr<Expr>
+Builder::call (std::unique_ptr<Path> &&path,
+	       std::vector<std::unique_ptr<Expr>> &&args) const
+{
+  return call (std::unique_ptr<Expr> (
+		 new PathInExpression (std::move (path), {}, loc)),
+	       std::move (args));
+}
+
+std::unique_ptr<Expr>
+Builder::call (std::unique_ptr<Expr> &&path, std::unique_ptr<Expr> &&arg) const
+{
+  auto args = std::vector<std::unique_ptr<Expr>> ();
+  args.emplace_back (std::move (arg));
+
+  return call (std::move (path), std::move (args));
+}
+
+std::unique_ptr<Expr>
+Builder::call (std::unique_ptr<Path> &&path, std::unique_ptr<Expr> &&arg) const
+{
+  auto args = std::vector<std::unique_ptr<Expr>> ();
+  args.emplace_back (std::move (arg));
+
+  return call (std::move (path), std::move (args));
+}
+
 std::unique_ptr<Expr>
 Builder::array (std::vector<std::unique_ptr<Expr>> &&members) const
 {
@@ -56,6 +84,12 @@ Builder::identifier (std::string name) const
   return std::unique_ptr<Expr> (new IdentifierExpr (name, {}, loc));
 }
 
+std::unique_ptr<Pattern>
+Builder::identifier_pattern (std::string name, bool mut) const
+{
+  return std::unique_ptr<Pattern> (new IdentifierPattern (name, loc, false, mut));
+}
+
 std::unique_ptr<Expr>
 Builder::tuple_idx (std::string receiver, int idx) const
 {
@@ -117,6 +151,22 @@ Builder::path_in_expression (std::vector<std::string> &&segments) const
   return PathInExpression (std::move (path_segments), {}, loc);
 }
 
+PathInExpression
+Builder::path_in_expression (LangItem::Kind lang_item) const
+{
+  return PathInExpression (lang_item, {}, loc);
+}
+
+std::unique_ptr<Expr>
+Builder::block (std::unique_ptr<Stmt> &&stmt,
+		std::unique_ptr<Expr> &&tail_expr) const
+{
+  auto stmts = std::vector<std::unique_ptr<Stmt>>();
+  stmts.emplace_back(std::move(stmt));
+
+  return block(std::move(stmts), std::move(tail_expr));
+}
+
 std::unique_ptr<Expr>
 Builder::block (std::vector<std::unique_ptr<Stmt>> &&stmts,
 		std::unique_ptr<Expr> &&tail_expr) const
@@ -189,6 +239,46 @@ Builder::wildcard () const
   return std::unique_ptr<Pattern> (new WildcardPattern (loc));
 }
 
+std::unique_ptr<Path>
+Builder::lang_item_path (LangItem::Kind kind) const
+{
+  return std::unique_ptr<Path> (new LangItemPath (kind, loc));
+}
+
+std::unique_ptr<Expr>
+Builder::match (std::unique_ptr<Expr> &&scrutinee,
+		std::vector<MatchCase> &&cases)
+{
+  return std::unique_ptr<Expr> (
+    new MatchExpr (std::move (scrutinee), std::move (cases), {}, {}, loc));
+}
+
+MatchArm
+Builder::match_arm (std::unique_ptr<Pattern> &&pattern)
+{
+  auto patterns = std::vector<std::unique_ptr<Pattern>> ();
+  patterns.emplace_back (std::move (pattern));
+
+  return MatchArm (std::move (patterns), loc);
+}
+
+MatchCase
+Builder::match_case (std::unique_ptr<Pattern> &&pattern,
+		     std::unique_ptr<Expr> &&expr)
+{
+  return MatchCase (match_arm (std::move (pattern)), std::move (expr));
+}
+
+std::unique_ptr<Expr>
+Builder::loop (std::vector<std::unique_ptr<Stmt>> &&stmts)
+{
+  auto block = std::unique_ptr<BlockExpr> (
+    new BlockExpr (std::move (stmts), nullptr, {}, {}, LoopLabel::error (), loc,
+		   loc));
+
+  return std::unique_ptr<Expr> (new LoopExpr (std::move (block), loc));
+}
+
 std::unique_ptr<Type>
 Builder::new_type (Type &type)
 {

gcc/rust/ast/rust-ast-builder.h

@@ -20,6 +20,7 @@
 #define AST_BUILDER_H
 
 #include "rust-ast-full.h"
+#include "rust-expr.h"
 
 namespace Rust {
 namespace AST {
@@ -38,6 +39,7 @@ class Builder
 
   /* Create an identifier expression (`variable`) */
   std::unique_ptr<Expr> identifier (std::string name) const;
+  std::unique_ptr<Pattern> identifier_pattern (std::string name, bool mut = false) const;
 
   /* Create a tuple index expression (`receiver.0`) */
   std::unique_ptr<Expr> tuple_idx (std::string receiver, int idx) const;
@@ -53,6 +55,9 @@ class Builder
   std::unique_ptr<Expr> block (std::vector<std::unique_ptr<Stmt>> &&stmts,
 			       std::unique_ptr<Expr> &&tail_expr
 			       = nullptr) const;
+  std::unique_ptr<Expr> block (std::unique_ptr<Stmt> &&stmt,
+			       std::unique_ptr<Expr> &&tail_expr
+			       = nullptr) const;
 
   /* Create a let binding with an optional type and initializer (`let <name> :
    * <type> = <init>`) */
@@ -66,6 +71,12 @@ class Builder
    */
   std::unique_ptr<Expr> call (std::unique_ptr<Expr> &&path,
 			      std::vector<std::unique_ptr<Expr>> &&args) const;
+  std::unique_ptr<Expr> call (std::unique_ptr<Path> &&path,
+			      std::vector<std::unique_ptr<Expr>> &&args) const;
+  std::unique_ptr<Expr> call (std::unique_ptr<Expr> &&path,
+			      std::unique_ptr<Expr> &&arg) const;
+  std::unique_ptr<Expr> call (std::unique_ptr<Path> &&path,
+			      std::unique_ptr<Expr> &&arg) const;
 
   /**
    * Create an array expression (`[member0, member1, member2]`)
@@ -100,6 +111,11 @@ class Builder
   PathInExpression
   path_in_expression (std::vector<std::string> &&segments) const;
 
+  /**
+   * Create a path in expression from a lang item.
+   */
+  PathInExpression path_in_expression (LangItem::Kind lang_item) const;
+
   /* Create a struct expression for unit structs (`S`) */
   std::unique_ptr<Expr> struct_expr_struct (std::string struct_name) const;
 
@@ -122,6 +138,19 @@ class Builder
   /* Create a wildcard pattern (`_`) */
   std::unique_ptr<Pattern> wildcard () const;
 
+  /* Create a lang item path usable as a general path */
+  std::unique_ptr<Path> lang_item_path (LangItem::Kind) const;
+
+  /* Create match expressions and their components */
+  std::unique_ptr<Expr> match (std::unique_ptr<Expr> &&scrutinee,
+			       std::vector<MatchCase> &&cases);
+  MatchArm match_arm (std::unique_ptr<Pattern> &&pattern);
+  MatchCase match_case (std::unique_ptr<Pattern> &&pattern,
+			std::unique_ptr<Expr> &&expr);
+
+  /* Create a loop expression */
+  std::unique_ptr<Expr> loop (std::vector<std::unique_ptr<Stmt>> &&stmts);
+
   static std::unique_ptr<Type> new_type (Type &type);
 
   static std::unique_ptr<GenericParam>

gcc/rust/ast/rust-ast-collector.cc

@@ -21,6 +21,7 @@
 #include "rust-expr.h"
 #include "rust-item.h"
 #include "rust-keyword-values.h"
+#include "rust-path.h"
 #include "rust-system.h"
 #include "rust-token.h"
 
@@ -553,11 +554,25 @@ TokenCollector::visit (PathExprSegment &segment)
 void
 TokenCollector::visit (PathInExpression &path)
 {
-  if (path.opening_scope_resolution ())
+  if (path.get_path ().get_path_kind () == Path::Kind::LangItem)
     {
-      push (Rust::Token::make (SCOPE_RESOLUTION, path.get_locus ()));
+      auto lang_item = static_cast<LangItemPath &> (path.get_path ());
+
+      push (Rust::Token::make (TokenId::HASH, path.get_locus ()));
+      push (Rust::Token::make (TokenId::LEFT_SQUARE, path.get_locus ()));
+      push (Rust::Token::make_identifier (path.get_locus (), "lang"));
+      push (Rust::Token::make (TokenId::EQUAL, path.get_locus ()));
+      push (Rust::Token::make_string (path.get_locus (),
+				      LangItem::ToString (
+					lang_item.get_lang_item_kind ())));
+      push (Rust::Token::make (TokenId::RIGHT_SQUARE, path.get_locus ()));
+
+      return;
     }
 
+  if (path.opening_scope_resolution ())
+    push (Rust::Token::make (SCOPE_RESOLUTION, path.get_locus ()));
+
   visit_items_joined_by_separator (path.get_segments (), SCOPE_RESOLUTION);
 }
 

gcc/rust/ast/rust-ast-visitor.cc

@@ -100,8 +100,10 @@ void
 DefaultASTVisitor::visit (AST::PathInExpression &path)
 {
   visit_outer_attrs (path);
-  for (auto &segment : path.get_segments ())
-    visit (segment);
+
+  if (path.get_path ().get_path_kind () != AST::Path::Kind::LangItem)
+    for (auto &segment : path.get_segments ())
+      visit (segment);
 }
 
 void