Merge #1514

1514: Fix SEGV in transcribe_type when compiling libcore 1.29 r=CohenArthur a=CohenArthur

Needs #1513, Skip reviewing the first commit

Co-authored-by: Arthur Cohen <[email protected]>

Author: bors[bot]

gcc/rust/ast/rust-ast-dump.h

@@ -52,6 +52,22 @@ class Dump : public ASTVisitor
   void go (AST::Crate &crate);
   void go (AST::Item &item);
 
+  /**
+   * Use the AST Dump as a debugging tool
+   */
+  template <typename T> static void debug (T &instance)
+  {
+    auto dump = Dump (std::cerr);
+
+    std::cerr << '\n';
+    instance.accept_vis (dump);
+    std::cerr << '\n';
+  }
+  template <typename T> static void debug (std::unique_ptr<T> &instance)
+  {
+    debug (*instance);
+  }
+
 private:
   std::ostream &stream;
   Indent indentation;

gcc/rust/ast/rust-ast.h

@@ -24,6 +24,7 @@
 #include "rust-hir-map.h"
 #include "rust-token.h"
 #include "rust-location.h"
+#include "rust-diagnostics.h"
 
 namespace Rust {
 // TODO: remove typedefs and make actual types for these
@@ -1818,7 +1819,7 @@ class SingleASTNode
     return true;
   }
 
-  std::string as_string ()
+  std::string as_string () const
   {
     switch (kind)
       {
@@ -1869,9 +1870,44 @@ class ASTFragment
 
   bool is_single_fragment () const { return nodes.size () == 1; }
 
-  bool is_single_fragment_kind (SingleASTNode::NodeType kind) const
+  bool is_single_fragment_of_kind (SingleASTNode::NodeType expected) const
   {
-    return is_single_fragment () && nodes[0].get_kind () == kind;
+    return is_single_fragment () && nodes[0].get_kind () == expected;
+  }
+
+  void assert_single_fragment (SingleASTNode::NodeType expected) const
+  {
+    static const std::map<SingleASTNode::NodeType, const char *> str_map = {
+      {SingleASTNode::NodeType::IMPL, "impl"},
+      {SingleASTNode::NodeType::ITEM, "item"},
+      {SingleASTNode::NodeType::TYPE, "type"},
+      {SingleASTNode::NodeType::EXPRESSION, "expr"},
+      {SingleASTNode::NodeType::STMT, "stmt"},
+      {SingleASTNode::NodeType::EXTERN, "extern"},
+      {SingleASTNode::NodeType::TRAIT, "trait"},
+      {SingleASTNode::NodeType::TRAIT_IMPL, "trait impl"},
+    };
+
+    auto actual = nodes[0].get_kind ();
+    auto fail = false;
+
+    if (!is_single_fragment ())
+      {
+	rust_error_at (Location (), "fragment is not single");
+	fail = true;
+      }
+
+    if (actual != expected)
+      {
+	rust_error_at (
+	  Location (),
+	  "invalid fragment operation: expected %qs node, got %qs node",
+	  str_map.find (expected)->second,
+	  str_map.find (nodes[0].get_kind ())->second);
+	fail = true;
+      }
+
+    rust_assert (!fail);
   }
 
 public:
@@ -1913,15 +1949,25 @@ class ASTFragment
 
   bool should_expand () const { return !is_error (); }
 
+  bool is_expression_fragment () const
+  {
+    return is_single_fragment_of_kind (SingleASTNode::NodeType::EXPRESSION);
+  }
+
+  bool is_type_fragment () const
+  {
+    return is_single_fragment_of_kind (SingleASTNode::NodeType::TYPE);
+  }
+
   std::unique_ptr<Expr> take_expression_fragment ()
   {
-    rust_assert (is_single_fragment_kind (SingleASTNode::NodeType::EXPRESSION));
+    assert_single_fragment (SingleASTNode::NodeType::EXPRESSION);
     return nodes[0].take_expr ();
   }
 
   std::unique_ptr<Type> take_type_fragment ()
   {
-    rust_assert (is_single_fragment_kind (SingleASTNode::NodeType::TYPE));
+    assert_single_fragment (SingleASTNode::NodeType::TYPE);
     return nodes[0].take_type ();
   }
 

gcc/rust/expand/rust-attribute-visitor.cc

@@ -2662,7 +2662,7 @@ AttrVisitor::visit (AST::InherentImpl &impl)
   for (auto &param : impl.get_generic_params ())
     param->accept_vis (*this);
 
-  expander.push_context (MacroExpander::ContextType::TYPE);
+  expander.push_context (MacroExpander::ContextType::ITEM);
 
   auto &type = impl.get_type ();
   type->accept_vis (*this);
@@ -2706,7 +2706,7 @@ AttrVisitor::visit (AST::TraitImpl &impl)
   for (auto &param : impl.get_generic_params ())
     param->accept_vis (*this);
 
-  expander.push_context (MacroExpander::ContextType::TYPE);
+  expander.push_context (MacroExpander::ContextType::ITEM);
 
   auto &type = impl.get_type ();
   type->accept_vis (*this);
@@ -3427,19 +3427,22 @@ AttrVisitor::visit (AST::BareFunctionType &type)
 
   // no where clause, apparently
 }
+
 void
 AttrVisitor::maybe_expand_expr (std::unique_ptr<AST::Expr> &expr)
 {
   auto final_fragment = expand_macro_fragment_recursive ();
-  if (final_fragment.should_expand ())
+  if (final_fragment.should_expand ()
+      && final_fragment.is_expression_fragment ())
     expr = final_fragment.take_expression_fragment ();
 }
 
 void
 AttrVisitor::maybe_expand_type (std::unique_ptr<AST::Type> &type)
 {
   auto final_fragment = expand_macro_fragment_recursive ();
-  if (final_fragment.should_expand ())
+  if (final_fragment.should_expand () && final_fragment.is_type_fragment ())
     type = final_fragment.take_type_fragment ();
 }
+
 } // namespace Rust

gcc/rust/expand/rust-macro-expand.cc

@@ -864,7 +864,9 @@ transcribe_expression (Parser<MacroInvocLexer> &parser)
 static AST::ASTFragment
 transcribe_type (Parser<MacroInvocLexer> &parser)
 {
-  auto type = parser.parse_type ();
+  auto type = parser.parse_type (true);
+  for (auto err : parser.get_errors ())
+    err.emit_error ();
 
   return AST::ASTFragment ({std::move (type)});
 }