FormatArgsEager

Author: powerboat9

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

@@ -3013,6 +3013,13 @@ TokenCollector::visit (AST::FormatArgs &fmt)
 		 __FILE__, __LINE__);
 }
 
+void
+TokenCollector::visit (AST::FormatArgsEager &fmt)
+{
+  rust_sorry_at (fmt.get_locus (), "%s:%u: unimplemented FormatArgsEager visitor",
+		 __FILE__, __LINE__);
+}
+
 void
 TokenCollector::visit (AST::OffsetOf &offset_of)
 {

gcc/rust/ast/rust-ast-collector.h

@@ -405,6 +405,7 @@ class TokenCollector : public ASTVisitor
   void visit (BareFunctionType &type);
 
   void visit (FormatArgs &fmt);
+  void visit (FormatArgsEager &fmt);
   void visit (OffsetOf &offset_of);
 };
 } // namespace AST

gcc/rust/ast/rust-ast-full-decls.h

@@ -272,6 +272,7 @@ class BareFunctionType;
 
 // rust-builtin-ast-nodes.h
 class FormatArgs;
+class FormatArgsEager;
 } // namespace AST
 } // namespace Rust
 

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

@@ -1505,6 +1505,15 @@ DefaultASTVisitor::visit (AST::FormatArgs &)
   // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
 }
 
+void
+DefaultASTVisitor::visit (AST::FormatArgsEager &fmt)
+{
+  // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
+
+  // we need this to resolve/expand macros, at least
+  visit (fmt.get_template ());
+}
+
 void
 DefaultASTVisitor::visit (AST::OffsetOf &offset_of)
 {

gcc/rust/ast/rust-ast-visitor.h

@@ -240,6 +240,7 @@ class ASTVisitor
 
   // special AST nodes for certain builtin macros such as `asm!()`
   virtual void visit (FormatArgs &fmt) = 0;
+  virtual void visit (FormatArgsEager &fmt) = 0;
   virtual void visit (OffsetOf &fmt) = 0;
 
   // TODO: rust-cond-compilation.h visiting? not currently used
@@ -413,6 +414,7 @@ class DefaultASTVisitor : public ASTVisitor
   virtual void visit (AST::FunctionParam &param) override;
   virtual void visit (AST::VariadicParam &param) override;
   virtual void visit (AST::FormatArgs &fmt) override;
+  virtual void visit (AST::FormatArgsEager &fmt) override;
   virtual void visit (AST::OffsetOf &fmt) override;
 
   template <typename T> void visit (T &node) { node.accept_vis (*this); }

gcc/rust/ast/rust-ast.cc

@@ -5054,6 +5054,59 @@ FormatArgs::clone_expr_impl () const
   return new FormatArgs (*this);
 }
 
+void
+FormatArgsEager::accept_vis (ASTVisitor &vis)
+{
+  vis.visit (*this);
+}
+
+std::string
+FormatArgsEager::as_string () const
+{
+  // FIXME(Arthur): Improve
+  return "FormatArgsEager";
+}
+
+bool
+FormatArgsEager::is_expr_without_block () const
+{
+  return false;
+}
+
+void
+FormatArgsEager::mark_for_strip ()
+{
+  marked_for_strip = true;
+}
+
+bool
+FormatArgsEager::is_marked_for_strip () const
+{
+  return marked_for_strip;
+}
+
+std::vector<Attribute> &
+FormatArgsEager::get_outer_attrs ()
+{
+  rust_unreachable ();
+}
+
+void
+FormatArgsEager::set_outer_attrs (std::vector<Attribute>)
+{
+  rust_unreachable ();
+}
+
+FormatArgsEager *
+FormatArgsEager::clone_expr_impl () const
+{
+  // based on FormatArgs::clone_expr_impl
+  // TODO: should this be happening?
+  rust_debug_loc (get_locus (), "[ARTHUR/OWEN] cloning FormatArgsEager!");
+
+  return new FormatArgsEager (*this);
+}
+
 std::vector<Attribute> &
 OffsetOf::get_outer_attrs ()
 {

gcc/rust/ast/rust-ast.h

@@ -1310,6 +1310,7 @@ class Expr : public Visitable
     LlvmInlineAsm,
     Identifier,
     FormatArgs,
+    FormatArgsEager,
     OffsetOf,
     MacroInvocation,
     Borrow,

gcc/rust/ast/rust-builtin-ast-nodes.h

@@ -225,6 +225,70 @@ class FormatArgs : public Expr
   virtual Expr *clone_expr_impl () const override;
 };
 
