Improved parser errors

gcc/rust/ast/rust-ast.cc

@@ -3816,7 +3816,7 @@ DelimTokenTree::to_token_stream () const
 std::unique_ptr<MetaItemLitExpr>
 AttributeParser::parse_meta_item_lit ()
 {
-  std::unique_ptr<LiteralExpr> lit_expr = parser->parse_literal_expr ({});
+  auto lit_expr = parser->parse_literal_expr ({});
 
   // TODO: return nullptr instead?
   if (!lit_expr)
@@ -3825,7 +3825,7 @@ AttributeParser::parse_meta_item_lit ()
 		       lexer->peek_token ()->get_locus ()));
 
   return std::unique_ptr<MetaItemLitExpr> (
-    new MetaItemLitExpr (std::move (*lit_expr)));
+    new MetaItemLitExpr (std::move (*lit_expr.value ())));
 }
 
 bool

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

@@ -188,7 +188,7 @@ parse_single_string_literal (BuiltinMacro kind,
 
   if (parser.peek_current_token ()->get_id () == STRING_LITERAL)
     {
-      lit_expr = parser.parse_literal_expr ();
+      lit_expr = parser.parse_literal_expr ().value ();
       parser.maybe_skip_token (COMMA);
       if (parser.peek_current_token ()->get_id () != last_token_id)
 	{

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

@@ -427,7 +427,7 @@ MacroExpander::match_fragment (Parser<MacroInvocLexer> &parser,
       break;
 
     case AST::MacroFragSpec::LITERAL:
-      parser.parse_literal_expr ();
+      std::ignore = parser.parse_literal_expr ();
       break;
 
     case AST::MacroFragSpec::ITEM:

gcc/rust/parse/rust-cfg-parser.cc

@@ -51,10 +51,11 @@ parse_cfg_option (std::string &input, std::string &key, std::string &value)
       {
 	rust_assert (parser.skip_token (EQUAL));
 
-	auto value_expr = parser.parse_literal_expr ();
+	auto value_expr_res = parser.parse_literal_expr ();
 	// We had an equal sign but no value, error out
-	if (!value_expr)
+	if (!value_expr_res)
 	  return false;
+	auto value_expr = std::move (value_expr_res.value ());
 
 	if (value_expr->get_lit_type () != AST::Literal::LitType::STRING)
 	  return false;

gcc/rust/parse/rust-parse-error.h

@@ -55,22 +55,6 @@ struct Attribute
   Attribute (Kind kind) : kind (kind) {}
 };
 
-struct SimplePath
-{
-  static tl::expected<AST::SimplePath, SimplePath> make_malformed ()
-  {
-    return tl::unexpected<SimplePath> (SimplePath (Kind::MALFORMED));
-  }
-
-  enum class Kind
-  {
-    MALFORMED,
-  } kind;
-
-private:
-  SimplePath (Kind kind) : kind (kind) {}
-};
-
 struct AttributeBody
 {
   static tl::expected<Parse::AttributeBody, AttributeBody> make_invalid_path ()
@@ -172,151 +156,161 @@ struct AttrInput
   AttrInput (Kind kind) : kind (kind) {}
 };
 
-struct DelimTokenTree
+struct Item
 {
-  static tl::expected<AST::DelimTokenTree, DelimTokenTree>
-  make_expected_delimiter ()
-  {
-    return tl::unexpected<DelimTokenTree> (
-      DelimTokenTree (Kind::EXPECTED_DELIMITER));
-  }
-
-  static tl::expected<AST::DelimTokenTree, DelimTokenTree>
-  make_invalid_token_tree ()
+  static tl::expected<std::unique_ptr<AST::Item>, Item> make_end_of_file ()
   {
-    return tl::unexpected<DelimTokenTree> (
-      DelimTokenTree (Kind::INVALID_TOKEN_TREE));
+    return tl::unexpected<Item> (Item (Kind::END_OF_FILE));
   }
 
-  static tl::expected<AST::DelimTokenTree, DelimTokenTree>
-  make_mismatched_delimiters ()
+  static tl::expected<std::unique_ptr<AST::Item>, Item> make_malformed ()
   {
-    return tl::unexpected<DelimTokenTree> (
-      DelimTokenTree (Kind::INVALID_TOKEN_TREE));
+    return tl::unexpected<Item> (Item (Kind::MALFORMED));
   }
 
   enum class Kind
   {
-    EXPECTED_DELIMITER,
-    INVALID_TOKEN_TREE,
-    MISMATCHED_DELIMITERS,
+    END_OF_FILE,
+    MALFORMED,
   } kind;
 
 private:
-  DelimTokenTree (Kind kind) : kind (kind) {}
+  Item (Kind kind) : kind (kind) {}
 };
 
-struct Token
+struct Items
 {
-  static tl::expected<std::unique_ptr<AST::Token>, Token> make_malformed ()
+  static tl::expected<std::vector<std::unique_ptr<AST::Item>>, Items>
+  make_malformed (std::vector<std::unique_ptr<AST::Item>> items)
   {
-    return tl::unexpected<Token> (Token (Kind::MALFORMED));
+    return tl::unexpected<Items> (Items (Kind::MALFORMED, std::move (items)));
   }
 
   enum class Kind
   {
     MALFORMED,
   } kind;
 
+  Items (Items const &) = delete;
+  Items &operator= (Items const &) = delete;
+
+  Items (Items &&items) = default;
+  Items &operator= (Items &&) = default;
+
+  // Should we do anything with valid items ?
+  std::vector<std::unique_ptr<AST::Item>> items;
+
 private:
-  Token (Kind kind) : kind (kind) {}
+  Items (Kind kind, std::vector<std::unique_ptr<AST::Item>> items)
+    : kind (kind), items (std::move (items))
+  {}
 };
 
-struct TokenTree
+struct Visibility
 {
-  static tl::expected<std::unique_ptr<AST::TokenTree>, TokenTree>
-  make_malformed ()
+  static tl::expected<AST::Visibility, Visibility> make_malformed ()
   {
-    return tl::unexpected<TokenTree> (TokenTree (Kind::MALFORMED));
+    return tl::unexpected<Visibility> (Visibility (Kind::MALFORMED));
   }
 
-  static tl::expected<std::unique_ptr<AST::TokenTree>, TokenTree>
-  make_malformed_delimited_token_tree ()
+  static tl::expected<AST::Visibility, Visibility> make_missing_path ()
   {
-    return tl::unexpected<TokenTree> (
-      TokenTree (Kind::MALFORMED_DELIMITED_TOKEN_TREE));
+    return tl::unexpected<Visibility> (Visibility (Kind::MISSING_PATH));
   }
 
   enum class Kind
   {
+    MISSING_PATH,
     MALFORMED,
-    MALFORMED_DELIMITED_TOKEN_TREE,
   } kind;
 
 private:
-  TokenTree (Kind kind) : kind (kind) {}
+  Visibility (Kind kind) : kind (kind) {}
 };
 
-struct Item
+struct LifetimeParam
 {
-  static tl::expected<std::unique_ptr<AST::Item>, Item> make_end_of_file ()
-  {
-    return tl::unexpected<Item> (Item (Kind::END_OF_FILE));
-  }
-
-  static tl::expected<std::unique_ptr<AST::Item>, Item> make_malformed ()
+  static tl::expected<AST::LifetimeParam, LifetimeParam>
+  make_not_a_lifetime_param ()
   {
-    return tl::unexpected<Item> (Item (Kind::MALFORMED));
+    return tl::unexpected<LifetimeParam> (
+      LifetimeParam (Kind::NOT_A_LIFETIME_PARAM));
   }
 
   enum class Kind
   {
-    END_OF_FILE,
-    MALFORMED,
+    NOT_A_LIFETIME_PARAM,
   } kind;
 
 private:
-  Item (Kind kind) : kind (kind) {}
+  LifetimeParam (Kind kind) : kind (kind) {}
 };
 
-struct Items
+class Lifetime
 {
-  static tl::expected<std::vector<std::unique_ptr<AST::Item>>, Items>
-  make_malformed (std::vector<std::unique_ptr<AST::Item>> items)
+};
+
+struct LoopLabel
+{
+  static tl::expected<AST::LoopLabel, LoopLabel> make_not_loop_label ()
   {
-    return tl::unexpected<Items> (Items (Kind::MALFORMED, std::move (items)));
+    return tl::unexpected<LoopLabel> (LoopLabel (Kind::NOT_LOOP_LABEL));
+  }
+
+  static tl::expected<AST::LoopLabel, LoopLabel> make_missing_colon ()
+  {
+    return tl::unexpected<LoopLabel> (LoopLabel (Kind::MISSING_COLON));
   }
 
   enum class Kind
   {
-    MALFORMED,
+    // Not an hard error
+    NOT_LOOP_LABEL,
+    // Hard error
+    MISSING_COLON,
   } kind;
 
-  Items (Items const &) = delete;
-  Items &operator= (Items const &) = delete;
-
-  Items (Items &&items) = default;
-  Items &operator= (Items &&) = default;
-
-  // Should we do anything with valid items ?
-  std::vector<std::unique_ptr<AST::Item>> items;
-
 private:
-  Items (Kind kind, std::vector<std::unique_ptr<AST::Item>> items)
-    : kind (kind), items (std::move (items))
-  {}
+  LoopLabel (Kind kind) : kind (kind) {}
 };
 
-struct Visibility
+struct Self
 {
-  static tl::expected<AST::Visibility, Visibility> make_malformed ()
+  static tl::expected<std::unique_ptr<AST::Param>, Self>
+  make_self_raw_pointer ()
   {
-    return tl::unexpected<Visibility> (Visibility (Kind::MALFORMED));
+    return tl::unexpected<Self> (Self (Kind::SELF_RAW_PTR));
   }
 
-  static tl::expected<AST::Visibility, Visibility> make_missing_path ()
+  static tl::expected<std::unique_ptr<AST::Param>, Self> make_not_self ()
   {
-    return tl::unexpected<Visibility> (Visibility (Kind::MISSING_PATH));
+    return tl::unexpected<Self> (Self (Kind::NOT_SELF));
+  }
+
+  static tl::expected<std::unique_ptr<AST::Param>, Self> make_parsing_error ()
+  {
+    return tl::unexpected<Self> (Self (Kind::PARSING));
   }
 
   enum class Kind
   {
-    MISSING_PATH,
-    MALFORMED,
+    SELF_RAW_PTR,
+    PARSING,
+    NOT_SELF,
   } kind;
 
 private:
-  Visibility (Kind kind) : kind (kind) {}
+  Self (Kind kind) : kind (kind) {}
+};
+
+// Generic intermediate AST node error used when the errors need no special
+// handling
+enum class Node
+{
+  // Unexpected or missing token whilst parsing the node
+  MALFORMED,
+  // Error whilst parsing a child construct for the current node
+  CHILD_ERROR,
 };
 
 } // namespace Error