// Copyright (C) 2025-2026 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/>.

/* DO NOT INCLUDE ANYWHERE - this is automatically included
 *   by rust-parse-impl*.h
 * This is also the reason why there are no include guards. */

#include "rust-parse.h"
#include "rust-parse-error.h"
#include "rust-attribute-values.h"
#include "expected.h"

namespace Rust {

// Parse a inner or outer doc comment into an doc attribute
template <typename ManagedTokenSource>
Parse::AttributeBody
Parser<ManagedTokenSource>::parse_doc_comment ()
{
  const_TokenPtr token = lexer.peek_token ();
  location_t locus = token->get_locus ();
  AST::SimplePathSegment segment (Values::Attributes::DOC, locus);
  std::vector<AST::SimplePathSegment> segments;
  segments.push_back (std::move (segment));
  AST::SimplePath attr_path (std::move (segments), false, locus);
  AST::LiteralExpr lit_expr (token->get_str (), AST::Literal::STRING,
			     PrimitiveCoreType::CORETYPE_STR, {}, locus);
  std::unique_ptr<AST::AttrInput> attr_input (
    new AST::AttrInputLiteral (std::move (lit_expr)));
  lexer.skip_token ();

  return Parse::AttributeBody{std::move (attr_path), std::move (attr_input),
			      locus};
}

// Parse a single inner attribute.
template <typename ManagedTokenSource>
tl::expected<AST::Attribute, Parse::Error::Attribute>
Parser<ManagedTokenSource>::parse_inner_attribute ()
{
  if (lexer.peek_token ()->get_id () == INNER_DOC_COMMENT)
    {
      auto body = parse_doc_comment ();
      return AST::Attribute (std::move (body.path), std::move (body.input),
			     body.locus, true);
    }

  rust_assert (lexer.peek_token ()->get_id () == HASH);

  lexer.skip_token ();

  if (lexer.peek_token ()->get_id () != EXCLAM)
    {
      Error error (lexer.peek_token ()->get_locus (),
		   "expected %<!%> or %<[%> for inner attribute");
      add_error (std::move (error));

      return Parse::Error::Attribute::make_malformed ();
    }
  lexer.skip_token ();

  if (!skip_token (LEFT_SQUARE))
    return Parse::Error::Attribute::make_malformed ();

  auto body_res = parse_attribute_body ();
  if (!body_res)
    return Parse::Error::Attribute::make_malformed ();
  auto body = std::move (body_res.value ());

  auto actual_attribute
    = AST::Attribute (std::move (body.path), std::move (body.input), body.locus,
		      true);

  if (!skip_token (RIGHT_SQUARE))
    return Parse::Error::Attribute::make_malformed ();

  return actual_attribute;
}

// Parse a single outer attribute.
template <typename ManagedTokenSource>
tl::expected<AST::Attribute, Parse::Error::Attribute>
Parser<ManagedTokenSource>::parse_outer_attribute ()
{
  if (lexer.peek_token ()->get_id () == OUTER_DOC_COMMENT)
    {
      auto body = parse_doc_comment ();
      return AST::Attribute (std::move (body.path), std::move (body.input),
			     body.locus, false);
    }

  if (lexer.peek_token ()->get_id () == INNER_DOC_COMMENT)
    {
      Error error (
	lexer.peek_token ()->get_locus (), ErrorCode::E0753,
	"expected outer doc comment, inner doc (%<//!%> or %</*!%>) only "
	"allowed at start of item "
	"and before any outer attribute or doc (%<#[%>, %<///%> or %</**%>)");
      add_error (std::move (error));
      lexer.skip_token ();
      return Parse::Error::Attribute::make_unexpected_inner ();
    }

  /* OuterAttribute -> '#' '[' Attr ']' */

  if (lexer.peek_token ()->get_id () != HASH)
    return Parse::Error::Attribute::make_malformed ();

  lexer.skip_token ();

  TokenId id = lexer.peek_token ()->get_id ();
  if (id != LEFT_SQUARE)
    {
      if (id == EXCLAM)
	{
	  // this is inner attribute syntax, so throw error
	  // inner attributes were either already parsed or not allowed here.
	  Error error (
	    lexer.peek_token ()->get_locus (),
	    "token %<!%> found, indicating inner attribute definition. Inner "
	    "attributes are not possible at this location");
	  add_error (std::move (error));
	}
      return Parse::Error::Attribute::make_unexpected_inner ();
    }

  lexer.skip_token ();

  auto body_res = parse_attribute_body ();
  if (!body_res)
    return Parse::Error::Attribute::make_malformed_body ();
  auto body = std::move (body_res.value ());

  auto actual_attribute
    = AST::Attribute (std::move (body.path), std::move (body.input), body.locus,
		      false);

  if (lexer.peek_token ()->get_id () != RIGHT_SQUARE)
    return Parse::Error::Attribute::make_malformed ();

  lexer.skip_token ();

  return actual_attribute;
}

// Parses the body of an attribute (inner or outer).
template <typename ManagedTokenSource>
tl::expected<Parse::AttributeBody, Parse::Error::AttributeBody>
Parser<ManagedTokenSource>::parse_attribute_body ()
{
  location_t locus = lexer.peek_token ()->get_locus ();

  auto attr_path = parse_simple_path ();
  // ensure path is valid to parse attribute input
  if (!attr_path)
    {
      Error error (lexer.peek_token ()->get_locus (),
		   "empty simple path in attribute");
      add_error (std::move (error));

      // Skip past potential further info in attribute (i.e. attr_input)
      skip_after_end_attribute ();
      return Parse::Error::AttributeBody::make_invalid_path ();
    }

  auto attr_input = parse_attr_input ();
  // AttrInput is allowed to be null, so no checks here
  if (attr_input)
    return Parse::AttributeBody{std::move (attr_path.value ()),
				std::move (attr_input.value ()), locus};
  else if (attr_input.error ().kind == Parse::Error::AttrInput::Kind::MISSING)
    return Parse::AttributeBody{std::move (attr_path.value ()), nullptr, locus};
  else
    return Parse::Error::AttributeBody::make_invalid_attrinput ();
}

// Parse a contiguous block of inner attributes.
template <typename ManagedTokenSource>
AST::AttrVec
Parser<ManagedTokenSource>::parse_inner_attributes ()
{
  AST::AttrVec inner_attributes;

  auto has_valid_inner_attribute_prefix = [&] () {
    auto id = lexer.peek_token ()->get_id ();
    /* Outer attribute `#[` is not allowed, only accepts `#!` */
    return (id == HASH && lexer.peek_token (1)->get_id () == EXCLAM)
	   || id == INNER_DOC_COMMENT;
  };

  while (has_valid_inner_attribute_prefix ())
    {
      auto inner_attr = parse_inner_attribute ();

      /* Ensure only valid inner attributes are added to the inner_attributes
       * list */
      if (inner_attr)
	{
	  inner_attributes.push_back (std::move (inner_attr.value ()));
	}
      else
	{
	  /* If no more valid inner attributes, break out of loop (only
	   * contiguous inner attributes parsed). */
	  break;
	}
    }

  inner_attributes.shrink_to_fit ();
  return inner_attributes;
}

// Parses a contiguous block of outer attributes.
template <typename ManagedTokenSource>
AST::AttrVec
Parser<ManagedTokenSource>::parse_outer_attributes ()
{
  AST::AttrVec outer_attributes;

  auto has_valid_attribute_prefix = [&] () {
    auto id = lexer.peek_token ()->get_id ();
    /* We allow inner attributes `#!` and catch the error later  */
    return id == HASH || id == OUTER_DOC_COMMENT || id == INNER_DOC_COMMENT;
  };

  while (has_valid_attribute_prefix ()) /* For error handling.  */
    {
      auto outer_attr = parse_outer_attribute ();

      /* Ensure only valid outer attributes are added to the outer_attributes
       * list */
      if (outer_attr)
	{
	  outer_attributes.push_back (std::move (outer_attr.value ()));
	}
      else
	{
	  /* If no more valid outer attributes, break out of loop (only
	   * contiguous outer attributes parsed). */
	  break;
	}
    }

  outer_attributes.shrink_to_fit ();
  return outer_attributes;

  /* TODO: this shares basically all code with parse_inner_attributes except
   * function call - find way of making it more modular? function pointer? */
}

// Parses an AttrInput AST node (polymorphic, as AttrInput is abstract)
template <typename ManagedTokenSource>
tl::expected<std::unique_ptr<AST::AttrInput>, Parse::Error::AttrInput>
Parser<ManagedTokenSource>::parse_attr_input ()
{
  const_TokenPtr t = lexer.peek_token ();
  switch (t->get_id ())
    {
    case LEFT_PAREN:
    case LEFT_SQUARE:
    case LEFT_CURLY:
      {
	auto dtoken_tree = parse_delim_token_tree ();
	if (!dtoken_tree)
	  return Parse::Error::AttrInput::make_bad_token_tree ();

	// must be a delimited token tree, so parse that
	std::unique_ptr<AST::AttrInput> input_tree (
	  new AST::DelimTokenTree (dtoken_tree.value ()));

	return tl::expected<std::unique_ptr<AST::AttrInput>,
			    Parse::Error::AttrInput>{std::move (input_tree)};
      }
    case EQUAL:
      {
	// = LiteralExpr
	lexer.skip_token ();

	t = lexer.peek_token ();

	// attempt to parse macro
	// TODO: macros may/may not be allowed in attributes
	// this is needed for "#[doc = include_str!(...)]"
	if (Parse::Utils::is_simple_path_segment (t->get_id ()))
	  {
	    std::unique_ptr<AST::MacroInvocation> invoke
	      = parse_macro_invocation ({});

	    if (!invoke)
	      return Parse::Error::AttrInput::make_bad_macro_invocation ();

	    return std::unique_ptr<AST::AttrInput> (
	      new AST::AttrInputMacro (std::move (invoke)));
	  }

	/* Ensure token is a "literal expression" (literally only a literal
	 * token of any type) */
	if (!t->is_literal ())
	  {
	    Error error (
	      t->get_locus (),
	      "unknown token %qs in attribute body - literal expected",
	      t->get_token_description ());
	    add_error (std::move (error));

	    skip_after_end_attribute ();
	    return Parse::Error::AttrInput::make_malformed ();
	  }

	AST::Literal::LitType lit_type = AST::Literal::STRING;
	// Crappy mapping of token type to literal type
	switch (t->get_id ())
	  {
	  case INT_LITERAL:
	    lit_type = AST::Literal::INT;
	    break;
	  case FLOAT_LITERAL:
	    lit_type = AST::Literal::FLOAT;
	    break;
	  case CHAR_LITERAL:
	    lit_type = AST::Literal::CHAR;
	    break;
	  case BYTE_CHAR_LITERAL:
	    lit_type = AST::Literal::BYTE;
	    break;
	  case BYTE_STRING_LITERAL:
	    lit_type = AST::Literal::BYTE_STRING;
	    break;
	  case RAW_STRING_LITERAL:
	    lit_type = AST::Literal::RAW_STRING;
	    break;
	  case STRING_LITERAL:
	  default:
	    lit_type = AST::Literal::STRING;
	    break; // TODO: raw string? don't eliminate it from lexer?
	  }

	// create actual LiteralExpr
	AST::LiteralExpr lit_expr (t->get_str (), lit_type, t->get_type_hint (),
				   {}, t->get_locus ());
	lexer.skip_token ();

	std::unique_ptr<AST::AttrInput> attr_input_lit (
	  new AST::AttrInputLiteral (std::move (lit_expr)));

	// do checks or whatever? none required, really

	// FIXME: shouldn't a skip token be required here?

	return tl::expected<std::unique_ptr<AST::AttrInput>,
			    Parse::Error::AttrInput>{
	  std::move (attr_input_lit)};
      }
      break;
    case RIGHT_PAREN:
    case RIGHT_SQUARE:
    case RIGHT_CURLY:
    case END_OF_FILE:
      // means AttrInput is missing, which is allowed
      return Parse::Error::AttrInput::make_missing_attrinput ();
    default:
      add_error (
	Error (t->get_locus (),
	       "unknown token %qs in attribute body - attribute input or "
	       "none expected",
	       t->get_token_description ()));

      skip_after_end_attribute ();
      return Parse::Error::AttrInput::make_malformed ();
    }
  rust_unreachable ();
  // TODO: find out how to stop gcc error on "no return value"
}

} // namespace Rust