+// a FormatArgs which hasn't had its first argument parsed yet
+// used to handle eager expansion
+class FormatArgsEager final : public Expr
+{
+public:
+  using Newline = FormatArgs::Newline;
+
+  FormatArgsEager (location_t loc, std::unique_ptr<Expr> &&template_expr,
+	      FormatArguments &&arguments, Newline newline)
+    : loc (loc), template_expr (std::move (template_expr)),
+      arguments (std::move (arguments)), newline (newline)
+  {}
+
+  FormatArgsEager (const FormatArgsEager &other): Expr (other), loc (other.loc), template_expr (other.template_expr->clone_expr ()), arguments (other.arguments), newline (other.newline) {}
+
+  FormatArgsEager &operator= (const FormatArgsEager &other)
+  {
+    Expr::operator= (other);
+    loc = other.loc;
+    template_expr = other.template_expr->clone_expr ();
+    arguments = other.arguments;
+    newline = other.newline;
+    return *this;
+  }
+
+  FormatArgsEager (FormatArgsEager &&other) = default;
+  FormatArgsEager &operator= (FormatArgsEager &&other) = default;
+
+  void accept_vis (AST::ASTVisitor &vis) override;
+
+  const Expr &get_template () const { return *template_expr; }
+  
+  Expr &get_template () { return *template_expr; }
+  
+  std::unique_ptr<Expr> &get_template_ptr () { return template_expr; }
+  
+  const FormatArguments &get_arguments () const { return arguments; }
+  
+  FormatArguments &get_arguments () { return arguments; }
+  
+  virtual location_t get_locus () const override { return loc; }
+  
+  Newline get_newline () const { return newline; }
+
+  Expr::Kind get_expr_kind () const override { return Expr::Kind::FormatArgsEager; }
+
+private:
+  location_t loc;
+  std::unique_ptr<Expr> template_expr;
+  FormatArguments arguments;
+  Newline newline;
+
+  bool marked_for_strip = false;
+
+protected:
+  virtual std::string as_string () const override;
+  virtual bool is_expr_without_block () const override;
+  virtual void mark_for_strip () override;
+  virtual bool is_marked_for_strip () const override;
+  virtual std::vector<Attribute> &get_outer_attrs () override;
+  virtual void set_outer_attrs (std::vector<Attribute>) override;
+  virtual FormatArgsEager *clone_expr_impl () const override;
+};
+
 /**
  * The node associated with the builtin offset_of!() macro
  */

gcc/rust/expand/rust-derive.h

@@ -256,6 +256,7 @@ class DeriveVisitor : public AST::ASTVisitor
   virtual void visit (FunctionParam &param) override final{};
   virtual void visit (VariadicParam &param) override final{};
   virtual void visit (FormatArgs &param) override final{};
+  virtual void visit (FormatArgsEager &param) override final{};
   virtual void visit (OffsetOf &param) override final{};
 };
 

gcc/rust/expand/rust-expand-format-args.cc

@@ -65,9 +65,38 @@ get_trait_name (ffi::FormatSpec format_specifier)
   return it->second;
 }
 
-tl::optional<AST::Fragment>
-expand_format_args (AST::FormatArgs &fmt,
-		    std::vector<std::unique_ptr<AST::Token>> &&tokens)
+tl::optional<std::unique_ptr<AST::Expr>>
+expand_format_args_eager (AST::FormatArgsEager &fmt_eager)
+{
+  if (!fmt_eager.get_template ().is_literal ())
+    {
+      if (fmt_eager.get_template ().get_expr_kind () != AST::Expr::Kind::MacroInvocation)
+        rust_error_at (fmt_eager.get_locus (), "format argument must be a string literal");
+      return tl::nullopt;
+    }
+
+  auto &literal = static_cast<AST::LiteralExpr &> (fmt_eager.get_template ());
+
+  // TODO: is special handling for RAW_STRING needed?
+  rust_assert (literal.get_lit_type () == AST::Literal::STRING || literal.get_lit_type () == AST::Literal::RAW_STRING);
+
+  // TODO: does this handle escapes in STRING properly?
+  auto fmt_str = literal.get_literal ().as_string ();
+
+  bool append_newline = fmt_eager.get_newline () == AST::FormatArgs::Newline::Yes;
+
+  if (append_newline)
+    fmt_str += '\n';
+
+  auto pieces = Fmt::Pieces::collect (fmt_str, append_newline, Fmt::ffi::ParseMode::Format);
+
+  auto fmt_args_node = AST::FormatArgs (fmt_eager.get_locus (), std::move (pieces), std::move (fmt_eager.get_arguments ()));
+
+  return Fmt::expand_format_args (fmt_args_node);
+}
+
+std::unique_ptr<AST::Expr>
+expand_format_args (AST::FormatArgs &fmt)
 {
   auto loc = fmt.get_locus ();
   auto builder = AST::Builder (loc);
@@ -131,9 +160,7 @@ expand_format_args (AST::FormatArgs &fmt,
   auto final_call
     = builder.call (std::move (final_path), std::move (final_args));
 
-  auto node = AST::SingleASTNode (std::move (final_call));
-
-  return AST::Fragment ({node}, std::move (tokens));
+  return final_call;
 }
 
 } // namespace Fmt