gdb/rust-exp.y

   1 /* Bison parser for Rust expressions, for GDB.
   2    Copyright (C) 2016-2017 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /* Removing the last conflict seems difficult.  */
  20 %expect 1
  21
  22 %{
  23
  24 #include "defs.h"
  25
  26 #include "block.h"
  27 #include "charset.h"
  28 #include "cp-support.h"
  29 #include "gdb_obstack.h"
  30 #include "gdb_regex.h"
  31 #include "rust-lang.h"
  32 #include "parser-defs.h"
  33 #include "selftest.h"
  34 #include "value.h"
  35 #include "vec.h"
  36
  37 #define GDB_YY_REMAP_PREFIX rust
  38 #include "yy-remap.h"
  39
  40 #define RUSTSTYPE YYSTYPE
  41
  42 struct rust_op;
  43 typedef std::vector<const struct rust_op *> rust_op_vector;
  44
  45 /* A typed integer constant.  */
  46
  47 struct typed_val_int
  48 {
  49   LONGEST val;
  50   struct type *type;
  51 };
  52
  53 /* A typed floating point constant.  */
  54
  55 struct typed_val_float
  56 {
  57   gdb_byte val[16];
  58   struct type *type;
  59 };
  60
  61 /* An identifier and an expression.  This is used to represent one
  62    element of a struct initializer.  */
  63
  64 struct set_field
  65 {
  66   struct stoken name;
  67   const struct rust_op *init;
  68 };
  69
  70 typedef std::vector<set_field> rust_set_vector;
  71
  72 static int rustyylex (void);
  73 static void rust_push_back (char c);
  74 static const char *rust_copy_name (const char *, int);
  75 static struct stoken rust_concat3 (const char *, const char *, const char *);
  76 static struct stoken make_stoken (const char *);
  77 static struct block_symbol rust_lookup_symbol (const char *name,
  78                                                const struct block *block,
  79                                                const domain_enum domain);
  80 static struct type *rust_lookup_type (const char *name,
  81                                       const struct block *block);
  82 static struct type *rust_type (const char *name);
  83
  84 static const struct rust_op *crate_name (const struct rust_op *name);
  85 static const struct rust_op *super_name (const struct rust_op *name,
  86                                          unsigned int n_supers);
  87
  88 static const struct rust_op *ast_operation (enum exp_opcode opcode,
  89                                             const struct rust_op *left,
  90                                             const struct rust_op *right);
  91 static const struct rust_op *ast_compound_assignment
  92   (enum exp_opcode opcode, const struct rust_op *left,
  93    const struct rust_op *rust_op);
  94 static const struct rust_op *ast_literal (struct typed_val_int val);
  95 static const struct rust_op *ast_dliteral (struct typed_val_float val);
  96 static const struct rust_op *ast_structop (const struct rust_op *left,
  97                                            const char *name,
  98                                            int completing);
  99 static const struct rust_op *ast_structop_anonymous
 100   (const struct rust_op *left, struct typed_val_int number);
 101 static const struct rust_op *ast_unary (enum exp_opcode opcode,
 102                                         const struct rust_op *expr);
 103 static const struct rust_op *ast_cast (const struct rust_op *expr,
 104                                        const struct rust_op *type);
 105 static const struct rust_op *ast_call_ish (enum exp_opcode opcode,
 106                                            const struct rust_op *expr,
 107                                            rust_op_vector *params);
 108 static const struct rust_op *ast_path (struct stoken name,
 109                                        rust_op_vector *params);
 110 static const struct rust_op *ast_string (struct stoken str);
 111 static const struct rust_op *ast_struct (const struct rust_op *name,
 112                                          rust_set_vector *fields);
 113 static const struct rust_op *ast_range (const struct rust_op *lhs,
 114                                         const struct rust_op *rhs);
 115 static const struct rust_op *ast_array_type (const struct rust_op *lhs,
 116                                              struct typed_val_int val);
 117 static const struct rust_op *ast_slice_type (const struct rust_op *type);
 118 static const struct rust_op *ast_reference_type (const struct rust_op *type);
 119 static const struct rust_op *ast_pointer_type (const struct rust_op *type,
 120                                                int is_mut);
 121 static const struct rust_op *ast_function_type (const struct rust_op *result,
 122                                                 rust_op_vector *params);
 123 static const struct rust_op *ast_tuple_type (rust_op_vector *params);
 124
 125 /* The current rust parser.  */
 126
 127 struct rust_parser;
 128 static rust_parser *current_parser;
 129
 130 /* A regular expression for matching Rust numbers.  This is split up
 131    since it is very long and this gives us a way to comment the
 132    sections.  */
 133
 134 static const char *number_regex_text =
 135   /* subexpression 1: allows use of alternation, otherwise uninteresting */
 136   "^("
 137   /* First comes floating point.  */
 138   /* Recognize number after the decimal point, with optional
 139      exponent and optional type suffix.
 140      subexpression 2: allows "?", otherwise uninteresting
 141      subexpression 3: if present, type suffix
 142   */
 143   "[0-9][0-9_]*\\.[0-9][0-9_]*([eE][-+]?[0-9][0-9_]*)?(f32|f64)?"
 144 #define FLOAT_TYPE1 3
 145   "|"
 146   /* Recognize exponent without decimal point, with optional type
 147      suffix.
 148      subexpression 4: if present, type suffix
 149   */
 150 #define FLOAT_TYPE2 4
 151   "[0-9][0-9_]*[eE][-+]?[0-9][0-9_]*(f32|f64)?"
 152   "|"
 153   /* "23." is a valid floating point number, but "23.e5" and
 154      "23.f32" are not.  So, handle the trailing-. case
 155      separately.  */
 156   "[0-9][0-9_]*\\."
 157   "|"
 158   /* Finally come integers.
 159      subexpression 5: text of integer
 160      subexpression 6: if present, type suffix
 161      subexpression 7: allows use of alternation, otherwise uninteresting
 162   */
 163 #define INT_TEXT 5
 164 #define INT_TYPE 6
 165   "(0x[a-fA-F0-9_]+|0o[0-7_]+|0b[01_]+|[0-9][0-9_]*)"
 166   "([iu](size|8|16|32|64))?"
 167   ")";
 168 /* The number of subexpressions to allocate space for, including the
 169    "0th" whole match subexpression.  */
 170 #define NUM_SUBEXPRESSIONS 8
 171
 172 /* The compiled number-matching regex.  */
 173
 174 static regex_t number_regex;
 175
 176 /* Obstack for data temporarily allocated during parsing.  Points to
 177    the obstack in the rust_parser, or to a temporary obstack during
 178    unit testing.  */
 179
 180 static auto_obstack *work_obstack;
 181
 182 /* An instance of this is created before parsing, and destroyed when
 183    parsing is finished.  */
 184
 185 struct rust_parser
 186 {
 187   rust_parser (struct parser_state *state)
 188     : rust_ast (nullptr),
 189       pstate (state)
 190   {
 191     gdb_assert (current_parser == nullptr);
 192     current_parser = this;
 193     work_obstack = &obstack;
 194   }
 195
 196   ~rust_parser ()
 197   {
 198     /* Clean up the globals we set.  */
 199     current_parser = nullptr;
 200     work_obstack = nullptr;
 201   }
 202
 203   /* Create a new rust_set_vector.  The storage for the new vector is
 204      managed by this class.  */
 205   rust_set_vector *new_set_vector ()
 206   {
 207     rust_set_vector *result = new rust_set_vector;
 208     set_vectors.push_back (std::unique_ptr<rust_set_vector> (result));
 209     return result;
 210   }
 211
 212   /* Create a new rust_ops_vector.  The storage for the new vector is
 213      managed by this class.  */
 214   rust_op_vector *new_op_vector ()
 215   {
 216     rust_op_vector *result = new rust_op_vector;
 217     op_vectors.push_back (std::unique_ptr<rust_op_vector> (result));
 218     return result;
 219   }
 220
 221   /* Return the parser's language.  */
 222   const struct language_defn *language () const
 223   {
 224     return parse_language (pstate);
 225   }
 226
 227   /* Return the parser's gdbarch.  */
 228   struct gdbarch *arch () const
 229   {
 230     return parse_gdbarch (pstate);
 231   }
 232
 233   /* A pointer to this is installed globally.  */
 234   auto_obstack obstack;
 235
 236   /* Result of parsing.  Points into obstack.  */
 237   const struct rust_op *rust_ast;
 238
 239   /* This keeps track of the various vectors we allocate.  */
 240   std::vector<std::unique_ptr<rust_set_vector>> set_vectors;
 241   std::vector<std::unique_ptr<rust_op_vector>> op_vectors;
 242
 243   /* The parser state gdb gave us.  */
 244   struct parser_state *pstate;
 245 };
 246
 247 %}
 248
 249 %union
 250 {
 251   /* A typed integer constant.  */
 252   struct typed_val_int typed_val_int;
 253
 254   /* A typed floating point constant.  */
 255   struct typed_val_float typed_val_float;
 256
 257   /* An identifier or string.  */
 258   struct stoken sval;
 259
 260   /* A token representing an opcode, like "==".  */
 261   enum exp_opcode opcode;
 262
 263   /* A list of expressions; for example, the arguments to a function
 264      call.  */
 265   rust_op_vector *params;
 266
 267   /* A list of field initializers.  */
 268   rust_set_vector *field_inits;
 269
 270   /* A single field initializer.  */
 271   struct set_field one_field_init;
 272
 273   /* An expression.  */
 274   const struct rust_op *op;
 275
 276   /* A plain integer, for example used to count the number of
 277      "super::" prefixes on a path.  */
 278   unsigned int depth;
 279 }
 280
 281 %{
 282
 283   /* Rust AST operations.  We build a tree of these; then lower them
 284      to gdb expressions when parsing has completed.  */
 285
 286 struct rust_op
 287 {
 288   /* The opcode.  */
 289   enum exp_opcode opcode;
 290   /* If OPCODE is OP_TYPE, then this holds information about what type
 291      is described by this node.  */
 292   enum type_code typecode;
 293   /* Indicates whether OPCODE actually represents a compound
 294      assignment.  For example, if OPCODE is GTGT and this is false,
 295      then this rust_op represents an ordinary ">>"; but if this is
 296      true, then this rust_op represents ">>=".  Unused in other
 297      cases.  */
 298   unsigned int compound_assignment : 1;
 299   /* Only used by a field expression; if set, indicates that the field
 300      name occurred at the end of the expression and is eligible for
 301      completion.  */
 302   unsigned int completing : 1;
 303   /* Operands of expression.  Which one is used and how depends on the
 304      particular opcode.  */
 305   RUSTSTYPE left;
 306   RUSTSTYPE right;
 307 };
 308
 309 %}
 310
 311 %token <sval> GDBVAR
 312 %token <sval> IDENT
 313 %token <sval> COMPLETE
 314 %token <typed_val_int> INTEGER
 315 %token <typed_val_int> DECIMAL_INTEGER
 316 %token <sval> STRING
 317 %token <sval> BYTESTRING
 318 %token <typed_val_float> FLOAT
 319 %token <opcode> COMPOUND_ASSIGN
 320
 321 /* Keyword tokens.  */
 322 %token <voidval> KW_AS
 323 %token <voidval> KW_IF
 324 %token <voidval> KW_TRUE
 325 %token <voidval> KW_FALSE
 326 %token <voidval> KW_SUPER
 327 %token <voidval> KW_SELF
 328 %token <voidval> KW_MUT
 329 %token <voidval> KW_EXTERN
 330 %token <voidval> KW_CONST
 331 %token <voidval> KW_FN
 332 %token <voidval> KW_SIZEOF
 333
 334 /* Operator tokens.  */
 335 %token <voidval> DOTDOT
 336 %token <voidval> OROR
 337 %token <voidval> ANDAND
 338 %token <voidval> EQEQ
 339 %token <voidval> NOTEQ
 340 %token <voidval> LTEQ
 341 %token <voidval> GTEQ
 342 %token <voidval> LSH RSH
 343 %token <voidval> COLONCOLON
 344 %token <voidval> ARROW
 345
 346 %type <op> type
 347 %type <op> path_for_expr
 348 %type <op> identifier_path_for_expr
 349 %type <op> path_for_type
 350 %type <op> identifier_path_for_type
 351 %type <op> just_identifiers_for_type
 352
 353 %type <params> maybe_type_list
 354 %type <params> type_list
 355
 356 %type <depth> super_path
 357
 358 %type <op> literal
 359 %type <op> expr
 360 %type <op> field_expr
 361 %type <op> idx_expr
 362 %type <op> unop_expr
 363 %type <op> binop_expr
 364 %type <op> binop_expr_expr
 365 %type <op> type_cast_expr
 366 %type <op> assignment_expr
 367 %type <op> compound_assignment_expr
 368 %type <op> paren_expr
 369 %type <op> call_expr
 370 %type <op> path_expr
 371 %type <op> tuple_expr
 372 %type <op> unit_expr
 373 %type <op> struct_expr
 374 %type <op> array_expr
 375 %type <op> range_expr
 376
 377 %type <params> expr_list
 378 %type <params> maybe_expr_list
 379 %type <params> paren_expr_list
 380
 381 %type <field_inits> struct_expr_list
 382 %type <one_field_init> struct_expr_tail
 383
 384 /* Precedence.  */
 385 %nonassoc DOTDOT
 386 %right '=' COMPOUND_ASSIGN
 387 %left OROR
 388 %left ANDAND
 389 %nonassoc EQEQ NOTEQ '<' '>' LTEQ GTEQ
 390 %left '|'
 391 %left '^'
 392 %left '&'
 393 %left LSH RSH
 394 %left '@'
 395 %left '+' '-'
 396 %left '*' '/' '%'
 397 /* These could be %precedence in Bison, but that isn't a yacc
 398    feature.  */
 399 %left KW_AS
 400 %left UNARY
 401 %left '[' '.' '('
 402
 403 %%
 404
 405 start:
 406         expr
 407                 {
 408                   /* If we are completing and see a valid parse,
 409                      rust_ast will already have been set.  */
 410                   if (current_parser->rust_ast == NULL)
 411                     current_parser->rust_ast = $1;
 412                 }
 413 ;
 414
 415 /* Note that the Rust grammar includes a method_call_expr, but we
 416    handle this differently, to avoid a shift/reduce conflict with
 417    call_expr.  */
 418 expr:
 419         literal
 420 |       path_expr
 421 |       tuple_expr
 422 |       unit_expr
 423 |       struct_expr
 424 |       field_expr
 425 |       array_expr
 426 |       idx_expr
 427 |       range_expr
 428 |       unop_expr /* Must precede call_expr because of ambiguity with sizeof.  */
 429 |       binop_expr
 430 |       paren_expr
 431 |       call_expr
 432 ;
 433
 434 tuple_expr:
 435         '(' expr ',' maybe_expr_list ')'
 436                 {
 437                   $4->push_back ($2);
 438                   error (_("Tuple expressions not supported yet"));
 439                 }
 440 ;
 441
 442 unit_expr:
 443         '(' ')'
 444                 {
 445                   struct typed_val_int val;
 446
 447                   val.type
 448                     = language_lookup_primitive_type (current_parser->language (),
 449                                                       current_parser->arch (),
 450                                                       "()");
 451                   val.val = 0;
 452                   $$ = ast_literal (val);
 453                 }
 454 ;
 455
 456 /* To avoid a shift/reduce conflict with call_expr, we don't handle
 457    tuple struct expressions here, but instead when examining the
 458    AST.  */
 459 struct_expr:
 460         path_for_expr '{' struct_expr_list '}'
 461                 { $$ = ast_struct ($1, $3); }
 462 ;
 463
 464 struct_expr_tail:
 465         DOTDOT expr
 466                 {
 467                   struct set_field sf;
 468
 469                   sf.name.ptr = NULL;
 470                   sf.name.length = 0;
 471                   sf.init = $2;
 472
 473                   $$ = sf;
 474                 }
 475 |       IDENT ':' expr
 476                 {
 477                   struct set_field sf;
 478
 479                   sf.name = $1;
 480                   sf.init = $3;
 481                   $$ = sf;
 482                 }
 483 ;
 484
 485 struct_expr_list:
 486         /* %empty */
 487                 {
 488                   $$ = current_parser->new_set_vector ();
 489                 }
 490 |       struct_expr_tail
 491                 {
 492                   rust_set_vector *result = current_parser->new_set_vector ();
 493                   result->push_back ($1);
 494                   $$ = result;
 495                 }
 496 |       IDENT ':' expr ',' struct_expr_list
 497                 {
 498                   struct set_field sf;
 499
 500                   sf.name = $1;
 501                   sf.init = $3;
 502                   $5->push_back (sf);
 503                   $$ = $5;
 504                 }
 505 ;
 506
 507 array_expr:
 508         '[' KW_MUT expr_list ']'
 509                 { $$ = ast_call_ish (OP_ARRAY, NULL, $3); }
 510 |       '[' expr_list ']'
 511                 { $$ = ast_call_ish (OP_ARRAY, NULL, $2); }
 512 |       '[' KW_MUT expr ';' expr ']'
 513                 { $$ = ast_operation (OP_RUST_ARRAY, $3, $5); }
 514 |       '[' expr ';' expr ']'
 515                 { $$ = ast_operation (OP_RUST_ARRAY, $2, $4); }
 516 ;
 517
 518 range_expr:
 519         expr DOTDOT
 520                 { $$ = ast_range ($1, NULL); }
 521 |       expr DOTDOT expr
 522                 { $$ = ast_range ($1, $3); }
 523 |       DOTDOT expr
 524                 { $$ = ast_range (NULL, $2); }
 525 |       DOTDOT
 526                 { $$ = ast_range (NULL, NULL); }
 527 ;
 528
 529 literal:
 530         INTEGER
 531                 { $$ = ast_literal ($1); }
 532 |       DECIMAL_INTEGER
 533                 { $$ = ast_literal ($1); }
 534 |       FLOAT
 535                 { $$ = ast_dliteral ($1); }
 536 |       STRING
 537                 {
 538                   const struct rust_op *str = ast_string ($1);
 539                   struct set_field field;
 540                   struct typed_val_int val;
 541                   struct stoken token;
 542
 543                   rust_set_vector *fields = current_parser->new_set_vector ();
 544
 545                   /* Wrap the raw string in the &str struct.  */
 546                   field.name.ptr = "data_ptr";
 547                   field.name.length = strlen (field.name.ptr);
 548                   field.init = ast_unary (UNOP_ADDR, ast_string ($1));
 549                   fields->push_back (field);
 550
 551                   val.type = rust_type ("usize");
 552                   val.val = $1.length;
 553
 554                   field.name.ptr = "length";
 555                   field.name.length = strlen (field.name.ptr);
 556                   field.init = ast_literal (val);
 557                   fields->push_back (field);
 558
 559                   token.ptr = "&str";
 560                   token.length = strlen (token.ptr);
 561                   $$ = ast_struct (ast_path (token, NULL), fields);
 562                 }
 563 |       BYTESTRING
 564                 { $$ = ast_string ($1); }
 565 |       KW_TRUE
 566                 {
 567                   struct typed_val_int val;
 568
 569                   val.type = language_bool_type (current_parser->language (),
 570                                                  current_parser->arch ());
 571                   val.val = 1;
 572                   $$ = ast_literal (val);
 573                 }
 574 |       KW_FALSE
 575                 {
 576                   struct typed_val_int val;
 577
 578                   val.type = language_bool_type (current_parser->language (),
 579                                                  current_parser->arch ());
 580                   val.val = 0;
 581                   $$ = ast_literal (val);
 582                 }
 583 ;
 584
 585 field_expr:
 586         expr '.' IDENT
 587                 { $$ = ast_structop ($1, $3.ptr, 0); }
 588 |       expr '.' COMPLETE
 589                 {
 590                   $$ = ast_structop ($1, $3.ptr, 1);
 591                   current_parser->rust_ast = $$;
 592                 }
 593 |       expr '.' DECIMAL_INTEGER
 594                 { $$ = ast_structop_anonymous ($1, $3); }
 595 ;
 596
 597 idx_expr:
 598         expr '[' expr ']'
 599                 { $$ = ast_operation (BINOP_SUBSCRIPT, $1, $3); }
 600 ;
 601
 602 unop_expr:
 603         '+' expr        %prec UNARY
 604                 { $$ = ast_unary (UNOP_PLUS, $2); }
 605
 606 |       '-' expr        %prec UNARY
 607                 { $$ = ast_unary (UNOP_NEG, $2); }
 608
 609 |       '!' expr        %prec UNARY
 610                 {
 611                   /* Note that we provide a Rust-specific evaluator
 612                      override for UNOP_COMPLEMENT, so it can do the
 613                      right thing for both bool and integral
 614                      values.  */
 615                   $$ = ast_unary (UNOP_COMPLEMENT, $2);
 616                 }
 617
 618 |       '*' expr        %prec UNARY
 619                 { $$ = ast_unary (UNOP_IND, $2); }
 620
 621 |       '&' expr        %prec UNARY
 622                 { $$ = ast_unary (UNOP_ADDR, $2); }
 623
 624 |       '&' KW_MUT expr %prec UNARY
 625                 { $$ = ast_unary (UNOP_ADDR, $3); }
 626 |   KW_SIZEOF '(' expr ')' %prec UNARY
 627         { $$ = ast_unary (UNOP_SIZEOF, $3); }
 628 ;
 629
 630 binop_expr:
 631         binop_expr_expr
 632 |       type_cast_expr
 633 |       assignment_expr
 634 |       compound_assignment_expr
 635 ;
 636
 637 binop_expr_expr:
 638         expr '*' expr
 639                 { $$ = ast_operation (BINOP_MUL, $1, $3); }
 640
 641 |       expr '@' expr
 642                 { $$ = ast_operation (BINOP_REPEAT, $1, $3); }
 643
 644 |       expr '/' expr
 645                 { $$ = ast_operation (BINOP_DIV, $1, $3); }
 646
 647 |       expr '%' expr
 648                 { $$ = ast_operation (BINOP_REM, $1, $3); }
 649
 650 |       expr '<' expr
 651                 { $$ = ast_operation (BINOP_LESS, $1, $3); }
 652
 653 |       expr '>' expr
 654                 { $$ = ast_operation (BINOP_GTR, $1, $3); }
 655
 656 |       expr '&' expr
 657                 { $$ = ast_operation (BINOP_BITWISE_AND, $1, $3); }
 658
 659 |       expr '|' expr
 660                 { $$ = ast_operation (BINOP_BITWISE_IOR, $1, $3); }
 661
 662 |       expr '^' expr
 663                 { $$ = ast_operation (BINOP_BITWISE_XOR, $1, $3); }
 664
 665 |       expr '+' expr
 666                 { $$ = ast_operation (BINOP_ADD, $1, $3); }
 667
 668 |       expr '-' expr
 669                 { $$ = ast_operation (BINOP_SUB, $1, $3); }
 670
 671 |       expr OROR expr
 672                 { $$ = ast_operation (BINOP_LOGICAL_OR, $1, $3); }
 673
 674 |       expr ANDAND expr
 675                 { $$ = ast_operation (BINOP_LOGICAL_AND, $1, $3); }
 676
 677 |       expr EQEQ expr
 678                 { $$ = ast_operation (BINOP_EQUAL, $1, $3); }
 679
 680 |       expr NOTEQ expr
 681                 { $$ = ast_operation (BINOP_NOTEQUAL, $1, $3); }
 682
 683 |       expr LTEQ expr
 684                 { $$ = ast_operation (BINOP_LEQ, $1, $3); }
 685
 686 |       expr GTEQ expr
 687                 { $$ = ast_operation (BINOP_GEQ, $1, $3); }
 688
 689 |       expr LSH expr
 690                 { $$ = ast_operation (BINOP_LSH, $1, $3); }
 691
 692 |       expr RSH expr
 693                 { $$ = ast_operation (BINOP_RSH, $1, $3); }
 694 ;
 695
 696 type_cast_expr:
 697         expr KW_AS type
 698                 { $$ = ast_cast ($1, $3); }
 699 ;
 700
 701 assignment_expr:
 702         expr '=' expr
 703                 { $$ = ast_operation (BINOP_ASSIGN, $1, $3); }
 704 ;
 705
 706 compound_assignment_expr:
 707         expr COMPOUND_ASSIGN expr
 708                 { $$ = ast_compound_assignment ($2, $1, $3); }
 709
 710 ;
 711
 712 paren_expr:
 713         '(' expr ')'
 714                 { $$ = $2; }
 715 ;
 716
 717 expr_list:
 718         expr
 719                 {
 720                   $$ = current_parser->new_op_vector ();
 721                   $$->push_back ($1);
 722                 }
 723 |       expr_list ',' expr
 724                 {
 725                   $1->push_back ($3);
 726                   $$ = $1;
 727                 }
 728 ;
 729
 730 maybe_expr_list:
 731         /* %empty */
 732                 {
 733                   /* The result can't be NULL.  */
 734                   $$ = current_parser->new_op_vector ();
 735                 }
 736 |       expr_list
 737                 { $$ = $1; }
 738 ;
 739
 740 paren_expr_list:
 741         '('
 742         maybe_expr_list
 743         ')'
 744                 { $$ = $2; }
 745 ;
 746
 747 call_expr:
 748         expr paren_expr_list
 749                 { $$ = ast_call_ish (OP_FUNCALL, $1, $2); }
 750 ;
 751
 752 maybe_self_path:
 753         /* %empty */
 754 |       KW_SELF COLONCOLON
 755 ;
 756
 757 super_path:
 758         KW_SUPER COLONCOLON
 759                 { $$ = 1; }
 760 |       super_path KW_SUPER COLONCOLON
 761                 { $$ = $1 + 1; }
 762 ;
 763
 764 path_expr:
 765         path_for_expr
 766                 { $$ = $1; }
 767 |       GDBVAR
 768                 { $$ = ast_path ($1, NULL); }
 769 |       KW_SELF
 770                 { $$ = ast_path (make_stoken ("self"), NULL); }
 771 ;
 772
 773 path_for_expr:
 774         identifier_path_for_expr
 775 |       KW_SELF COLONCOLON identifier_path_for_expr
 776                 { $$ = super_name ($3, 0); }
 777 |       maybe_self_path super_path identifier_path_for_expr
 778                 { $$ = super_name ($3, $2); }
 779 |       COLONCOLON identifier_path_for_expr
 780                 { $$ = crate_name ($2); }
 781 |       KW_EXTERN identifier_path_for_expr
 782                 {
 783                   /* This is a gdb extension to make it possible to
 784                      refer to items in other crates.  It just bypasses
 785                      adding the current crate to the front of the
 786                      name.  */
 787                   $$ = ast_path (rust_concat3 ("::", $2->left.sval.ptr, NULL),
 788                                  $2->right.params);
 789                 }
 790 ;
 791
 792 identifier_path_for_expr:
 793         IDENT
 794                 { $$ = ast_path ($1, NULL); }
 795 |       identifier_path_for_expr COLONCOLON IDENT
 796                 {
 797                   $$ = ast_path (rust_concat3 ($1->left.sval.ptr, "::",
 798                                                $3.ptr),
 799                                  NULL);
 800                 }
 801 |       identifier_path_for_expr COLONCOLON '<' type_list '>'
 802                 { $$ = ast_path ($1->left.sval, $4); }
 803 |       identifier_path_for_expr COLONCOLON '<' type_list RSH
 804                 {
 805                   $$ = ast_path ($1->left.sval, $4);
 806                   rust_push_back ('>');
 807                 }
 808 ;
 809
 810 path_for_type:
 811         identifier_path_for_type
 812 |       KW_SELF COLONCOLON identifier_path_for_type
 813                 { $$ = super_name ($3, 0); }
 814 |       maybe_self_path super_path identifier_path_for_type
 815                 { $$ = super_name ($3, $2); }
 816 |       COLONCOLON identifier_path_for_type
 817                 { $$ = crate_name ($2); }
 818 |       KW_EXTERN identifier_path_for_type
 819                 {
 820                   /* This is a gdb extension to make it possible to
 821                      refer to items in other crates.  It just bypasses
 822                      adding the current crate to the front of the
 823                      name.  */
 824                   $$ = ast_path (rust_concat3 ("::", $2->left.sval.ptr, NULL),
 825                                  $2->right.params);
 826                 }
 827 ;
 828
 829 just_identifiers_for_type:
 830         IDENT
 831                 { $$ = ast_path ($1, NULL); }
 832 |       just_identifiers_for_type COLONCOLON IDENT
 833                 {
 834                   $$ = ast_path (rust_concat3 ($1->left.sval.ptr, "::",
 835                                                $3.ptr),
 836                                  NULL);
 837                 }
 838 ;
 839
 840 identifier_path_for_type:
 841         just_identifiers_for_type
 842 |       just_identifiers_for_type '<' type_list '>'
 843                 { $$ = ast_path ($1->left.sval, $3); }
 844 |       just_identifiers_for_type '<' type_list RSH
 845                 {
 846                   $$ = ast_path ($1->left.sval, $3);
 847                   rust_push_back ('>');
 848                 }
 849 ;
 850
 851 type:
 852         path_for_type
 853 |       '[' type ';' INTEGER ']'
 854                 { $$ = ast_array_type ($2, $4); }
 855 |       '[' type ';' DECIMAL_INTEGER ']'
 856                 { $$ = ast_array_type ($2, $4); }
 857 |       '&' '[' type ']'
 858                 { $$ = ast_slice_type ($3); }
 859 |       '&' type
 860                 { $$ = ast_reference_type ($2); }
 861 |       '*' KW_MUT type
 862                 { $$ = ast_pointer_type ($3, 1); }
 863 |       '*' KW_CONST type
 864                 { $$ = ast_pointer_type ($3, 0); }
 865 |       KW_FN '(' maybe_type_list ')' ARROW type
 866                 { $$ = ast_function_type ($6, $3); }
 867 |       '(' maybe_type_list ')'
 868                 { $$ = ast_tuple_type ($2); }
 869 ;
 870
 871 maybe_type_list:
 872         /* %empty */
 873                 { $$ = NULL; }
 874 |       type_list
 875                 { $$ = $1; }
 876 ;
 877
 878 type_list:
 879         type
 880                 {
 881                   rust_op_vector *result = current_parser->new_op_vector ();
 882                   result->push_back ($1);
 883                   $$ = result;
 884                 }
 885 |       type_list ',' type
 886                 {
 887                   $1->push_back ($3);
 888                   $$ = $1;
 889                 }
 890 ;
 891
 892 %%
 893
 894 /* A struct of this type is used to describe a token.  */
 895
 896 struct token_info
 897 {
 898   const char *name;
 899   int value;
 900   enum exp_opcode opcode;
 901 };
 902
 903 /* Identifier tokens.  */
 904
 905 static const struct token_info identifier_tokens[] =
 906 {
 907   { "as", KW_AS, OP_NULL },
 908   { "false", KW_FALSE, OP_NULL },
 909   { "if", 0, OP_NULL },
 910   { "mut", KW_MUT, OP_NULL },
 911   { "const", KW_CONST, OP_NULL },
 912   { "self", KW_SELF, OP_NULL },
 913   { "super", KW_SUPER, OP_NULL },
 914   { "true", KW_TRUE, OP_NULL },
 915   { "extern", KW_EXTERN, OP_NULL },
 916   { "fn", KW_FN, OP_NULL },
 917   { "sizeof", KW_SIZEOF, OP_NULL },
 918 };
 919
 920 /* Operator tokens, sorted longest first.  */
 921
 922 static const struct token_info operator_tokens[] =
 923 {
 924   { ">>=", COMPOUND_ASSIGN, BINOP_RSH },
 925   { "<<=", COMPOUND_ASSIGN, BINOP_LSH },
 926
 927   { "<<", LSH, OP_NULL },
 928   { ">>", RSH, OP_NULL },
 929   { "&&", ANDAND, OP_NULL },
 930   { "||", OROR, OP_NULL },
 931   { "==", EQEQ, OP_NULL },
 932   { "!=", NOTEQ, OP_NULL },
 933   { "<=", LTEQ, OP_NULL },
 934   { ">=", GTEQ, OP_NULL },
 935   { "+=", COMPOUND_ASSIGN, BINOP_ADD },
 936   { "-=", COMPOUND_ASSIGN, BINOP_SUB },
 937   { "*=", COMPOUND_ASSIGN, BINOP_MUL },
 938   { "/=", COMPOUND_ASSIGN, BINOP_DIV },
 939   { "%=", COMPOUND_ASSIGN, BINOP_REM },
 940   { "&=", COMPOUND_ASSIGN, BINOP_BITWISE_AND },
 941   { "|=", COMPOUND_ASSIGN, BINOP_BITWISE_IOR },
 942   { "^=", COMPOUND_ASSIGN, BINOP_BITWISE_XOR },
 943
 944   { "::", COLONCOLON, OP_NULL },
 945   { "..", DOTDOT, OP_NULL },
 946   { "->", ARROW, OP_NULL }
 947 };
 948
 949 /* Helper function to copy to the name obstack.  */
 950
 951 static const char *
 952 rust_copy_name (const char *name, int len)
 953 {
 954   return (const char *) obstack_copy0 (work_obstack, name, len);
 955 }
 956
 957 /* Helper function to make an stoken from a C string.  */
 958
 959 static struct stoken
 960 make_stoken (const char *p)
 961 {
 962   struct stoken result;
 963
 964   result.ptr = p;
 965   result.length = strlen (result.ptr);
 966   return result;
 967 }
 968
 969 /* Helper function to concatenate three strings on the name
 970    obstack.  */
 971
 972 static struct stoken
 973 rust_concat3 (const char *s1, const char *s2, const char *s3)
 974 {
 975   return make_stoken (obconcat (work_obstack, s1, s2, s3, (char *) NULL));
 976 }
 977
 978 /* Return an AST node referring to NAME, but relative to the crate's
 979    name.  */
 980
 981 static const struct rust_op *
 982 crate_name (const struct rust_op *name)
 983 {
 984   std::string crate = rust_crate_for_block (expression_context_block);
 985   struct stoken result;
 986
 987   gdb_assert (name->opcode == OP_VAR_VALUE);
 988
 989   if (crate.empty ())
 990     error (_("Could not find crate for current location"));
 991   result = make_stoken (obconcat (work_obstack, "::", crate.c_str (), "::",
 992                                   name->left.sval.ptr, (char *) NULL));
 993
 994   return ast_path (result, name->right.params);
 995 }
 996
 997 /* Create an AST node referring to a "super::" qualified name.  IDENT
 998    is the base name and N_SUPERS is how many "super::"s were
 999    provided.  N_SUPERS can be zero.  */
