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

   1 // Copyright (C) 2020-2023 Free Software Foundation, Inc.
   2
   3 // This file is part of GCC.
   4
   5 // GCC is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU General Public License as published by the Free
   7 // Software Foundation; either version 3, or (at your option) any later
   8 // version.
   9
  10 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  11 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13 // for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with GCC; see the file COPYING3.  If not see
  17 // <http://www.gnu.org/licenses/>.
  18
  19 #include "rust-macro-builtins.h"
  20 #include "rust-ast.h"
  21 #include "rust-diagnostics.h"
  22 #include "rust-expr.h"
  23 #include "rust-session-manager.h"
  24 #include "rust-macro-invoc-lexer.h"
  25 #include "rust-lex.h"
  26 #include "rust-parse.h"
  27 #include "rust-early-name-resolver.h"
  28 #include "rust-attribute-visitor.h"
  29
  30 namespace Rust {
  31 namespace {
  32 std::unique_ptr<AST::Expr>
  33 make_string (Location locus, std::string value)
  34 {
  35   return std::unique_ptr<AST::Expr> (
  36     new AST::LiteralExpr (value, AST::Literal::STRING,
  37                           PrimitiveCoreType::CORETYPE_STR, {}, locus));
  38 }
  39
  40 /* Match the end token of a macro given the start delimiter of the macro */
  41
  42 static inline TokenId
  43 macro_end_token (AST::DelimTokenTree &invoc_token_tree,
  44                  Parser<MacroInvocLexer> &parser)
  45 {
  46   auto last_token_id = TokenId::RIGHT_CURLY;
  47   switch (invoc_token_tree.get_delim_type ())
  48     {
  49     case AST::DelimType::PARENS:
  50       last_token_id = TokenId::RIGHT_PAREN;
  51       rust_assert (parser.skip_token (LEFT_PAREN));
  52       break;
  53
  54     case AST::DelimType::CURLY:
  55       rust_assert (parser.skip_token (LEFT_CURLY));
  56       break;
  57
  58     case AST::DelimType::SQUARE:
  59       last_token_id = TokenId::RIGHT_SQUARE;
  60       rust_assert (parser.skip_token (LEFT_SQUARE));
  61       break;
  62     }
  63
  64   return last_token_id;
  65 }
  66
  67 /* Expand and extract an expression from the macro */
  68
  69 static inline AST::ASTFragment
  70 try_expand_macro_expression (AST::Expr *expr, MacroExpander *expander)
  71 {
  72   rust_assert (expander);
  73
  74   auto attr_visitor = Rust::AttrVisitor (*expander);
  75   auto early_name_resolver = Resolver::EarlyNameResolver ();
  76   expr->accept_vis (early_name_resolver);
  77   expr->accept_vis (attr_visitor);
  78   return expander->take_expanded_fragment (attr_visitor);
  79 }
  80
  81 /* Expand and then extract a string literal from the macro */
  82
  83 static std::unique_ptr<AST::LiteralExpr>
  84 try_extract_string_literal_from_fragment (const Location &parent_locus,
  85                                           std::unique_ptr<AST::Expr> &node)
  86 {
  87   auto maybe_lit = static_cast<AST::LiteralExpr *> (node.get ());
  88   if (!node || !node->is_literal ()
  89       || maybe_lit->get_lit_type () != AST::Literal::STRING)
  90     {
  91       rust_error_at (parent_locus, "argument must be a string literal");
  92       if (node)
  93         rust_inform (node->get_locus (), "expanded from here");
  94       return nullptr;
  95     }
  96   return std::unique_ptr<AST::LiteralExpr> (
  97     static_cast<AST::LiteralExpr *> (node->clone_expr ().release ()));
  98 }
  99
 100 static std::unique_ptr<AST::LiteralExpr>
 101 try_expand_single_string_literal (AST::Expr *input_expr,
 102                                   const Location &invoc_locus,
 103                                   MacroExpander *expander)
 104 {
 105   auto nodes = try_expand_macro_expression (input_expr, expander);
 106   if (nodes.is_error () || nodes.is_expression_fragment ())
 107     {
 108       rust_error_at (input_expr->get_locus (),
 109                      "argument must be a string literal");
 110       return nullptr;
 111     }
 112   auto expr = nodes.take_expression_fragment ();
 113   return try_extract_string_literal_from_fragment (input_expr->get_locus (),
 114                                                    expr);
 115 }
 116
 117 static std::vector<std::unique_ptr<AST::Expr>>
 118 try_expand_many_expr (Parser<MacroInvocLexer> &parser,
 119                       const Location &invoc_locus, const TokenId last_token_id,
 120                       MacroExpander *expander, bool &has_error)
 121 {
 122   auto restrictions = Rust::ParseRestrictions ();
 123   // stop parsing when encountered a braces/brackets
 124   restrictions.expr_can_be_null = true;
 125   // we can't use std::optional, so...
 126   auto result = std::vector<std::unique_ptr<AST::Expr>> ();
 127   auto empty_expr = std::vector<std::unique_ptr<AST::Expr>> ();
 128
 129   auto first_token = parser.peek_current_token ()->get_id ();
 130   if (first_token == COMMA)
 131     {
 132       rust_error_at (parser.peek_current_token ()->get_locus (),
 133                      "expected expression, found %<,%>");
 134       has_error = true;
 135       return empty_expr;
 136     }
 137
 138   while (parser.peek_current_token ()->get_id () != last_token_id
 139          && parser.peek_current_token ()->get_id () != END_OF_FILE)
 140     {
 141       auto expr = parser.parse_expr (AST::AttrVec (), restrictions);
 142       // something must be so wrong that the expression could not be parsed
 143       rust_assert (expr);
 144       auto nodes = try_expand_macro_expression (expr.get (), expander);
 145       if (nodes.is_error ())
 146         {
 147           // not macro
 148           result.push_back (std::move (expr));
 149         }
 150       else if (!nodes.is_expression_fragment ())
 151         {
 152           rust_error_at (expr->get_locus (), "expected expression");
 153           has_error = true;
 154           return empty_expr;
 155         }
 156       else
 157         {
 158           result.push_back (nodes.take_expression_fragment ());
 159         }
 160
 161       auto next_token = parser.peek_current_token ();
 162       if (!parser.skip_token (COMMA) && next_token->get_id () != last_token_id)
 163         {
 164           rust_error_at (next_token->get_locus (), "expected token: %<,%>");
 165           // TODO: is this recoverable? to avoid crashing the parser in the next
 166           // fragment we have to exit early here
 167           has_error = true;
 168           return empty_expr;
 169         }
 170     }
 171
 172   return result;
 173 }
 174
 175 /* Parse a single string literal from the given delimited token tree,
 176    and return the LiteralExpr for it. Allow for an optional trailing comma,
 177    but otherwise enforce that these are the only tokens.  */
 178
 179 std::unique_ptr<AST::LiteralExpr>
 180 parse_single_string_literal (AST::DelimTokenTree &invoc_token_tree,
 181                              Location invoc_locus, MacroExpander *expander)
 182 {
 183   MacroInvocLexer lex (invoc_token_tree.to_token_stream ());
 184   Parser<MacroInvocLexer> parser (lex);
 185
 186   auto last_token_id = macro_end_token (invoc_token_tree, parser);
 187
 188   std::unique_ptr<AST::LiteralExpr> lit_expr = nullptr;
 189
 190   if (parser.peek_current_token ()->get_id () == STRING_LITERAL)
 191     {
 192       lit_expr = parser.parse_literal_expr ();
 193       parser.maybe_skip_token (COMMA);
 194       if (parser.peek_current_token ()->get_id () != last_token_id)
 195         {
 196           lit_expr = nullptr;
 197           rust_error_at (invoc_locus, "macro takes 1 argument");
 198         }
 199     }
 200   else if (parser.peek_current_token ()->get_id () == last_token_id)
 201     rust_error_at (invoc_locus, "macro takes 1 argument");
 202   else
 203     {
 204       // when the expression does not seem to be a string literal, we then try
 205       // to parse/expand it as macro to see if it expands to a string literal
 206       auto expr = parser.parse_expr ();
 207       lit_expr
 208         = try_expand_single_string_literal (expr.get (), invoc_locus, expander);
 209     }
 210
 211   parser.skip_token (last_token_id);
 212
 213   return lit_expr;
 214 }
 215
 216 /* Treat PATH as a path relative to the source file currently being
 217    compiled, and return the absolute path for it.  */
 218
 219 std::string
 220 source_relative_path (std::string path, Location locus)
 221 {
 222   std::string compile_fname
 223     = Session::get_instance ().linemap->location_file (locus);
 224
 225   auto dir_separator_pos = compile_fname.rfind (file_separator);
 226
 227   /* If there is no file_separator in the path, use current dir ('.').  */
 228   std::string dirname;
 229   if (dir_separator_pos == std::string::npos)
 230     dirname = std::string (".") + file_separator;
 231   else
 232     dirname = compile_fname.substr (0, dir_separator_pos) + file_separator;
 233
 234   return dirname + path;
 235 }
 236
 237 /* Read the full contents of the file FILENAME and return them in a vector.
 238    FIXME: platform specific.  */
 239
 240 std::vector<uint8_t>
 241 load_file_bytes (const char *filename)
 242 {
 243   RAIIFile file_wrap (filename);
 244   if (file_wrap.get_raw () == nullptr)
 245     {
 246       rust_error_at (Location (), "cannot open filename %s: %m", filename);
 247       return std::vector<uint8_t> ();
 248     }
 249
 250   FILE *f = file_wrap.get_raw ();
 251   fseek (f, 0L, SEEK_END);
 252   long fsize = ftell (f);
 253   fseek (f, 0L, SEEK_SET);
 254
 255   std::vector<uint8_t> buf (fsize);
 256
 257   if (fread (&buf[0], fsize, 1, f) != 1)
 258     {
 259       rust_error_at (Location (), "error reading file %s: %m", filename);
 260       return std::vector<uint8_t> ();
 261     }
 262
 263   return buf;
 264 }
 265 } // namespace
 266
 267 AST::ASTFragment
 268 MacroBuiltin::assert (Location invoc_locus, AST::MacroInvocData &invoc)
 269 {
 270   rust_debug ("assert!() called");
 271
 272   return AST::ASTFragment::create_error ();
 273 }
 274
 275 AST::ASTFragment
 276 MacroBuiltin::file (Location invoc_locus, AST::MacroInvocData &invoc)
 277 {
 278   auto current_file
 279     = Session::get_instance ().linemap->location_file (invoc_locus);
 280   auto file_str = AST::SingleASTNode (make_string (invoc_locus, current_file));
 281
 282   return AST::ASTFragment ({file_str});
 283 }
 284
 285 AST::ASTFragment
 286 MacroBuiltin::column (Location invoc_locus, AST::MacroInvocData &invoc)
 287 {
 288   auto current_column
 289     = Session::get_instance ().linemap->location_to_column (invoc_locus);
 290
 291   auto column_no = AST::SingleASTNode (std::unique_ptr<AST::Expr> (
 292     new AST::LiteralExpr (std::to_string (current_column), AST::Literal::INT,
 293                           PrimitiveCoreType::CORETYPE_U32, {}, invoc_locus)));
 294
 295   return AST::ASTFragment ({column_no});
 296 }
 297
 298 /* Expand builtin macro include_bytes!("filename"), which includes the contents
 299    of the given file as reference to a byte array. Yields an expression of type
 300    &'static [u8; N].  */
 301
 302 AST::ASTFragment
 303 MacroBuiltin::include_bytes (Location invoc_locus, AST::MacroInvocData &invoc)
 304 {
 305   /* Get target filename from the macro invocation, which is treated as a path
 306      relative to the include!-ing file (currently being compiled).  */
 307   auto lit_expr
 308     = parse_single_string_literal (invoc.get_delim_tok_tree (), invoc_locus,
 309                                    invoc.get_expander ());
 310   if (lit_expr == nullptr)
 311     return AST::ASTFragment::create_error ();
 312
 313   std::string target_filename
 314     = source_relative_path (lit_expr->as_string (), invoc_locus);
 315
 316   std::vector<uint8_t> bytes = load_file_bytes (target_filename.c_str ());
 317
 318   /* Is there a more efficient way to do this?  */
 319   std::vector<std::unique_ptr<AST::Expr>> elts;
 320   for (uint8_t b : bytes)
 321     {
 322       elts.emplace_back (
 323         new AST::LiteralExpr (std::string (1, (char) b), AST::Literal::BYTE,
 324                               PrimitiveCoreType::CORETYPE_U8,
 325                               {} /* outer_attrs */, invoc_locus));
 326     }
 327
 328   auto elems = std::unique_ptr<AST::ArrayElems> (
 329     new AST::ArrayElemsValues (std::move (elts), invoc_locus));
 330
 331   auto array = std::unique_ptr<AST::Expr> (
 332     new AST::ArrayExpr (std::move (elems), {}, {}, invoc_locus));
 333
 334   auto borrow = std::unique_ptr<AST::Expr> (
 335     new AST::BorrowExpr (std::move (array), false, false, {}, invoc_locus));
 336
 337   auto node = AST::SingleASTNode (std::move (borrow));
 338   return AST::ASTFragment ({node});
 339 }
 340
 341 /* Expand builtin macro include_str!("filename"), which includes the contents
 342    of the given file as a string. The file must be UTF-8 encoded. Yields an
 343    expression of type &'static str.  */
 344
 345 AST::ASTFragment
 346 MacroBuiltin::include_str (Location invoc_locus, AST::MacroInvocData &invoc)
 347 {
 348   /* Get target filename from the macro invocation, which is treated as a path
 349      relative to the include!-ing file (currently being compiled).  */
 350   auto lit_expr
 351     = parse_single_string_literal (invoc.get_delim_tok_tree (), invoc_locus,
 352                                    invoc.get_expander ());
 353   if (lit_expr == nullptr)
 354     return AST::ASTFragment::create_error ();
 355
 356   std::string target_filename
 357     = source_relative_path (lit_expr->as_string (), invoc_locus);
 358
 359   std::vector<uint8_t> bytes = load_file_bytes (target_filename.c_str ());
 360
 361   /* FIXME: Enforce that the file contents are valid UTF-8.  */
 362   std::string str ((const char *) &bytes[0], bytes.size ());
 363
 364   auto node = AST::SingleASTNode (make_string (invoc_locus, str));
 365   return AST::ASTFragment ({node});
 366 }
 367
 368 /* Expand builtin macro compile_error!("error"), which forces a compile error
 369    during the compile time. */
 370 AST::ASTFragment
 371 MacroBuiltin::compile_error (Location invoc_locus, AST::MacroInvocData &invoc)
 372 {
 373   auto lit_expr
 374     = parse_single_string_literal (invoc.get_delim_tok_tree (), invoc_locus,
 375                                    invoc.get_expander ());
 376   if (lit_expr == nullptr)
 377     return AST::ASTFragment::create_error ();
 378
 379   std::string error_string = lit_expr->as_string ();
 380   rust_error_at (invoc_locus, "%s", error_string.c_str ());
 381
 382   return AST::ASTFragment::create_error ();
 383 }
 384
 385 /* Expand builtin macro concat!(), which joins all the literal parameters
 386    into a string with no delimiter. */
 387
 388 AST::ASTFragment
 389 MacroBuiltin::concat (Location invoc_locus, AST::MacroInvocData &invoc)
 390 {
 391   auto invoc_token_tree = invoc.get_delim_tok_tree ();
 392   MacroInvocLexer lex (invoc_token_tree.to_token_stream ());
 393   Parser<MacroInvocLexer> parser (lex);
 394
 395   auto str = std::string ();
 396   bool has_error = false;
 397
 398   auto last_token_id = macro_end_token (invoc_token_tree, parser);
 399
 400   /* NOTE: concat! could accept no argument, so we don't have any checks here */
 401   auto expanded_expr = try_expand_many_expr (parser, invoc_locus, last_token_id,
 402                                              invoc.get_expander (), has_error);
 403   for (auto &expr : expanded_expr)
 404     {
 405       if (!expr->is_literal ())
 406         {
 407           has_error = true;
 408           rust_error_at (expr->get_locus (), "expected a literal");
 409           // diagnostics copied from rustc
 410           rust_inform (expr->get_locus (),
 411                        "only literals (like %<\"foo\"%>, %<42%> and "
 412                        "%<3.14%>) can be passed to %<concat!()%>");
 413           continue;
 414         }
 415       auto *literal = static_cast<AST::LiteralExpr *> (expr.get ());
 416       if (literal->get_lit_type () == AST::Literal::BYTE
 417           || literal->get_lit_type () == AST::Literal::BYTE_STRING)
 418         {
 419           has_error = true;
 420           rust_error_at (expr->get_locus (),
 421                          "cannot concatenate a byte string literal");
 422           continue;
 423         }
 424       str += literal->as_string ();
 425     }
 426
 427   parser.skip_token (last_token_id);
 428
 429   if (has_error)
 430     return AST::ASTFragment::create_error ();
 431
 432   auto node = AST::SingleASTNode (make_string (invoc_locus, str));
 433   return AST::ASTFragment ({node});
 434 }
 435
 436 /* Expand builtin macro env!(), which inspects an environment variable at
 437    compile time. */
 438
 439 AST::ASTFragment
 440 MacroBuiltin::env (Location invoc_locus, AST::MacroInvocData &invoc)
 441 {
 442   auto invoc_token_tree = invoc.get_delim_tok_tree ();
 443   MacroInvocLexer lex (invoc_token_tree.to_token_stream ());
 444   Parser<MacroInvocLexer> parser (lex);
 445
 446   auto last_token_id = macro_end_token (invoc_token_tree, parser);
 447   std::unique_ptr<AST::LiteralExpr> error_expr = nullptr;
 448   std::unique_ptr<AST::LiteralExpr> lit_expr = nullptr;
 449   bool has_error = false;
 450
 451   auto expanded_expr = try_expand_many_expr (parser, invoc_locus, last_token_id,
 452                                              invoc.get_expander (), has_error);
 453   if (has_error)
 454     return AST::ASTFragment::create_error ();
 455   if (expanded_expr.size () < 1 || expanded_expr.size () > 2)
 456     {
 457       rust_error_at (invoc_locus, "env! takes 1 or 2 arguments");
 458       return AST::ASTFragment::create_error ();
 459     }
 460   if (expanded_expr.size () > 0)
 461     {
 462       if (!(lit_expr
 463             = try_extract_string_literal_from_fragment (invoc_locus,
 464                                                         expanded_expr[0])))
 465         {
 466           return AST::ASTFragment::create_error ();
 467         }
 468     }
 469   if (expanded_expr.size () > 1)
 470     {
 471       if (!(error_expr
 472             = try_extract_string_literal_from_fragment (invoc_locus,
 473                                                         expanded_expr[1])))
 474         {
 475           return AST::ASTFragment::create_error ();
 476         }
 477     }
 478
 479   parser.skip_token (last_token_id);
 480
 481   auto env_value = getenv (lit_expr->as_string ().c_str ());
 482
 483   if (env_value == nullptr)
 484     {
 485       if (error_expr == nullptr)
 486         rust_error_at (invoc_locus, "environment variable %qs not defined",
 487                        lit_expr->as_string ().c_str ());
 488       else
 489         rust_error_at (invoc_locus, "%s", error_expr->as_string ().c_str ());
 490       return AST::ASTFragment::create_error ();
 491     }
 492
 493   auto node = AST::SingleASTNode (make_string (invoc_locus, env_value));
 494   return AST::ASTFragment ({node});
 495 }
 496
 497 AST::ASTFragment
 498 MacroBuiltin::cfg (Location invoc_locus, AST::MacroInvocData &invoc)
 499 {
 500   // only parse if not already parsed
 501   if (!invoc.is_parsed ())
 502     {
 503       std::unique_ptr<AST::AttrInputMetaItemContainer> converted_input (
 504         invoc.get_delim_tok_tree ().parse_to_meta_item ());
 505
 506       if (converted_input == nullptr)
 507         {
 508           rust_debug ("DEBUG: failed to parse macro to meta item");
 509           // TODO: do something now? is this an actual error?
 510         }
 511       else
 512         {
 513           std::vector<std::unique_ptr<AST::MetaItemInner>> meta_items (
 514             std::move (converted_input->get_items ()));
 515           invoc.set_meta_item_output (std::move (meta_items));
 516         }
 517     }
 518
 519   /* TODO: assuming that cfg! macros can only have one meta item inner, like cfg
 520    * attributes */
 521   if (invoc.get_meta_items ().size () != 1)
 522     return AST::ASTFragment::create_error ();
 523
 524   bool result = invoc.get_meta_items ()[0]->check_cfg_predicate (
 525     Session::get_instance ());
 526   auto literal_exp = AST::SingleASTNode (std::unique_ptr<AST::Expr> (
 527     new AST::LiteralExpr (result ? "true" : "false", AST::Literal::BOOL,
 528                           PrimitiveCoreType::CORETYPE_BOOL, {}, invoc_locus)));
 529
 530   return AST::ASTFragment ({literal_exp});
 531 }
 532
 533 /* Expand builtin macro include!(), which includes a source file at the current
 534  scope compile time. */
 535
 536 AST::ASTFragment
 537 MacroBuiltin::include (Location invoc_locus, AST::MacroInvocData &invoc)
 538 {
 539   /* Get target filename from the macro invocation, which is treated as a path
 540      relative to the include!-ing file (currently being compiled).  */
 541   auto lit_expr
 542     = parse_single_string_literal (invoc.get_delim_tok_tree (), invoc_locus,
 543                                    invoc.get_expander ());
 544   if (lit_expr == nullptr)
 545     return AST::ASTFragment::create_error ();
 546
 547   std::string filename
 548     = source_relative_path (lit_expr->as_string (), invoc_locus);
 549   auto target_filename
 550     = Rust::Session::get_instance ().include_extra_file (std::move (filename));
 551
 552   RAIIFile target_file (target_filename);
 553   Linemap *linemap = Session::get_instance ().linemap;
 554
 555   if (!target_file.ok ())
 556     {
 557       rust_error_at (lit_expr->get_locus (),
 558                      "cannot open included file %qs: %m", target_filename);
 559       return AST::ASTFragment::create_error ();
 560     }
 561
 562   rust_debug ("Attempting to parse included file %s", target_filename);
 563
 564   Lexer lex (target_filename, std::move (target_file), linemap);
 565   Parser<Lexer> parser (lex);
 566
 567   auto parsed_items = parser.parse_items ();
 568   bool has_error = !parser.get_errors ().empty ();
 569
 570   for (const auto &error : parser.get_errors ())
 571     error.emit_error ();
 572
 573   if (has_error)
 574     {
 575       // inform the user that the errors above are from a included file
 576       rust_inform (invoc_locus, "included from here");
 577       return AST::ASTFragment::create_error ();
 578     }
 579
 580   std::vector<AST::SingleASTNode> nodes{};
 581   for (auto &item : parsed_items)
 582     {
 583       AST::SingleASTNode node (std::move (item));
 584       nodes.push_back (node);
 585     }
 586
 587   return AST::ASTFragment (nodes);
 588 }
 589
 590 AST::ASTFragment
 591 MacroBuiltin::line (Location invoc_locus, AST::MacroInvocData &invoc)
 592 {
 593   auto current_line
 594     = Session::get_instance ().linemap->location_to_line (invoc_locus);
 595
 596   auto line_no = AST::SingleASTNode (std::unique_ptr<AST::Expr> (
 597     new AST::LiteralExpr (std::to_string (current_line), AST::Literal::INT,
 598                           PrimitiveCoreType::CORETYPE_U32, {}, invoc_locus)));
 599
 600   return AST::ASTFragment ({line_no});
 601 }
 602
 603 } // namespace Rust