1000
1001 static const struct rust_op *
1002 super_name (const struct rust_op *ident, unsigned int n_supers)
1003 {
1004   const char *scope = block_scope (expression_context_block);
1005   int offset;
1006
1007   gdb_assert (ident->opcode == OP_VAR_VALUE);
1008
1009   if (scope[0] == '\0')
1010     error (_("Couldn't find namespace scope for self::"));
1011
1012   if (n_supers > 0)
1013     {
1014       int len;
1015       std::vector<int> offsets;
1016       unsigned int current_len;
1017
1018       current_len = cp_find_first_component (scope);
1019       while (scope[current_len] != '\0')
1020         {
1021           offsets.push_back (current_len);
1022           gdb_assert (scope[current_len] == ':');
1023           /* The "::".  */
1024           current_len += 2;
1025           current_len += cp_find_first_component (scope
1026                                                   + current_len);
1027         }
1028
1029       len = offsets.size ();
1030       if (n_supers >= len)
1031         error (_("Too many super:: uses from '%s'"), scope);
1032
1033       offset = offsets[len - n_supers];
1034     }
1035   else
1036     offset = strlen (scope);
1037
1038   obstack_grow (work_obstack, "::", 2);
1039   obstack_grow (work_obstack, scope, offset);
1040   obstack_grow (work_obstack, "::", 2);
1041   obstack_grow0 (work_obstack, ident->left.sval.ptr, ident->left.sval.length);
1042
1043   return ast_path (make_stoken ((const char *) obstack_finish (work_obstack)),
1044                    ident->right.params);
1045 }
1046
1047 /* A helper that updates innermost_block as appropriate.  */
1048
1049 static void
1050 update_innermost_block (struct block_symbol sym)
1051 {
1052   if (symbol_read_needs_frame (sym.symbol)
1053       && (innermost_block == NULL
1054           || contained_in (sym.block, innermost_block)))
1055     innermost_block = sym.block;
1056 }
1057
1058 /* A helper to look up a Rust type, or fail.  This only works for
1059    types defined by rust_language_arch_info.  */
1060
1061 static struct type *
1062 rust_type (const char *name)
1063 {
1064   struct type *type;
1065
1066   type = language_lookup_primitive_type (current_parser->language (),
1067                                          current_parser->arch (),
1068                                          name);
1069   if (type == NULL)
1070     error (_("Could not find Rust type %s"), name);
1071   return type;
1072 }
1073
1074 /* Lex a hex number with at least MIN digits and at most MAX
1075    digits.  */
1076
1077 static uint32_t
1078 lex_hex (int min, int max)
1079 {
1080   uint32_t result = 0;
1081   int len = 0;
1082   /* We only want to stop at MAX if we're lexing a byte escape.  */
1083   int check_max = min == max;
1084
1085   while ((check_max ? len <= max : 1)
1086          && ((lexptr[0] >= 'a' && lexptr[0] <= 'f')
1087              || (lexptr[0] >= 'A' && lexptr[0] <= 'F')
1088              || (lexptr[0] >= '0' && lexptr[0] <= '9')))
1089     {
1090       result *= 16;
1091       if (lexptr[0] >= 'a' && lexptr[0] <= 'f')
1092         result = result + 10 + lexptr[0] - 'a';
1093       else if (lexptr[0] >= 'A' && lexptr[0] <= 'F')
1094         result = result + 10 + lexptr[0] - 'A';
1095       else
1096         result = result + lexptr[0] - '0';
1097       ++lexptr;
1098       ++len;
1099     }
1100
1101   if (len < min)
1102     error (_("Not enough hex digits seen"));
1103   if (len > max)
1104     {
1105       gdb_assert (min != max);
1106       error (_("Overlong hex escape"));
1107     }
1108
1109   return result;
1110 }
1111
1112 /* Lex an escape.  IS_BYTE is true if we're lexing a byte escape;
1113    otherwise we're lexing a character escape.  */
1114
1115 static uint32_t
1116 lex_escape (int is_byte)
1117 {
1118   uint32_t result;
1119
1120   gdb_assert (lexptr[0] == '\\');
1121   ++lexptr;
1122   switch (lexptr[0])
1123     {
1124     case 'x':
1125       ++lexptr;
1126       result = lex_hex (2, 2);
1127       break;
1128
1129     case 'u':
1130       if (is_byte)
1131         error (_("Unicode escape in byte literal"));
1132       ++lexptr;
1133       if (lexptr[0] != '{')
1134         error (_("Missing '{' in Unicode escape"));
1135       ++lexptr;
1136       result = lex_hex (1, 6);
1137       /* Could do range checks here.  */
1138       if (lexptr[0] != '}')
1139         error (_("Missing '}' in Unicode escape"));
1140       ++lexptr;
1141       break;
1142
1143     case 'n':
1144       result = '\n';
1145       ++lexptr;
1146       break;
1147     case 'r':
1148       result = '\r';
1149       ++lexptr;
1150       break;
1151     case 't':
1152       result = '\t';
1153       ++lexptr;
1154       break;
1155     case '\\':
1156       result = '\\';
1157       ++lexptr;
1158       break;
1159     case '0':
1160       result = '\0';
1161       ++lexptr;
1162       break;
1163     case '\'':
1164       result = '\'';
1165       ++lexptr;
1166       break;
1167     case '"':
1168       result = '"';
1169       ++lexptr;
1170       break;
1171
1172     default:
1173       error (_("Invalid escape \\%c in literal"), lexptr[0]);
1174     }
1175
1176   return result;
1177 }
1178
1179 /* Lex a character constant.  */
1180
1181 static int
1182 lex_character (void)
1183 {
1184   int is_byte = 0;
1185   uint32_t value;
1186
1187   if (lexptr[0] == 'b')
1188     {
1189       is_byte = 1;
1190       ++lexptr;
1191     }
1192   gdb_assert (lexptr[0] == '\'');
1193   ++lexptr;
1194   /* This should handle UTF-8 here.  */
1195   if (lexptr[0] == '\\')
1196     value = lex_escape (is_byte);
1197   else
1198     {
1199       value = lexptr[0] & 0xff;
1200       ++lexptr;
1201     }
1202
1203   if (lexptr[0] != '\'')
1204     error (_("Unterminated character literal"));
1205   ++lexptr;
1206
1207   rustyylval.typed_val_int.val = value;
1208   rustyylval.typed_val_int.type = rust_type (is_byte ? "u8" : "char");
1209
1210   return INTEGER;
1211 }
1212
1213 /* Return the offset of the double quote if STR looks like the start
1214    of a raw string, or 0 if STR does not start a raw string.  */
1215
1216 static int
1217 starts_raw_string (const char *str)
1218 {
1219   const char *save = str;
1220
1221   if (str[0] != 'r')
1222     return 0;
1223   ++str;
1224   while (str[0] == '#')
1225     ++str;
1226   if (str[0] == '"')
1227     return str - save;
1228   return 0;
1229 }
1230
1231 /* Return true if STR looks like the end of a raw string that had N
1232    hashes at the start.  */
1233
1234 static bool
1235 ends_raw_string (const char *str, int n)
1236 {
1237   int i;
1238
1239   gdb_assert (str[0] == '"');
1240   for (i = 0; i < n; ++i)
1241     if (str[i + 1] != '#')
1242       return false;
1243   return true;
1244 }
1245
1246 /* Lex a string constant.  */
1247
1248 static int
1249 lex_string (void)
1250 {
1251   int is_byte = lexptr[0] == 'b';
1252   int raw_length;
1253
1254   if (is_byte)
1255     ++lexptr;
1256   raw_length = starts_raw_string (lexptr);
1257   lexptr += raw_length;
1258   gdb_assert (lexptr[0] == '"');
1259   ++lexptr;
1260
1261   while (1)
1262     {
1263       uint32_t value;
1264
1265       if (raw_length > 0)
1266         {
1267           if (lexptr[0] == '"' && ends_raw_string (lexptr, raw_length - 1))
1268             {
1269               /* Exit with lexptr pointing after the final "#".  */
1270               lexptr += raw_length;
1271               break;
1272             }
1273           else if (lexptr[0] == '\0')
1274             error (_("Unexpected EOF in string"));
1275
1276           value = lexptr[0] & 0xff;
1277           if (is_byte && value > 127)
1278             error (_("Non-ASCII value in raw byte string"));
1279           obstack_1grow (work_obstack, value);
1280
1281           ++lexptr;
1282         }
1283       else if (lexptr[0] == '"')
1284         {
1285           /* Make sure to skip the quote.  */
1286           ++lexptr;
1287           break;
1288         }
1289       else if (lexptr[0] == '\\')
1290         {
1291           value = lex_escape (is_byte);
1292
1293           if (is_byte)
1294             obstack_1grow (work_obstack, value);
1295           else
1296             convert_between_encodings ("UTF-32", "UTF-8", (gdb_byte *) &value,
1297                                        sizeof (value), sizeof (value),
1298                                        work_obstack, translit_none);
1299         }
1300       else if (lexptr[0] == '\0')
1301         error (_("Unexpected EOF in string"));
1302       else
1303         {
1304           value = lexptr[0] & 0xff;
1305           if (is_byte && value > 127)
1306             error (_("Non-ASCII value in byte string"));
1307           obstack_1grow (work_obstack, value);
1308           ++lexptr;
1309         }
1310     }
1311
1312   rustyylval.sval.length = obstack_object_size (work_obstack);
1313   rustyylval.sval.ptr = (const char *) obstack_finish (work_obstack);
1314   return is_byte ? BYTESTRING : STRING;
1315 }
1316
1317 /* Return true if STRING starts with whitespace followed by a digit.  */
1318
1319 static bool
1320 space_then_number (const char *string)
1321 {
1322   const char *p = string;
1323
1324   while (p[0] == ' ' || p[0] == '\t')
1325     ++p;
1326   if (p == string)
1327     return false;
1328
1329   return *p >= '0' && *p <= '9';
1330 }
1331
1332 /* Return true if C can start an identifier.  */
1333
1334 static bool
1335 rust_identifier_start_p (char c)
1336 {
1337   return ((c >= 'a' && c <= 'z')
1338           || (c >= 'A' && c <= 'Z')
1339           || c == '_'
1340           || c == '$');
1341 }
1342
1343 /* Lex an identifier.  */
1344
1345 static int
1346 lex_identifier (void)
1347 {
1348   const char *start = lexptr;
1349   unsigned int length;
1350   const struct token_info *token;
1351   int i;
1352   int is_gdb_var = lexptr[0] == '$';
1353
1354   gdb_assert (rust_identifier_start_p (lexptr[0]));
1355
1356   ++lexptr;
1357
1358   /* For the time being this doesn't handle Unicode rules.  Non-ASCII
1359      identifiers are gated anyway.  */
1360   while ((lexptr[0] >= 'a' && lexptr[0] <= 'z')
1361          || (lexptr[0] >= 'A' && lexptr[0] <= 'Z')
1362          || lexptr[0] == '_'
1363          || (is_gdb_var && lexptr[0] == '$')
1364          || (lexptr[0] >= '0' && lexptr[0] <= '9'))
1365     ++lexptr;
1366
1367
1368   length = lexptr - start;
1369   token = NULL;
1370   for (i = 0; i < ARRAY_SIZE (identifier_tokens); ++i)
1371     {
1372       if (length == strlen (identifier_tokens[i].name)
1373           && strncmp (identifier_tokens[i].name, start, length) == 0)
1374         {
1375           token = &identifier_tokens[i];
1376           break;
1377         }
1378     }
1379
1380   if (token != NULL)
1381     {
1382       if (token->value == 0)
1383         {
1384           /* Leave the terminating token alone.  */
1385           lexptr = start;
1386           return 0;
1387         }
1388     }
1389   else if (token == NULL
1390            && (strncmp (start, "thread", length) == 0
1391                || strncmp (start, "task", length) == 0)
1392            && space_then_number (lexptr))
1393     {
1394       /* "task" or "thread" followed by a number terminates the
1395          parse, per gdb rules.  */
1396       lexptr = start;
1397       return 0;
1398     }
1399
1400   if (token == NULL || (parse_completion && lexptr[0] == '\0'))
1401     rustyylval.sval = make_stoken (rust_copy_name (start, length));
1402
1403   if (parse_completion && lexptr[0] == '\0')
1404     {
1405       /* Prevent rustyylex from returning two COMPLETE tokens.  */
1406       prev_lexptr = lexptr;
1407       return COMPLETE;
1408     }
1409
1410   if (token != NULL)
1411     return token->value;
1412   if (is_gdb_var)
1413     return GDBVAR;
1414   return IDENT;
1415 }
1416
1417 /* Lex an operator.  */
1418
1419 static int
1420 lex_operator (void)
1421 {
1422   const struct token_info *token = NULL;
1423   int i;
1424
1425   for (i = 0; i < ARRAY_SIZE (operator_tokens); ++i)
1426     {
1427       if (strncmp (operator_tokens[i].name, lexptr,
1428                    strlen (operator_tokens[i].name)) == 0)
1429         {
1430           lexptr += strlen (operator_tokens[i].name);
1431           token = &operator_tokens[i];
1432           break;
1433         }
1434     }
1435
1436   if (token != NULL)
1437     {
1438       rustyylval.opcode = token->opcode;
1439       return token->value;
1440     }
1441
1442   return *lexptr++;
1443 }
1444
1445 /* Lex a number.  */
1446
1447 static int
1448 lex_number (void)
1449 {
1450   regmatch_t subexps[NUM_SUBEXPRESSIONS];
1451   int match;
1452   int is_integer = 0;
1453   int could_be_decimal = 1;
1454   int implicit_i32 = 0;
1455   const char *type_name = NULL;
1456   struct type *type;
1457   int end_index;
1458   int type_index = -1;
1459   int i;
1460
1461   match = regexec (&number_regex, lexptr, ARRAY_SIZE (subexps), subexps, 0);
1462   /* Failure means the regexp is broken.  */
1463   gdb_assert (match == 0);
1464
1465   if (subexps[INT_TEXT].rm_so != -1)
1466     {
1467       /* Integer part matched.  */
1468       is_integer = 1;
1469       end_index = subexps[INT_TEXT].rm_eo;
1470       if (subexps[INT_TYPE].rm_so == -1)
1471         {
1472           type_name = "i32";
1473           implicit_i32 = 1;
1474         }
1475       else
1476         {
1477           type_index = INT_TYPE;
1478           could_be_decimal = 0;
1479         }
1480     }
1481   else if (subexps[FLOAT_TYPE1].rm_so != -1)
1482     {
1483       /* Found floating point type suffix.  */
1484       end_index = subexps[FLOAT_TYPE1].rm_so;
1485       type_index = FLOAT_TYPE1;
1486     }
1487   else if (subexps[FLOAT_TYPE2].rm_so != -1)
1488     {
1489       /* Found floating point type suffix.  */
1490       end_index = subexps[FLOAT_TYPE2].rm_so;
1491       type_index = FLOAT_TYPE2;
1492     }
1493   else
1494     {
1495       /* Any other floating point match.  */
1496       end_index = subexps[0].rm_eo;
1497       type_name = "f64";
1498     }
1499
1500   /* We need a special case if the final character is ".".  In this
1501      case we might need to parse an integer.  For example, "23.f()" is
1502      a request for a trait method call, not a syntax error involving
1503      the floating point number "23.".  */
1504   gdb_assert (subexps[0].rm_eo > 0);
1505   if (lexptr[subexps[0].rm_eo - 1] == '.')
1506     {
1507       const char *next = skip_spaces (&lexptr[subexps[0].rm_eo]);
1508
1509       if (rust_identifier_start_p (*next) || *next == '.')
1510         {
1511           --subexps[0].rm_eo;
1512           is_integer = 1;
1513           end_index = subexps[0].rm_eo;
1514           type_name = "i32";
1515           could_be_decimal = 1;
1516           implicit_i32 = 1;
1517         }
1518     }
1519
1520   /* Compute the type name if we haven't already.  */
1521   std::string type_name_holder;
1522   if (type_name == NULL)
1523     {
1524       gdb_assert (type_index != -1);
1525       type_name_holder = std::string (lexptr + subexps[type_index].rm_so,
1526                                       (subexps[type_index].rm_eo
1527                                        - subexps[type_index].rm_so));
1528       type_name = type_name_holder.c_str ();
1529     }
1530
1531   /* Look up the type.  */
1532   type = rust_type (type_name);
1533
1534   /* Copy the text of the number and remove the "_"s.  */
1535   std::string number;
1536   for (i = 0; i < end_index && lexptr[i]; ++i)
1537     {
1538       if (lexptr[i] == '_')
1539         could_be_decimal = 0;
1540       else
1541         number.push_back (lexptr[i]);
1542     }
1543
1544   /* Advance past the match.  */
1545   lexptr += subexps[0].rm_eo;
1546
1547   /* Parse the number.  */
1548   if (is_integer)
1549     {
1550       uint64_t value;
1551       int radix = 10;
1552       int offset = 0;
1553
1554       if (number[0] == '0')
1555         {
1556           if (number[1] == 'x')
1557             radix = 16;
1558           else if (number[1] == 'o')
1559             radix = 8;
1560           else if (number[1] == 'b')
1561             radix = 2;
1562           if (radix != 10)
1563             {
1564               offset = 2;
1565               could_be_decimal = 0;
1566             }
1567         }
1568
1569       value = strtoul (number.c_str () + offset, NULL, radix);
1570       if (implicit_i32 && value >= ((uint64_t) 1) << 31)
1571         type = rust_type ("i64");
1572
1573       rustyylval.typed_val_int.val = value;
1574       rustyylval.typed_val_int.type = type;
1575     }
1576   else
1577     {
1578       rustyylval.typed_val_float.type = type;
1579       bool parsed = parse_float (number.c_str (), number.length (),
1580                                  rustyylval.typed_val_float.type,
1581                                  rustyylval.typed_val_float.val);
1582       gdb_assert (parsed);
1583     }
1584
1585   return is_integer ? (could_be_decimal ? DECIMAL_INTEGER : INTEGER) : FLOAT;
1586 }
1587
1588 /* The lexer.  */
1589
1590 static int
1591 rustyylex (void)
1592 {
1593   /* Skip all leading whitespace.  */
1594   while (lexptr[0] == ' ' || lexptr[0] == '\t' || lexptr[0] == '\r'
1595          || lexptr[0] == '\n')
1596     ++lexptr;
1597
1598   /* If we hit EOF and we're completing, then return COMPLETE -- maybe
1599      we're completing an empty string at the end of a field_expr.
1600      But, we don't want to return two COMPLETE tokens in a row.  */
1601   if (lexptr[0] == '\0' && lexptr == prev_lexptr)
1602     return 0;
1603   prev_lexptr = lexptr;
1604   if (lexptr[0] == '\0')
1605     {
1606       if (parse_completion)
1607         {
1608           rustyylval.sval = make_stoken ("");
1609           return COMPLETE;
1610         }
1611       return 0;
1612     }
1613
1614   if (lexptr[0] >= '0' && lexptr[0] <= '9')
1615     return lex_number ();
1616   else if (lexptr[0] == 'b' && lexptr[1] == '\'')
1617     return lex_character ();
1618   else if (lexptr[0] == 'b' && lexptr[1] == '"')
1619     return lex_string ();
1620   else if (lexptr[0] == 'b' && starts_raw_string (lexptr + 1))
1621     return lex_string ();
1622   else if (starts_raw_string (lexptr))
1623     return lex_string ();
1624   else if (rust_identifier_start_p (lexptr[0]))
1625     return lex_identifier ();
1626   else if (lexptr[0] == '"')
1627     return lex_string ();
1628   else if (lexptr[0] == '\'')
1629     return lex_character ();
1630   else if (lexptr[0] == '}' || lexptr[0] == ']')
1631     {
1632       /* Falls through to lex_operator.  */
1633       --paren_depth;
1634     }
1635   else if (lexptr[0] == '(' || lexptr[0] == '{')
1636     {
1637       /* Falls through to lex_operator.  */
1638       ++paren_depth;
1639     }
1640   else if (lexptr[0] == ',' && comma_terminates && paren_depth == 0)
1641     return 0;
1642
1643   return lex_operator ();
1644 }
1645
1646 /* Push back a single character to be re-lexed.  */
1647
1648 static void
1649 rust_push_back (char c)
1650 {
1651   /* Can't be called before any lexing.  */
1652   gdb_assert (prev_lexptr != NULL);
1653
1654   --lexptr;
1655   gdb_assert (*lexptr == c);
1656 }
1657
1658 \f
1659
1660 /* Make an arbitrary operation and fill in the fields.  */
1661
1662 static const struct rust_op *
1663 ast_operation (enum exp_opcode opcode, const struct rust_op *left,
1664                 const struct rust_op *right)
1665 {
1666   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1667
1668   result->opcode = opcode;
1669   result->left.op = left;
1670   result->right.op = right;
1671
1672   return result;
1673 }
1674
1675 /* Make a compound assignment operation.  */
1676
1677 static const struct rust_op *
1678 ast_compound_assignment (enum exp_opcode opcode, const struct rust_op *left,
1679                           const struct rust_op *right)
1680 {
1681   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1682
1683   result->opcode = opcode;
1684   result->compound_assignment = 1;
1685   result->left.op = left;
1686   result->right.op = right;
1687
1688   return result;
1689 }
1690
1691 /* Make a typed integer literal operation.  */
1692
1693 static const struct rust_op *
1694 ast_literal (struct typed_val_int val)
1695 {
1696   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1697
1698   result->opcode = OP_LONG;
1699   result->left.typed_val_int = val;
1700
1701   return result;
1702 }
1703
1704 /* Make a typed floating point literal operation.  */
1705
1706 static const struct rust_op *
1707 ast_dliteral (struct typed_val_float val)
1708 {
1709   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1710
1711   result->opcode = OP_FLOAT;
1712   result->left.typed_val_float = val;
1713
1714   return result;
1715 }
1716
1717 /* Make a unary operation.  */
1718
1719 static const struct rust_op *
1720 ast_unary (enum exp_opcode opcode, const struct rust_op *expr)
1721 {
1722   return ast_operation (opcode, expr, NULL);
1723 }
1724
1725 /* Make a cast operation.  */
1726
1727 static const struct rust_op *
1728 ast_cast (const struct rust_op *expr, const struct rust_op *type)
1729 {
1730   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1731
1732   result->opcode = UNOP_CAST;
1733   result->left.op = expr;
1734   result->right.op = type;
1735
1736   return result;
1737 }
1738
1739 /* Make a call-like operation.  This is nominally a function call, but
1740    when lowering we may discover that it actually represents the
1741    creation of a tuple struct.  */
1742
1743 static const struct rust_op *
1744 ast_call_ish (enum exp_opcode opcode, const struct rust_op *expr,
1745               rust_op_vector *params)
1746 {
1747   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1748
1749   result->opcode = opcode;
1750   result->left.op = expr;
1751   result->right.params = params;
1752
1753   return result;
1754 }
1755
1756 /* Make a structure creation operation.  */
1757
1758 static const struct rust_op *
1759 ast_struct (const struct rust_op *name, rust_set_vector *fields)
1760 {
1761   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1762
1763   result->opcode = OP_AGGREGATE;
1764   result->left.op = name;
1765   result->right.field_inits = fields;
1766
1767   return result;
1768 }
1769
1770 /* Make an identifier path.  */
1771
1772 static const struct rust_op *
1773 ast_path (struct stoken path, rust_op_vector *params)
1774 {
1775   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1776
1777   result->opcode = OP_VAR_VALUE;
1778   result->left.sval = path;
1779   result->right.params = params;
1780
1781   return result;
1782 }
1783
1784 /* Make a string constant operation.  */
1785
1786 static const struct rust_op *
1787 ast_string (struct stoken str)
1788 {
1789   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1790
1791   result->opcode = OP_STRING;
1792   result->left.sval = str;
1793
1794   return result;
1795 }
1796
1797 /* Make a field expression.  */
1798
1799 static const struct rust_op *
1800 ast_structop (const struct rust_op *left, const char *name, int completing)
1801 {
1802   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1803
1804   result->opcode = STRUCTOP_STRUCT;
1805   result->completing = completing;
1806   result->left.op = left;
1807   result->right.sval = make_stoken (name);
1808
1809   return result;
1810 }
1811
1812 /* Make an anonymous struct operation, like 'x.0'.  */
1813
1814 static const struct rust_op *
1815 ast_structop_anonymous (const struct rust_op *left,
1816                          struct typed_val_int number)
1817 {
1818   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1819
1820   result->opcode = STRUCTOP_ANONYMOUS;
1821   result->left.op = left;
1822   result->right.typed_val_int = number;
1823
1824   return result;
1825 }
1826
1827 /* Make a range operation.  */
1828
1829 static const struct rust_op *
1830 ast_range (const struct rust_op *lhs, const struct rust_op *rhs)
1831 {
1832   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1833
1834   result->opcode = OP_RANGE;
1835   result->left.op = lhs;
1836   result->right.op = rhs;
1837
1838   return result;
1839 }
1840
1841 /* A helper function to make a type-related AST node.  */
1842
1843 static struct rust_op *
1844 ast_basic_type (enum type_code typecode)
1845 {
1846   struct rust_op *result = OBSTACK_ZALLOC (work_obstack, struct rust_op);
1847
1848   result->opcode = OP_TYPE;
1849   result->typecode = typecode;
1850   return result;
1851 }
1852
1853 /* Create an AST node describing an array type.  */
1854
1855 static const struct rust_op *
1856 ast_array_type (const struct rust_op *lhs, struct typed_val_int val)
1857 {
1858   struct rust_op *result = ast_basic_type (TYPE_CODE_ARRAY);
1859
1860   result->left.op = lhs;
1861   result->right.typed_val_int = val;
1862   return result;
1863 }
1864
1865 /* Create an AST node describing a reference type.  */
1866
1867 static const struct rust_op *
1868 ast_slice_type (const struct rust_op *type)
1869 {
1870   /* Use TYPE_CODE_COMPLEX just because it is handy.  */
1871   struct rust_op *result = ast_basic_type (TYPE_CODE_COMPLEX);
1872
1873   result->left.op = type;
1874   return result;
1875 }
1876
1877 /* Create an AST node describing a reference type.  */
1878
1879 static const struct rust_op *
1880 ast_reference_type (const struct rust_op *type)
1881 {
1882   struct rust_op *result = ast_basic_type (TYPE_CODE_REF);
1883
1884   result->left.op = type;
1885   return result;
1886 }
1887
1888 /* Create an AST node describing a pointer type.  */
1889
1890 static const struct rust_op *
1891 ast_pointer_type (const struct rust_op *type, int is_mut)
1892 {
1893   struct rust_op *result = ast_basic_type (TYPE_CODE_PTR);
1894
1895   result->left.op = type;
1896   /* For the time being we ignore is_mut.  */
1897   return result;
1898 }
1899
1900 /* Create an AST node describing a function type.  */
1901
1902 static const struct rust_op *
1903 ast_function_type (const struct rust_op *rtype, rust_op_vector *params)
1904 {
1905   struct rust_op *result = ast_basic_type (TYPE_CODE_FUNC);
1906
1907   result->left.op = rtype;
1908   result->right.params = params;
1909   return result;
1910 }
1911
1912 /* Create an AST node describing a tuple type.  */
1913
1914 static const struct rust_op *
1915 ast_tuple_type (rust_op_vector *params)
1916 {
1917   struct rust_op *result = ast_basic_type (TYPE_CODE_STRUCT);
1918
1919   result->left.params = params;
1920   return result;
1921 }
1922
1923 /* A helper to appropriately munge NAME and BLOCK depending on the
1924    presence of a leading "::".  */
1925
1926 static void
1927 munge_name_and_block (const char **name, const struct block **block)
1928 {
1929   /* If it is a global reference, skip the current block in favor of
1930      the static block.  */
1931   if (strncmp (*name, "::", 2) == 0)
1932     {
1933       *name += 2;
1934       *block = block_static_block (*block);
1935     }
1936 }
1937
1938 /* Like lookup_symbol, but handles Rust namespace conventions, and
1939    doesn't require field_of_this_result.  */
1940
1941 static struct block_symbol
1942 rust_lookup_symbol (const char *name, const struct block *block,
1943                     const domain_enum domain)
1944 {
1945   struct block_symbol result;
1946
1947   munge_name_and_block (&name, &block);
1948
1949   result = lookup_symbol (name, block, domain, NULL);
1950   if (result.symbol != NULL)
1951     update_innermost_block (result);
1952   return result;
1953 }
1954
1955 /* Look up a type, following Rust namespace conventions.  */
1956
1957 static struct type *
1958 rust_lookup_type (const char *name, const struct block *block)
1959 {
1960   struct block_symbol result;
1961   struct type *type;
1962
1963   munge_name_and_block (&name, &block);
1964
1965   result = lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
1966   if (result.symbol != NULL)
1967     {
1968       update_innermost_block (result);
1969       return SYMBOL_TYPE (result.symbol);
1970     }
1971
1972   type = lookup_typename (current_parser->language (), current_parser->arch (),
1973                           name, NULL, 1);
1974   if (type != NULL)
1975     return type;
1976
1977   /* Last chance, try a built-in type.  */
1978   return language_lookup_primitive_type (current_parser->language (),
1979                                          current_parser->arch (),
1980                                          name);
1981 }
1982
1983 static struct type *convert_ast_to_type (struct parser_state *state,
1984                                          const struct rust_op *operation);
1985 static const char *convert_name (struct parser_state *state,
1986                                  const struct rust_op *operation);
1987
1988 /* Convert a vector of rust_ops representing types to a vector of
1989    types.  */
1990
1991 static std::vector<struct type *>
1992 convert_params_to_types (struct parser_state *state, rust_op_vector *params)
1993 {
1994   std::vector<struct type *> result;
1995
1996   for (const rust_op *op : *params)
1997     result.push_back (convert_ast_to_type (state, op));
1998
1999   return result;
2000 }
2001
2002 /* Convert a rust_op representing a type to a struct type *.  */
2003
2004 static struct type *
2005 convert_ast_to_type (struct parser_state *state,
2006                      const struct rust_op *operation)
2007 {
2008   struct type *type, *result = NULL;
2009
2010   if (operation->opcode == OP_VAR_VALUE)
2011     {
2012       const char *varname = convert_name (state, operation);
2013
2014       result = rust_lookup_type (varname, expression_context_block);
2015       if (result == NULL)
2016         error (_("No typed name '%s' in current context"), varname);
2017       return result;
2018     }
2019
2020   gdb_assert (operation->opcode == OP_TYPE);
2021
2022   switch (operation->typecode)
2023     {
2024     case TYPE_CODE_ARRAY:
2025       type = convert_ast_to_type (state, operation->left.op);
2026       if (operation->right.typed_val_int.val < 0)
2027         error (_("Negative array length"));
2028       result = lookup_array_range_type (type, 0,
2029                                         operation->right.typed_val_int.val - 1);
2030       break;
2031
2032     case TYPE_CODE_COMPLEX:
2033       {
2034         struct type *usize = rust_type ("usize");
2035
2036         type = convert_ast_to_type (state, operation->left.op);
2037         result = rust_slice_type ("&[*gdb*]", type, usize);
2038       }
2039       break;
2040
2041     case TYPE_CODE_REF:
2042     case TYPE_CODE_PTR:
2043       /* For now we treat &x and *x identically.  */
2044       type = convert_ast_to_type (state, operation->left.op);
2045       result = lookup_pointer_type (type);
2046       break;
2047
2048     case TYPE_CODE_FUNC:
2049       {
2050         std::vector<struct type *> args
2051           (convert_params_to_types (state, operation->right.params));
2052         struct type **argtypes = NULL;
2053
2054         type = convert_ast_to_type (state, operation->left.op);
2055         if (!args.empty ())
2056           argtypes = args.data ();
2057
2058         result
2059           = lookup_function_type_with_arguments (type, args.size (),
2060                                                  argtypes);
2061         result = lookup_pointer_type (result);
2062       }
2063       break;
2064
2065     case TYPE_CODE_STRUCT:
2066       {
2067         std::vector<struct type *> args
2068           (convert_params_to_types (state, operation->left.params));
2069         int i;
2070         const char *name;
2071
2072         obstack_1grow (work_obstack, '(');
2073         for (i = 0; i < args.size (); ++i)
2074           {
2075             std::string type_name = type_to_string (args[i]);
2076
2077             if (i > 0)
2078               obstack_1grow (work_obstack, ',');
2079             obstack_grow_str (work_obstack, type_name.c_str ());
2080           }
2081
2082         obstack_grow_str0 (work_obstack, ")");
2083         name = (const char *) obstack_finish (work_obstack);
2084
2085         /* We don't allow creating new tuple types (yet), but we do
2086            allow looking up existing tuple types.  */
2087         result = rust_lookup_type (name, expression_context_block);
2088         if (result == NULL)
2089           error (_("could not find tuple type '%s'"), name);
2090       }
2091       break;
2092
2093     default:
2094       gdb_assert_not_reached ("unhandled opcode in convert_ast_to_type");
2095     }
2096
2097   gdb_assert (result != NULL);
2098   return result;
2099 }
2100
2101 /* A helper function to turn a rust_op representing a name into a full
2102    name.  This applies generic arguments as needed.  The returned name
2103    is allocated on the work obstack.  */
2104
2105 static const char *
2106 convert_name (struct parser_state *state, const struct rust_op *operation)
2107 {
2108   int i;
2109
2110   gdb_assert (operation->opcode == OP_VAR_VALUE);
2111
2112   if (operation->right.params == NULL)
2113     return operation->left.sval.ptr;
2114
2115   std::vector<struct type *> types
2116     (convert_params_to_types (state, operation->right.params));
2117
2118   obstack_grow_str (work_obstack, operation->left.sval.ptr);
2119   obstack_1grow (work_obstack, '<');
2120   for (i = 0; i < types.size (); ++i)
2121     {
2122       std::string type_name = type_to_string (types[i]);
2123
2124       if (i > 0)
2125         obstack_1grow (work_obstack, ',');
2126
2127       obstack_grow_str (work_obstack, type_name.c_str ());
2128     }
2129   obstack_grow_str0 (work_obstack, ">");
2130
2131   return (const char *) obstack_finish (work_obstack);
2132 }
2133
2134 static void convert_ast_to_expression (struct parser_state *state,
2135                                        const struct rust_op *operation,
2136                                        const struct rust_op *top,
2137                                        bool want_type = false);
2138
2139 /* A helper function that converts a vec of rust_ops to a gdb
2140    expression.  */
2141
2142 static void
2143 convert_params_to_expression (struct parser_state *state,
2144                               rust_op_vector *params,
2145                               const struct rust_op *top)
2146 {
2147   for (const rust_op *elem : *params)
2148     convert_ast_to_expression (state, elem, top);
2149 }
2150
2151 /* Lower a rust_op to a gdb expression.  STATE is the parser state.
2152    OPERATION is the operation to lower.  TOP is a pointer to the
2153    top-most operation; it is used to handle the special case where the
2154    top-most expression is an identifier and can be optionally lowered
2155    to OP_TYPE.  WANT_TYPE is a flag indicating that, if the expression
2156    is the name of a type, then emit an OP_TYPE for it (rather than
2157    erroring).  If WANT_TYPE is set, then the similar TOP handling is
2158    not done.  */
2159
2160 static void
2161 convert_ast_to_expression (struct parser_state *state,
2162                            const struct rust_op *operation,
2163                            const struct rust_op *top,
2164                            bool want_type)
2165 {
2166   switch (operation->opcode)
2167     {
2168     case OP_LONG:
2169       write_exp_elt_opcode (state, OP_LONG);
2170       write_exp_elt_type (state, operation->left.typed_val_int.type);
2171       write_exp_elt_longcst (state, operation->left.typed_val_int.val);
2172       write_exp_elt_opcode (state, OP_LONG);
2173       break;
2174
2175     case OP_FLOAT:
2176       write_exp_elt_opcode (state, OP_FLOAT);
2177       write_exp_elt_type (state, operation->left.typed_val_float.type);
2178       write_exp_elt_floatcst (state, operation->left.typed_val_float.val);
2179       write_exp_elt_opcode (state, OP_FLOAT);
2180       break;
2181
2182     case STRUCTOP_STRUCT:
2183       {
2184         convert_ast_to_expression (state, operation->left.op, top);
2185
2186         if (operation->completing)
2187           mark_struct_expression (state);
2188         write_exp_elt_opcode (state, STRUCTOP_STRUCT);
2189         write_exp_string (state, operation->right.sval);
2190         write_exp_elt_opcode (state, STRUCTOP_STRUCT);
2191       }
2192       break;
2193
2194     case STRUCTOP_ANONYMOUS:
2195       {
2196         convert_ast_to_expression (state, operation->left.op, top);
2197
2198         write_exp_elt_opcode (state, STRUCTOP_ANONYMOUS);
2199         write_exp_elt_longcst (state, operation->right.typed_val_int.val);
2200         write_exp_elt_opcode (state, STRUCTOP_ANONYMOUS);
2201       }
2202       break;
2203
2204     case UNOP_SIZEOF:
2205       convert_ast_to_expression (state, operation->left.op, top, true);
2206       write_exp_elt_opcode (state, UNOP_SIZEOF);
2207       break;
2208
2209     case UNOP_PLUS:
2210     case UNOP_NEG:
2211     case UNOP_COMPLEMENT:
2212     case UNOP_IND:
2213     case UNOP_ADDR:
2214       convert_ast_to_expression (state, operation->left.op, top);
2215       write_exp_elt_opcode (state, operation->opcode);
2216       break;
2217
2218     case BINOP_SUBSCRIPT:
2219     case BINOP_MUL:
2220     case BINOP_REPEAT:
2221     case BINOP_DIV:
2222     case BINOP_REM:
2223     case BINOP_LESS:
2224     case BINOP_GTR:
2225     case BINOP_BITWISE_AND:
2226     case BINOP_BITWISE_IOR:
2227     case BINOP_BITWISE_XOR:
2228     case BINOP_ADD:
2229     case BINOP_SUB:
2230     case BINOP_LOGICAL_OR:
2231     case BINOP_LOGICAL_AND:
2232     case BINOP_EQUAL:
2233     case BINOP_NOTEQUAL:
2234     case BINOP_LEQ:
2235     case BINOP_GEQ:
2236     case BINOP_LSH:
2237     case BINOP_RSH:
2238     case BINOP_ASSIGN:
2239     case OP_RUST_ARRAY:
2240       convert_ast_to_expression (state, operation->left.op, top);
2241       convert_ast_to_expression (state, operation->right.op, top);
2242       if (operation->compound_assignment)
2243         {
2244           write_exp_elt_opcode (state, BINOP_ASSIGN_MODIFY);
2245           write_exp_elt_opcode (state, operation->opcode);
2246           write_exp_elt_opcode (state, BINOP_ASSIGN_MODIFY);
2247         }
2248       else
2249         write_exp_elt_opcode (state, operation->opcode);
2250
2251       if (operation->compound_assignment
2252           || operation->opcode == BINOP_ASSIGN)
2253         {
2254           struct type *type;
2255
2256           type = language_lookup_primitive_type (parse_language (state),
2257                                                  parse_gdbarch (state),
2258                                                  "()");
2259
2260           write_exp_elt_opcode (state, OP_LONG);
2261           write_exp_elt_type (state, type);
2262           write_exp_elt_longcst (state, 0);
2263           write_exp_elt_opcode (state, OP_LONG);
2264
2265           write_exp_elt_opcode (state, BINOP_COMMA);
2266         }
2267       break;
2268
2269     case UNOP_CAST:
2270       {
2271         struct type *type = convert_ast_to_type (state, operation->right.op);
2272
2273         convert_ast_to_expression (state, operation->left.op, top);
2274         write_exp_elt_opcode (state, UNOP_CAST);
2275         write_exp_elt_type (state, type);
2276         write_exp_elt_opcode (state, UNOP_CAST);
2277       }
2278       break;
2279
2280     case OP_FUNCALL:
2281       {
2282         if (operation->left.op->opcode == OP_VAR_VALUE)
2283           {
2284             struct type *type;
2285             const char *varname = convert_name (state, operation->left.op);
2286
2287             type = rust_lookup_type (varname, expression_context_block);
2288             if (type != NULL)
2289               {
2290                 /* This is actually a tuple struct expression, not a
2291                    call expression.  */
2292                 rust_op_vector *params = operation->right.params;
2293
2294                 if (TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
2295                   {
2296                     if (!rust_tuple_struct_type_p (type))
2297                       error (_("Type %s is not a tuple struct"), varname);
2298
2299                     for (int i = 0; i < params->size (); ++i)
2300                       {
2301                         char *cell = get_print_cell ();
2302
2303                         xsnprintf (cell, PRINT_CELL_SIZE, "__%d", i);
2304                         write_exp_elt_opcode (state, OP_NAME);
2305                         write_exp_string (state, make_stoken (cell));
2306                         write_exp_elt_opcode (state, OP_NAME);
2307
2308                         convert_ast_to_expression (state, (*params)[i], top);
2309                       }
2310
2311                     write_exp_elt_opcode (state, OP_AGGREGATE);
2312                     write_exp_elt_type (state, type);
2313                     write_exp_elt_longcst (state, 2 * params->size ());
2314                     write_exp_elt_opcode (state, OP_AGGREGATE);
2315                     break;
2316                   }
2317               }
2318           }
2319         convert_ast_to_expression (state, operation->left.op, top);
2320         convert_params_to_expression (state, operation->right.params, top);
2321         write_exp_elt_opcode (state, OP_FUNCALL);
2322         write_exp_elt_longcst (state, operation->right.params->size ());
2323         write_exp_elt_longcst (state, OP_FUNCALL);
2324       }
2325       break;
2326
2327     case OP_ARRAY:
2328       gdb_assert (operation->left.op == NULL);
2329       convert_params_to_expression (state, operation->right.params, top);
2330       write_exp_elt_opcode (state, OP_ARRAY);
2331       write_exp_elt_longcst (state, 0);
2332       write_exp_elt_longcst (state, operation->right.params->size () - 1);
2333       write_exp_elt_longcst (state, OP_ARRAY);
2334       break;
2335
2336     case OP_VAR_VALUE:
2337       {
2338         struct block_symbol sym;
2339         const char *varname;
2340
2341         if (operation->left.sval.ptr[0] == '$')
2342           {
2343             write_dollar_variable (state, operation->left.sval);
2344             break;
2345           }
2346
2347         varname = convert_name (state, operation);
2348         sym = rust_lookup_symbol (varname, expression_context_block,
2349                                   VAR_DOMAIN);
2350         if (sym.symbol != NULL && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
2351           {
2352             write_exp_elt_opcode (state, OP_VAR_VALUE);
2353             write_exp_elt_block (state, sym.block);
2354             write_exp_elt_sym (state, sym.symbol);
2355             write_exp_elt_opcode (state, OP_VAR_VALUE);
2356           }
2357         else
2358           {
2359             struct type *type = NULL;
2360
2361             if (sym.symbol != NULL)
2362               {
2363                 gdb_assert (SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF);
2364                 type = SYMBOL_TYPE (sym.symbol);
2365               }
2366             if (type == NULL)
2367               type = rust_lookup_type (varname, expression_context_block);
2368             if (type == NULL)
2369               error (_("No symbol '%s' in current context"), varname);
2370
2371             if (!want_type
2372                 && TYPE_CODE (type) == TYPE_CODE_STRUCT
2373                 && TYPE_NFIELDS (type) == 0)
2374               {
2375                 /* A unit-like struct.  */
2376                 write_exp_elt_opcode (state, OP_AGGREGATE);
2377                 write_exp_elt_type (state, type);
2378                 write_exp_elt_longcst (state, 0);
2379                 write_exp_elt_opcode (state, OP_AGGREGATE);
2380               }
2381             else if (want_type || operation == top)
2382               {
2383                 write_exp_elt_opcode (state, OP_TYPE);
2384                 write_exp_elt_type (state, type);
2385                 write_exp_elt_opcode (state, OP_TYPE);
2386               }
2387             else
2388               error (_("Found type '%s', which can't be "
2389                        "evaluated in this context"),
2390                      varname);
2391           }
2392       }
2393       break;
2394
2395     case OP_AGGREGATE:
2396       {
2397         int length;
2398         rust_set_vector *fields = operation->right.field_inits;
2399         struct type *type;
2400         const char *name;
2401
2402         length = 0;
2403         for (const set_field &init : *fields)
2404           {
2405             if (init.name.ptr != NULL)
2406               {
2407                 write_exp_elt_opcode (state, OP_NAME);
2408                 write_exp_string (state, init.name);
2409                 write_exp_elt_opcode (state, OP_NAME);
2410                 ++length;
2411               }
2412
2413             convert_ast_to_expression (state, init.init, top);
2414             ++length;
2415
2416             if (init.name.ptr == NULL)
2417               {
2418                 /* This is handled differently from Ada in our
2419                    evaluator.  */
2420                 write_exp_elt_opcode (state, OP_OTHERS);
2421               }
2422           }
2423
2424         name = convert_name (state, operation->left.op);
2425         type = rust_lookup_type (name, expression_context_block);
2426         if (type == NULL)
2427           error (_("Could not find type '%s'"), operation->left.sval.ptr);
2428
2429         if (TYPE_CODE (type) != TYPE_CODE_STRUCT
2430             || rust_tuple_type_p (type)
2431             || rust_tuple_struct_type_p (type))
2432           error (_("Struct expression applied to non-struct type"));
2433
2434         write_exp_elt_opcode (state, OP_AGGREGATE);
2435         write_exp_elt_type (state, type);
2436         write_exp_elt_longcst (state, length);
2437         write_exp_elt_opcode (state, OP_AGGREGATE);
2438       }
2439       break;
2440
2441     case OP_STRING:
2442       {
2443         write_exp_elt_opcode (state, OP_STRING);
2444         write_exp_string (state, operation->left.sval);
2445         write_exp_elt_opcode (state, OP_STRING);
2446       }
2447       break;
2448
2449     case OP_RANGE:
2450       {
2451         enum range_type kind = BOTH_BOUND_DEFAULT;
2452
2453         if (operation->left.op != NULL)
2454           {
2455             convert_ast_to_expression (state, operation->left.op, top);
2456             kind = HIGH_BOUND_DEFAULT;
2457           }
2458         if (operation->right.op != NULL)
2459           {
2460             convert_ast_to_expression (state, operation->right.op, top);
2461             if (kind == BOTH_BOUND_DEFAULT)
2462               kind = LOW_BOUND_DEFAULT;
2463             else
2464               {
2465                 gdb_assert (kind == HIGH_BOUND_DEFAULT);
2466                 kind = NONE_BOUND_DEFAULT;
2467               }
2468           }
2469         write_exp_elt_opcode (state, OP_RANGE);
2470         write_exp_elt_longcst (state, kind);
2471         write_exp_elt_opcode (state, OP_RANGE);
2472       }
2473       break;
2474
2475     default:
2476       gdb_assert_not_reached ("unhandled opcode in convert_ast_to_expression");
2477     }
2478 }
2479
2480 \f
2481
2482 /* The parser as exposed to gdb.  */
2483
2484 int
2485 rust_parse (struct parser_state *state)
2486 {
2487   int result;
2488
2489   /* This sets various globals and also clears them on
2490      destruction.  */
2491   rust_parser parser (state);
2492
2493   result = rustyyparse ();
2494
2495   if (!result || (parse_completion && parser.rust_ast != NULL))
2496     convert_ast_to_expression (state, parser.rust_ast, parser.rust_ast);
2497
2498   return result;
2499 }
2500
2501 /* The parser error handler.  */
2502
2503 void
2504 rustyyerror (const char *msg)
2505 {
2506   const char *where = prev_lexptr ? prev_lexptr : lexptr;
2507   error (_("%s in expression, near `%s'."), (msg ? msg : "Error"), where);
2508 }
2509
2510 \f
2511
2512 #if GDB_SELF_TEST
2513
2514 /* Initialize the lexer for testing.  */
2515
2516 static void
2517 rust_lex_test_init (const char *input)
2518 {
2519   prev_lexptr = NULL;
2520   lexptr = input;
2521   paren_depth = 0;
2522 }
2523
2524 /* A test helper that lexes a string, expecting a single token.  It
2525    returns the lexer data for this token.  */
2526
2527 static RUSTSTYPE
2528 rust_lex_test_one (const char *input, int expected)
2529 {
2530   int token;
2531   RUSTSTYPE result;
2532
2533   rust_lex_test_init (input);
2534
2535   token = rustyylex ();
2536   SELF_CHECK (token == expected);
2537   result = rustyylval;
2538
2539   if (token)
2540     {
2541       token = rustyylex ();
2542       SELF_CHECK (token == 0);
2543     }
2544
2545   return result;
2546 }
2547
2548 /* Test that INPUT lexes as the integer VALUE.  */
2549
2550 static void
2551 rust_lex_int_test (const char *input, int value, int kind)
2552 {
2553   RUSTSTYPE result = rust_lex_test_one (input, kind);
2554   SELF_CHECK (result.typed_val_int.val == value);
2555 }
2556
2557 /* Test that INPUT throws an exception with text ERR.  */
2558
2559 static void
2560 rust_lex_exception_test (const char *input, const char *err)
2561 {
2562   TRY
2563     {
2564       /* The "kind" doesn't matter.  */
2565       rust_lex_test_one (input, DECIMAL_INTEGER);
2566       SELF_CHECK (0);
2567     }
2568   CATCH (except, RETURN_MASK_ERROR)
2569     {
2570       SELF_CHECK (strcmp (except.message, err) == 0);
2571     }
2572   END_CATCH
2573 }
2574
2575 /* Test that INPUT lexes as the identifier, string, or byte-string
2576    VALUE.  KIND holds the expected token kind.  */
2577
2578 static void
2579 rust_lex_stringish_test (const char *input, const char *value, int kind)
2580 {
2581   RUSTSTYPE result = rust_lex_test_one (input, kind);
2582   SELF_CHECK (result.sval.length == strlen (value));
2583   SELF_CHECK (strncmp (result.sval.ptr, value, result.sval.length) == 0);
2584 }
2585
2586 /* Helper to test that a string parses as a given token sequence.  */
2587
2588 static void
2589 rust_lex_test_sequence (const char *input, int len, const int expected[])
2590 {
2591   int i;
2592
2593   lexptr = input;
2594   paren_depth = 0;
2595
2596   for (i = 0; i < len; ++i)
2597     {
2598       int token = rustyylex ();
2599
2600       SELF_CHECK (token == expected[i]);
2601     }
2602 }
2603
2604 /* Tests for an integer-parsing corner case.  */
2605
2606 static void
2607 rust_lex_test_trailing_dot (void)
2608 {
2609   const int expected1[] = { DECIMAL_INTEGER, '.', IDENT, '(', ')', 0 };
2610   const int expected2[] = { INTEGER, '.', IDENT, '(', ')', 0 };
2611   const int expected3[] = { FLOAT, EQEQ, '(', ')', 0 };
2612   const int expected4[] = { DECIMAL_INTEGER, DOTDOT, DECIMAL_INTEGER, 0 };
2613
2614   rust_lex_test_sequence ("23.g()", ARRAY_SIZE (expected1), expected1);
2615   rust_lex_test_sequence ("23_0.g()", ARRAY_SIZE (expected2), expected2);
2616   rust_lex_test_sequence ("23.==()", ARRAY_SIZE (expected3), expected3);
2617   rust_lex_test_sequence ("23..25", ARRAY_SIZE (expected4), expected4);
2618 }
2619
2620 /* Tests of completion.  */
2621
2622 static void
2623 rust_lex_test_completion (void)
2624 {
2625   const int expected[] = { IDENT, '.', COMPLETE, 0 };
2626
2627   parse_completion = 1;
2628
2629   rust_lex_test_sequence ("something.wha", ARRAY_SIZE (expected), expected);
2630   rust_lex_test_sequence ("something.", ARRAY_SIZE (expected), expected);
2631
2632   parse_completion = 0;
2633 }
2634
2635 /* Test pushback.  */
2636
2637 static void
2638 rust_lex_test_push_back (void)
2639 {
2640   int token;
2641
2642   rust_lex_test_init (">>=");
2643
2644   token = rustyylex ();
2645   SELF_CHECK (token == COMPOUND_ASSIGN);
2646   SELF_CHECK (rustyylval.opcode == BINOP_RSH);
2647
2648   rust_push_back ('=');
2649
2650   token = rustyylex ();
2651   SELF_CHECK (token == '=');
2652
2653   token = rustyylex ();
2654   SELF_CHECK (token == 0);
2655 }
2656
2657 /* Unit test the lexer.  */
2658
2659 static void
2660 rust_lex_tests (void)
2661 {
2662   int i;
2663
2664   auto_obstack test_obstack;
2665   scoped_restore obstack_holder = make_scoped_restore (&work_obstack,
2666                                                        &test_obstack);
2667
2668   // Set up dummy "parser", so that rust_type works.
2669   struct parser_state ps;
2670   initialize_expout (&ps, 0, &rust_language_defn, target_gdbarch ());
2671   rust_parser parser (&ps);
2672
2673   rust_lex_test_one ("", 0);
2674   rust_lex_test_one ("    \t  \n \r  ", 0);
2675   rust_lex_test_one ("thread 23", 0);
2676   rust_lex_test_one ("task 23", 0);
2677   rust_lex_test_one ("th 104", 0);
2678   rust_lex_test_one ("ta 97", 0);
2679
2680   rust_lex_int_test ("'z'", 'z', INTEGER);
2681   rust_lex_int_test ("'\\xff'", 0xff, INTEGER);
2682   rust_lex_int_test ("'\\u{1016f}'", 0x1016f, INTEGER);
2683   rust_lex_int_test ("b'z'", 'z', INTEGER);
2684   rust_lex_int_test ("b'\\xfe'", 0xfe, INTEGER);
2685   rust_lex_int_test ("b'\\xFE'", 0xfe, INTEGER);
2686   rust_lex_int_test ("b'\\xfE'", 0xfe, INTEGER);
2687
2688   /* Test all escapes in both modes.  */
2689   rust_lex_int_test ("'\\n'", '\n', INTEGER);
2690   rust_lex_int_test ("'\\r'", '\r', INTEGER);
2691   rust_lex_int_test ("'\\t'", '\t', INTEGER);
2692   rust_lex_int_test ("'\\\\'", '\\', INTEGER);
2693   rust_lex_int_test ("'\\0'", '\0', INTEGER);
2694   rust_lex_int_test ("'\\''", '\'', INTEGER);
2695   rust_lex_int_test ("'\\\"'", '"', INTEGER);
2696
2697   rust_lex_int_test ("b'\\n'", '\n', INTEGER);
2698   rust_lex_int_test ("b'\\r'", '\r', INTEGER);
2699   rust_lex_int_test ("b'\\t'", '\t', INTEGER);
2700   rust_lex_int_test ("b'\\\\'", '\\', INTEGER);
2701   rust_lex_int_test ("b'\\0'", '\0', INTEGER);
2702   rust_lex_int_test ("b'\\''", '\'', INTEGER);
2703   rust_lex_int_test ("b'\\\"'", '"', INTEGER);
2704
2705   rust_lex_exception_test ("'z", "Unterminated character literal");
2706   rust_lex_exception_test ("b'\\x0'", "Not enough hex digits seen");
2707   rust_lex_exception_test ("b'\\u{0}'", "Unicode escape in byte literal");
2708   rust_lex_exception_test ("'\\x0'", "Not enough hex digits seen");
2709   rust_lex_exception_test ("'\\u0'", "Missing '{' in Unicode escape");
2710   rust_lex_exception_test ("'\\u{0", "Missing '}' in Unicode escape");
2711   rust_lex_exception_test ("'\\u{0000007}", "Overlong hex escape");
2712   rust_lex_exception_test ("'\\u{}", "Not enough hex digits seen");
2713   rust_lex_exception_test ("'\\Q'", "Invalid escape \\Q in literal");
2714   rust_lex_exception_test ("b'\\Q'", "Invalid escape \\Q in literal");
2715
2716   rust_lex_int_test ("23", 23, DECIMAL_INTEGER);
2717   rust_lex_int_test ("2_344__29", 234429, INTEGER);
2718   rust_lex_int_test ("0x1f", 0x1f, INTEGER);
2719   rust_lex_int_test ("23usize", 23, INTEGER);
2720   rust_lex_int_test ("23i32", 23, INTEGER);
2721   rust_lex_int_test ("0x1_f", 0x1f, INTEGER);
2722   rust_lex_int_test ("0b1_101011__", 0x6b, INTEGER);
2723   rust_lex_int_test ("0o001177i64", 639, INTEGER);
2724
2725   rust_lex_test_trailing_dot ();
2726
2727   rust_lex_test_one ("23.", FLOAT);
2728   rust_lex_test_one ("23.99f32", FLOAT);
2729   rust_lex_test_one ("23e7", FLOAT);
2730   rust_lex_test_one ("23E-7", FLOAT);
2731   rust_lex_test_one ("23e+7", FLOAT);
2732   rust_lex_test_one ("23.99e+7f64", FLOAT);
2733   rust_lex_test_one ("23.82f32", FLOAT);
2734
2735   rust_lex_stringish_test ("hibob", "hibob", IDENT);
2736   rust_lex_stringish_test ("hibob__93", "hibob__93", IDENT);
2737   rust_lex_stringish_test ("thread", "thread", IDENT);
2738
2739   rust_lex_stringish_test ("\"string\"", "string", STRING);
2740   rust_lex_stringish_test ("\"str\\ting\"", "str\ting", STRING);
2741   rust_lex_stringish_test ("\"str\\\"ing\"", "str\"ing", STRING);
2742   rust_lex_stringish_test ("r\"str\\ing\"", "str\\ing", STRING);
2743   rust_lex_stringish_test ("r#\"str\\ting\"#", "str\\ting", STRING);
2744   rust_lex_stringish_test ("r###\"str\\\"ing\"###", "str\\\"ing", STRING);
2745
2746   rust_lex_stringish_test ("b\"string\"", "string", BYTESTRING);
2747   rust_lex_stringish_test ("b\"\x73tring\"", "string", BYTESTRING);
2748   rust_lex_stringish_test ("b\"str\\\"ing\"", "str\"ing", BYTESTRING);
2749   rust_lex_stringish_test ("br####\"\\x73tring\"####", "\\x73tring",
2750                            BYTESTRING);
2751
2752   for (i = 0; i < ARRAY_SIZE (identifier_tokens); ++i)
2753     rust_lex_test_one (identifier_tokens[i].name, identifier_tokens[i].value);
2754
2755   for (i = 0; i < ARRAY_SIZE (operator_tokens); ++i)
2756     rust_lex_test_one (operator_tokens[i].name, operator_tokens[i].value);
2757
2758   rust_lex_test_completion ();
2759   rust_lex_test_push_back ();
2760 }
2761
2762 #endif /* GDB_SELF_TEST */
2763
2764 void
2765 _initialize_rust_exp (void)
2766 {
2767   int code = regcomp (&number_regex, number_regex_text, REG_EXTENDED);
2768   /* If the regular expression was incorrect, it was a programming
2769      error.  */
2770   gdb_assert (code == 0);
2771
2772 #if GDB_SELF_TEST
2773   selftests::register_test ("rust-lex", rust_lex_tests);
2774 #endif
2775 }