gcc/cp/cxx-pretty-print.c

   1 /* Implementation of subroutines for the GNU C++ pretty-printer.
   2    Copyright (C) 2003-2018 Free Software Foundation, Inc.
   3    Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "cp-tree.h"
  25 #include "cxx-pretty-print.h"
  26 #include "tree-pretty-print.h"
  27
  28 static void pp_cxx_unqualified_id (cxx_pretty_printer *, tree);
  29 static void pp_cxx_nested_name_specifier (cxx_pretty_printer *, tree);
  30 static void pp_cxx_qualified_id (cxx_pretty_printer *, tree);
  31 static void pp_cxx_template_argument_list (cxx_pretty_printer *, tree);
  32 static void pp_cxx_type_specifier_seq (cxx_pretty_printer *, tree);
  33 static void pp_cxx_ptr_operator (cxx_pretty_printer *, tree);
  34 static void pp_cxx_parameter_declaration_clause (cxx_pretty_printer *, tree);
  35 static void pp_cxx_template_parameter (cxx_pretty_printer *, tree);
  36 static void pp_cxx_cast_expression (cxx_pretty_printer *, tree);
  37 static void pp_cxx_typeid_expression (cxx_pretty_printer *, tree);
  38 static void pp_cxx_unary_left_fold_expression (cxx_pretty_printer *, tree);
  39 static void pp_cxx_unary_right_fold_expression (cxx_pretty_printer *, tree);
  40 static void pp_cxx_binary_fold_expression (cxx_pretty_printer *, tree);
  41 \f
  42
  43 static inline void
  44 pp_cxx_nonconsecutive_character (cxx_pretty_printer *pp, int c)
  45 {
  46   const char *p = pp_last_position_in_text (pp);
  47
  48   if (p != NULL && *p == c)
  49     pp_cxx_whitespace (pp);
  50   pp_character (pp, c);
  51   pp->padding = pp_none;
  52 }
  53
  54 #define pp_cxx_expression_list(PP, T)    \
  55    pp_c_expression_list (PP, T)
  56 #define pp_cxx_space_for_pointer_operator(PP, T)  \
  57    pp_c_space_for_pointer_operator (PP, T)
  58 #define pp_cxx_init_declarator(PP, T)    \
  59    pp_c_init_declarator (PP, T)
  60 #define pp_cxx_call_argument_list(PP, T) \
  61    pp_c_call_argument_list (PP, T)
  62
  63 void
  64 pp_cxx_colon_colon (cxx_pretty_printer *pp)
  65 {
  66   pp_colon_colon (pp);
  67   pp->padding = pp_none;
  68 }
  69
  70 void
  71 pp_cxx_begin_template_argument_list (cxx_pretty_printer *pp)
  72 {
  73   pp_cxx_nonconsecutive_character (pp, '<');
  74 }
  75
  76 void
  77 pp_cxx_end_template_argument_list (cxx_pretty_printer *pp)
  78 {
  79   pp_cxx_nonconsecutive_character (pp, '>');
  80 }
  81
  82 void
  83 pp_cxx_separate_with (cxx_pretty_printer *pp, int c)
  84 {
  85   pp_separate_with (pp, c);
  86   pp->padding = pp_none;
  87 }
  88
  89 /* Expressions.  */
  90
  91 /* conversion-function-id:
  92       operator conversion-type-id
  93
  94    conversion-type-id:
  95       type-specifier-seq conversion-declarator(opt)
  96
  97    conversion-declarator:
  98       ptr-operator conversion-declarator(opt)  */
  99
 100 static inline void
 101 pp_cxx_conversion_function_id (cxx_pretty_printer *pp, tree t)
 102 {
 103   pp_cxx_ws_string (pp, "operator");
 104   pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
 105 }
 106
 107 static inline void
 108 pp_cxx_template_id (cxx_pretty_printer *pp, tree t)
 109 {
 110   pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
 111   pp_cxx_begin_template_argument_list (pp);
 112   pp_cxx_template_argument_list (pp, TREE_OPERAND (t, 1));
 113   pp_cxx_end_template_argument_list (pp);
 114 }
 115
 116 /* Prints the unqualified part of the id-expression T.
 117
 118    unqualified-id:
 119      identifier
 120      operator-function-id
 121      conversion-function-id
 122      ~ class-name
 123      template-id  */
 124
 125 static void
 126 pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
 127 {
 128   enum tree_code code = TREE_CODE (t);
 129   switch (code)
 130     {
 131     case RESULT_DECL:
 132       pp->translate_string ("<return-value>");
 133       break;
 134
 135     case OVERLOAD:
 136       t = OVL_FIRST (t);
 137       /* FALLTHRU */
 138     case VAR_DECL:
 139     case PARM_DECL:
 140     case CONST_DECL:
 141     case TYPE_DECL:
 142     case FUNCTION_DECL:
 143     case NAMESPACE_DECL:
 144     case FIELD_DECL:
 145     case LABEL_DECL:
 146     case USING_DECL:
 147     case TEMPLATE_DECL:
 148       t = DECL_NAME (t);
 149       /* FALLTHRU */
 150
 151     case IDENTIFIER_NODE:
 152       if (t == NULL)
 153         pp->translate_string ("<unnamed>");
 154       else if (IDENTIFIER_CONV_OP_P (t))
 155         pp_cxx_conversion_function_id (pp, t);
 156       else
 157         pp_cxx_tree_identifier (pp, t);
 158       break;
 159
 160     case TEMPLATE_ID_EXPR:
 161       pp_cxx_template_id (pp, t);
 162       break;
 163
 164     case BASELINK:
 165       pp_cxx_unqualified_id (pp, BASELINK_FUNCTIONS (t));
 166       break;
 167
 168     case RECORD_TYPE:
 169     case UNION_TYPE:
 170     case ENUMERAL_TYPE:
 171     case TYPENAME_TYPE:
 172     case UNBOUND_CLASS_TEMPLATE:
 173       pp_cxx_unqualified_id (pp, TYPE_NAME (t));
 174       if (CLASS_TYPE_P (t) && CLASSTYPE_USE_TEMPLATE (t))
 175         {
 176           pp_cxx_begin_template_argument_list (pp);
 177           pp_cxx_template_argument_list (pp, INNERMOST_TEMPLATE_ARGS
 178                                                  (CLASSTYPE_TI_ARGS (t)));
 179           pp_cxx_end_template_argument_list (pp);
 180         }
 181       break;
 182
 183     case BIT_NOT_EXPR:
 184       pp_cxx_complement (pp);
 185       pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
 186       break;
 187
 188     case TEMPLATE_TYPE_PARM:
 189     case TEMPLATE_TEMPLATE_PARM:
 190       if (TYPE_IDENTIFIER (t))
 191         pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
 192       else
 193         pp_cxx_canonical_template_parameter (pp, t);
 194       break;
 195
 196     case TEMPLATE_PARM_INDEX:
 197       pp_cxx_unqualified_id (pp, TEMPLATE_PARM_DECL (t));
 198       break;
 199
 200     case BOUND_TEMPLATE_TEMPLATE_PARM:
 201       pp_cxx_cv_qualifier_seq (pp, t);
 202       pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
 203       pp_cxx_begin_template_argument_list (pp);
 204       pp_cxx_template_argument_list (pp, TYPE_TI_ARGS (t));
 205       pp_cxx_end_template_argument_list (pp);
 206       break;
 207
 208     default:
 209       pp_unsupported_tree (pp, t);
 210       break;
 211     }
 212 }
 213
 214 /* Pretty-print out the token sequence ":: template" in template codes
 215    where it is needed to "inline declare" the (following) member as
 216    a template.  This situation arises when SCOPE of T is dependent
 217    on template parameters.  */
 218
 219 static inline void
 220 pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t)
 221 {
 222   if (TREE_CODE (t) == TEMPLATE_ID_EXPR
 223       && TYPE_P (scope) && dependent_type_p (scope))
 224     pp_cxx_ws_string (pp, "template");
 225 }
 226
 227 /* nested-name-specifier:
 228       class-or-namespace-name :: nested-name-specifier(opt)
 229       class-or-namespace-name :: template nested-name-specifier   */
 230
 231 static void
 232 pp_cxx_nested_name_specifier (cxx_pretty_printer *pp, tree t)
 233 {
 234   if (!SCOPE_FILE_SCOPE_P (t) && t != pp->enclosing_scope)
 235     {
 236       tree scope = get_containing_scope (t);
 237       pp_cxx_nested_name_specifier (pp, scope);
 238       pp_cxx_template_keyword_if_needed (pp, scope, t);
 239       pp_cxx_unqualified_id (pp, t);
 240       pp_cxx_colon_colon (pp);
 241     }
 242 }
 243
 244 /* qualified-id:
 245       nested-name-specifier template(opt) unqualified-id  */
 246
 247 static void
 248 pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t)
 249 {
 250   switch (TREE_CODE (t))
 251     {
 252       /* A pointer-to-member is always qualified.  */
 253     case PTRMEM_CST:
 254       pp_cxx_nested_name_specifier (pp, PTRMEM_CST_CLASS (t));
 255       pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t));
 256       break;
 257
 258       /* In Standard C++, functions cannot possibly be used as
 259          nested-name-specifiers.  However, there are situations where
 260          is "makes sense" to output the surrounding function name for the
 261          purpose of emphasizing on the scope kind.  Just printing the
 262          function name might not be sufficient as it may be overloaded; so,
 263          we decorate the function with its signature too.
 264          FIXME:  This is probably the wrong pretty-printing for conversion
 265          functions and some function templates.  */
 266     case OVERLOAD:
 267       t = OVL_FIRST (t);
 268       /* FALLTHRU */
 269     case FUNCTION_DECL:
 270       if (DECL_FUNCTION_MEMBER_P (t))
 271         pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
 272       pp_cxx_unqualified_id
 273         (pp, DECL_CONSTRUCTOR_P (t) ? DECL_CONTEXT (t) : t);
 274       pp_cxx_parameter_declaration_clause (pp, TREE_TYPE (t));
 275       break;
 276
 277     case OFFSET_REF:
 278     case SCOPE_REF:
 279       pp_cxx_nested_name_specifier (pp, TREE_OPERAND (t, 0));
 280       pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 1));
 281       break;
 282
 283     default:
 284       {
 285         tree scope = get_containing_scope (t);
 286         if (scope != pp->enclosing_scope)
 287           {
 288             pp_cxx_nested_name_specifier (pp, scope);
 289             pp_cxx_template_keyword_if_needed (pp, scope, t);
 290           }
 291         pp_cxx_unqualified_id (pp, t);
 292       }
 293       break;
 294     }
 295 }
 296
 297
 298 void
 299 cxx_pretty_printer::constant (tree t)
 300 {
 301   switch (TREE_CODE (t))
 302     {
 303     case STRING_CST:
 304       {
 305         const bool in_parens = PAREN_STRING_LITERAL_P (t);
 306         if (in_parens)
 307           pp_cxx_left_paren (this);
 308         c_pretty_printer::constant (t);
 309         if (in_parens)
 310           pp_cxx_right_paren (this);
 311       }
 312       break;
 313
 314     case INTEGER_CST:
 315       if (NULLPTR_TYPE_P (TREE_TYPE (t)))
 316         {
 317           pp_string (this, "nullptr");
 318           break;
 319         }
 320       /* fall through.  */
 321
 322     default:
 323       c_pretty_printer::constant (t);
 324       break;
 325     }
 326 }
 327
 328 /* id-expression:
 329       unqualified-id
 330       qualified-id   */
 331
 332 void
 333 cxx_pretty_printer::id_expression (tree t)
 334 {
 335   if (TREE_CODE (t) == OVERLOAD)
 336     t = OVL_FIRST (t);
 337   if (DECL_P (t) && DECL_CONTEXT (t))
 338     pp_cxx_qualified_id (this, t);
 339   else
 340     pp_cxx_unqualified_id (this, t);
 341 }
 342
 343 /* user-defined literal:
 344       literal ud-suffix  */
 345
 346 void
 347 pp_cxx_userdef_literal (cxx_pretty_printer *pp, tree t)
 348 {
 349   pp->constant (USERDEF_LITERAL_VALUE (t));
 350   pp->id_expression (USERDEF_LITERAL_SUFFIX_ID (t));
 351 }
 352
 353
 354 /* primary-expression:
 355      literal
 356      this
 357      :: identifier
 358      :: operator-function-id
 359      :: qualifier-id
 360      ( expression )
 361      id-expression
 362
 363    GNU Extensions:
 364      __builtin_va_arg ( assignment-expression , type-id )
 365      __builtin_offsetof ( type-id, offsetof-expression )
 366      __builtin_addressof ( expression )
 367
 368      __has_nothrow_assign ( type-id )
 369      __has_nothrow_constructor ( type-id )
 370      __has_nothrow_copy ( type-id )
 371      __has_trivial_assign ( type-id )
 372      __has_trivial_constructor ( type-id )
 373      __has_trivial_copy ( type-id )
 374      __has_unique_object_representations ( type-id )
 375      __has_trivial_destructor ( type-id )
 376      __has_virtual_destructor ( type-id )
 377      __is_abstract ( type-id )
 378      __is_base_of ( type-id , type-id )
 379      __is_class ( type-id )
 380      __is_empty ( type-id )
 381      __is_enum ( type-id )
 382      __is_literal_type ( type-id )
 383      __is_pod ( type-id )
 384      __is_polymorphic ( type-id )
 385      __is_std_layout ( type-id )
 386      __is_trivial ( type-id )
 387      __is_union ( type-id )  */
 388
 389 void
 390 cxx_pretty_printer::primary_expression (tree t)
 391 {
 392   switch (TREE_CODE (t))
 393     {
 394     case VOID_CST:
 395     case INTEGER_CST:
 396     case REAL_CST:
 397     case COMPLEX_CST:
 398     case STRING_CST:
 399       constant (t);
 400       break;
 401
 402     case USERDEF_LITERAL:
 403       pp_cxx_userdef_literal (this, t);
 404       break;
 405
 406     case BASELINK:
 407       t = BASELINK_FUNCTIONS (t);
 408       /* FALLTHRU */
 409     case VAR_DECL:
 410     case PARM_DECL:
 411     case FIELD_DECL:
 412     case FUNCTION_DECL:
 413     case OVERLOAD:
 414     case CONST_DECL:
 415     case TEMPLATE_DECL:
 416       id_expression (t);
 417       break;
 418
 419     case RESULT_DECL:
 420     case TEMPLATE_TYPE_PARM:
 421     case TEMPLATE_TEMPLATE_PARM:
 422     case TEMPLATE_PARM_INDEX:
 423       pp_cxx_unqualified_id (this, t);
 424       break;
 425
 426     case STMT_EXPR:
 427       pp_cxx_left_paren (this);
 428       statement (STMT_EXPR_STMT (t));
 429       pp_cxx_right_paren (this);
 430       break;
 431
 432     case TRAIT_EXPR:
 433       pp_cxx_trait_expression (this, t);
 434       break;
 435
 436     case VA_ARG_EXPR:
 437       pp_cxx_va_arg_expression (this, t);
 438       break;
 439
 440     case OFFSETOF_EXPR:
 441       pp_cxx_offsetof_expression (this, t);
 442       break;
 443
 444     case ADDRESSOF_EXPR:
 445       pp_cxx_addressof_expression (this, t);
 446       break;
 447
 448     case REQUIRES_EXPR:
 449       pp_cxx_requires_expr (this, t);
 450       break;
 451
 452     default:
 453       c_pretty_printer::primary_expression (t);
 454       break;
 455     }
 456 }
 457
 458 /* postfix-expression:
 459      primary-expression
 460      postfix-expression [ expression ]
 461      postfix-expression ( expression-list(opt) )
 462      simple-type-specifier ( expression-list(opt) )
 463      typename ::(opt) nested-name-specifier identifier ( expression-list(opt) )
 464      typename ::(opt) nested-name-specifier template(opt)
 465                                        template-id ( expression-list(opt) )
 466      postfix-expression . template(opt) ::(opt) id-expression
 467      postfix-expression -> template(opt) ::(opt) id-expression
 468      postfix-expression . pseudo-destructor-name
 469      postfix-expression -> pseudo-destructor-name
 470      postfix-expression ++
 471      postfix-expression --
 472      dynamic_cast < type-id > ( expression )
 473      static_cast < type-id > ( expression )
 474      reinterpret_cast < type-id > ( expression )
 475      const_cast < type-id > ( expression )
 476      typeid ( expression )
 477      typeid ( type-id )  */
 478
 479 void
 480 cxx_pretty_printer::postfix_expression (tree t)
 481 {
 482   enum tree_code code = TREE_CODE (t);
 483
 484   switch (code)
 485     {
 486     case AGGR_INIT_EXPR:
 487     case CALL_EXPR:
 488       {
 489         tree fun = cp_get_callee (t);
 490         tree saved_scope = enclosing_scope;
 491         bool skipfirst = false;
 492         tree arg;
 493
 494         if (TREE_CODE (fun) == ADDR_EXPR)
 495           fun = TREE_OPERAND (fun, 0);
 496
 497         /* In templates, where there is no way to tell whether a given
 498            call uses an actual member function.  So the parser builds
 499            FUN as a COMPONENT_REF or a plain IDENTIFIER_NODE until
 500            instantiation time.  */
 501         if (TREE_CODE (fun) != FUNCTION_DECL)
 502           ;
 503         else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun))
 504           {
 505             tree object = (code == AGGR_INIT_EXPR
 506                            ? (AGGR_INIT_VIA_CTOR_P (t)
 507                               ? AGGR_INIT_EXPR_SLOT (t)
 508                               : AGGR_INIT_EXPR_ARG (t, 0))
 509                            : CALL_EXPR_ARG (t, 0));
 510
 511             while (TREE_CODE (object) == NOP_EXPR)
 512               object = TREE_OPERAND (object, 0);
 513
 514             if (TREE_CODE (object) == ADDR_EXPR)
 515               object = TREE_OPERAND (object, 0);
 516
 517             if (!TYPE_PTR_P (TREE_TYPE (object)))
 518               {
 519                 postfix_expression (object);
 520                 pp_cxx_dot (this);
 521               }
 522             else
 523               {
 524                 postfix_expression (object);
 525                 pp_cxx_arrow (this);
 526               }
 527             skipfirst = true;
 528             enclosing_scope = strip_pointer_operator (TREE_TYPE (object));
 529           }
 530
 531         postfix_expression (fun);
 532         enclosing_scope = saved_scope;
 533         pp_cxx_left_paren (this);
 534         if (code == AGGR_INIT_EXPR)
 535           {
 536             aggr_init_expr_arg_iterator iter;
 537             FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
 538               {
 539                 if (skipfirst)
 540                   skipfirst = false;
 541                 else
 542                   {
 543                     expression (arg);
 544                     if (more_aggr_init_expr_args_p (&iter))
 545                       pp_cxx_separate_with (this, ',');
 546                   }
 547               }
 548           }
 549         else
 550           {
 551             call_expr_arg_iterator iter;
 552             FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
 553               {
 554                 if (skipfirst)
 555                   skipfirst = false;
 556                 else
 557                   {
 558                     expression (arg);
 559                     if (more_call_expr_args_p (&iter))
 560                       pp_cxx_separate_with (this, ',');
 561                   }
 562               }
 563           }
 564         pp_cxx_right_paren (this);
 565       }
 566       if (code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t))
 567         {
 568           pp_cxx_separate_with (this, ',');
 569           postfix_expression (AGGR_INIT_EXPR_SLOT (t));
 570         }
 571       break;
 572
 573     case BASELINK:
 574     case VAR_DECL:
 575     case PARM_DECL:
 576     case FIELD_DECL:
 577     case FUNCTION_DECL:
 578     case OVERLOAD:
 579     case CONST_DECL:
 580     case TEMPLATE_DECL:
 581     case RESULT_DECL:
 582       primary_expression (t);
 583       break;
 584
 585     case DYNAMIC_CAST_EXPR:
 586     case STATIC_CAST_EXPR:
 587     case REINTERPRET_CAST_EXPR:
 588     case CONST_CAST_EXPR:
 589       if (code == DYNAMIC_CAST_EXPR)
 590         pp_cxx_ws_string (this, "dynamic_cast");
 591       else if (code == STATIC_CAST_EXPR)
 592         pp_cxx_ws_string (this, "static_cast");
 593       else if (code == REINTERPRET_CAST_EXPR)
 594         pp_cxx_ws_string (this, "reinterpret_cast");
 595       else
 596         pp_cxx_ws_string (this, "const_cast");
 597       pp_cxx_begin_template_argument_list (this);
 598       type_id (TREE_TYPE (t));
 599       pp_cxx_end_template_argument_list (this);
 600       pp_left_paren (this);
 601       expression (TREE_OPERAND (t, 0));
 602       pp_right_paren (this);
 603       break;
 604
 605     case EMPTY_CLASS_EXPR:
 606       type_id (TREE_TYPE (t));
 607       pp_left_paren (this);
 608       pp_right_paren (this);
 609       break;
 610
 611     case TYPEID_EXPR:
 612       pp_cxx_typeid_expression (this, t);
 613       break;
 614
 615     case PSEUDO_DTOR_EXPR:
 616       postfix_expression (TREE_OPERAND (t, 0));
 617       pp_cxx_dot (this);
 618       if (TREE_OPERAND (t, 1))
 619         {
 620           pp_cxx_qualified_id (this, TREE_OPERAND (t, 1));
 621           pp_cxx_colon_colon (this);
 622         }
 623       pp_complement (this);
 624       pp_cxx_unqualified_id (this, TREE_OPERAND (t, 2));
 625       break;
 626
 627     case ARROW_EXPR:
 628       postfix_expression (TREE_OPERAND (t, 0));
 629       pp_cxx_arrow (this);
 630       break;
 631
 632     default:
 633       c_pretty_printer::postfix_expression (t);
 634       break;
 635     }
 636 }
 637
 638 /* new-expression:
 639       ::(opt) new new-placement(opt) new-type-id new-initializer(opt)
 640       ::(opt) new new-placement(opt) ( type-id ) new-initializer(opt)
 641
 642    new-placement:
 643       ( expression-list )
 644
 645    new-type-id:
 646       type-specifier-seq new-declarator(opt)
 647
 648    new-declarator:
 649       ptr-operator new-declarator(opt)
 650       direct-new-declarator
 651
 652    direct-new-declarator
 653       [ expression ]
 654       direct-new-declarator [ constant-expression ]
 655
 656    new-initializer:
 657       ( expression-list(opt) )  */
 658
 659 static void
 660 pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
 661 {
 662   enum tree_code code = TREE_CODE (t);
 663   tree type = TREE_OPERAND (t, 1);
 664   tree init = TREE_OPERAND (t, 2);
 665   switch (code)
 666     {
 667     case NEW_EXPR:
 668     case VEC_NEW_EXPR:
 669       if (NEW_EXPR_USE_GLOBAL (t))
 670         pp_cxx_colon_colon (pp);
 671       pp_cxx_ws_string (pp, "new");
 672       if (TREE_OPERAND (t, 0))
 673         {
 674           pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
 675           pp_space (pp);
 676         }
 677       if (TREE_CODE (type) == ARRAY_REF)
 678         type = build_cplus_array_type
 679           (TREE_OPERAND (type, 0),
 680            build_index_type (fold_build2_loc (input_location,
 681                                           MINUS_EXPR, integer_type_node,
 682                                           TREE_OPERAND (type, 1),
 683                                           integer_one_node)));
 684       pp->type_id (type);
 685       if (init)
 686         {
 687           pp_left_paren (pp);
 688           if (TREE_CODE (init) == TREE_LIST)
 689             pp_c_expression_list (pp, init);
 690           else if (init == void_node)
 691             ;                   /* OK, empty initializer list.  */
 692           else
 693             pp->expression (init);
 694           pp_right_paren (pp);
 695         }
 696       break;
 697
 698     default:
 699       pp_unsupported_tree (pp, t);
 700     }
 701 }
 702
 703 /* delete-expression:
 704       ::(opt) delete cast-expression
 705       ::(opt) delete [ ] cast-expression   */
 706
 707 static void
 708 pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
 709 {
 710   enum tree_code code = TREE_CODE (t);
 711   switch (code)
 712     {
 713     case DELETE_EXPR:
 714     case VEC_DELETE_EXPR:
 715       if (DELETE_EXPR_USE_GLOBAL (t))
 716         pp_cxx_colon_colon (pp);
 717       pp_cxx_ws_string (pp, "delete");
 718       pp_space (pp);
 719       if (code == VEC_DELETE_EXPR
 720           || DELETE_EXPR_USE_VEC (t))
 721         {
 722           pp_left_bracket (pp);
 723           pp_right_bracket (pp);
 724           pp_space (pp);
 725         }
 726       pp_c_cast_expression (pp, TREE_OPERAND (t, 0));
 727       break;
 728
 729     default:
 730       pp_unsupported_tree (pp, t);
 731     }
 732 }
 733
 734 /* unary-expression:
 735       postfix-expression
 736       ++ cast-expression
 737       -- cast-expression
 738       unary-operator cast-expression
 739       sizeof unary-expression
 740       sizeof ( type-id )
 741       sizeof ... ( identifier )
 742       new-expression
 743       delete-expression
 744
 745    unary-operator: one of
 746       *   &   +   -  !
 747
 748    GNU extensions:
 749       __alignof__ unary-expression
 750       __alignof__ ( type-id )  */
 751
 752 void
 753 cxx_pretty_printer::unary_expression (tree t)
 754 {
 755   enum tree_code code = TREE_CODE (t);
 756   switch (code)
 757     {
 758     case NEW_EXPR:
 759     case VEC_NEW_EXPR:
 760       pp_cxx_new_expression (this, t);
 761       break;
 762
 763     case DELETE_EXPR:
 764     case VEC_DELETE_EXPR:
 765       pp_cxx_delete_expression (this, t);
 766       break;
 767
 768     case SIZEOF_EXPR:
 769       if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
 770         {
 771           pp_cxx_ws_string (this, "sizeof");
 772           pp_cxx_ws_string (this, "...");
 773           pp_cxx_whitespace (this);
 774           pp_cxx_left_paren (this);
 775           if (TYPE_P (TREE_OPERAND (t, 0)))
 776             type_id (TREE_OPERAND (t, 0));
 777           else
 778             unary_expression (TREE_OPERAND (t, 0));
 779           pp_cxx_right_paren (this);
 780           break;
 781         }
 782       /* Fall through  */
 783
 784     case ALIGNOF_EXPR:
 785       pp_cxx_ws_string (this, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
 786       pp_cxx_whitespace (this);
 787       if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
 788         {
 789           pp_cxx_left_paren (this);
 790           type_id (TREE_TYPE (TREE_OPERAND (t, 0)));
 791           pp_cxx_right_paren (this);
 792         }
 793       else if (TYPE_P (TREE_OPERAND (t, 0)))
 794         {
 795           pp_cxx_left_paren (this);
 796           type_id (TREE_OPERAND (t, 0));
 797           pp_cxx_right_paren (this);
 798         }
 799       else
 800         unary_expression (TREE_OPERAND (t, 0));
 801       break;
 802
 803     case AT_ENCODE_EXPR:
 804       pp_cxx_ws_string (this, "@encode");
 805       pp_cxx_whitespace (this);
 806       pp_cxx_left_paren (this);
 807       type_id (TREE_OPERAND (t, 0));
 808       pp_cxx_right_paren (this);
 809       break;
 810
 811     case NOEXCEPT_EXPR:
 812       pp_cxx_ws_string (this, "noexcept");
 813       pp_cxx_whitespace (this);
 814       pp_cxx_left_paren (this);
 815       expression (TREE_OPERAND (t, 0));
 816       pp_cxx_right_paren (this);
 817       break;
 818
 819     case UNARY_PLUS_EXPR:
 820       pp_plus (this);
 821       pp_cxx_cast_expression (this, TREE_OPERAND (t, 0));
 822       break;
 823
 824     default:
 825       c_pretty_printer::unary_expression (t);
 826       break;
 827     }
 828 }
 829
 830 /* cast-expression:
 831       unary-expression
 832       ( type-id ) cast-expression  */
 833
 834 static void
 835 pp_cxx_cast_expression (cxx_pretty_printer *pp, tree t)
 836 {
 837   switch (TREE_CODE (t))
 838     {
 839     case CAST_EXPR:
 840     case IMPLICIT_CONV_EXPR:
 841       pp->type_id (TREE_TYPE (t));
 842       pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
 843       break;
 844
 845     default:
 846       pp_c_cast_expression (pp, t);
 847       break;
 848     }
 849 }
 850
 851 /* pm-expression:
 852       cast-expression
 853       pm-expression .* cast-expression
 854       pm-expression ->* cast-expression  */
 855
 856 static void
 857 pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t)
 858 {
 859   switch (TREE_CODE (t))
 860     {
 861       /* Handle unfortunate OFFSET_REF overloading here.  */
 862     case OFFSET_REF:
 863       if (TYPE_P (TREE_OPERAND (t, 0)))
 864         {
 865           pp_cxx_qualified_id (pp, t);
 866           break;
 867         }
 868       /* Fall through.  */
 869     case MEMBER_REF:
 870     case DOTSTAR_EXPR:
 871       pp_cxx_pm_expression (pp, TREE_OPERAND (t, 0));
 872       if (TREE_CODE (t) == MEMBER_REF)
 873         pp_cxx_arrow (pp);
 874       else
 875         pp_cxx_dot (pp);
 876       pp_star(pp);
 877       pp_cxx_cast_expression (pp, TREE_OPERAND (t, 1));
 878       break;
 879
 880
 881     default:
 882       pp_cxx_cast_expression (pp, t);
 883       break;
 884     }
 885 }
 886
 887 /* multiplicative-expression:
 888       pm-expression
 889       multiplicative-expression * pm-expression
 890       multiplicative-expression / pm-expression
 891       multiplicative-expression % pm-expression  */
 892
 893 void
 894 cxx_pretty_printer::multiplicative_expression (tree e)
 895 {
 896   enum tree_code code = TREE_CODE (e);
 897   switch (code)
 898     {
 899     case MULT_EXPR:
 900     case TRUNC_DIV_EXPR:
 901     case TRUNC_MOD_EXPR:
 902     case EXACT_DIV_EXPR:
 903     case RDIV_EXPR:
 904       multiplicative_expression (TREE_OPERAND (e, 0));
 905       pp_space (this);
 906       if (code == MULT_EXPR)
 907         pp_star (this);
 908       else if (code != TRUNC_MOD_EXPR)
 909         pp_slash (this);
 910       else
 911         pp_modulo (this);
 912       pp_space (this);
 913       pp_cxx_pm_expression (this, TREE_OPERAND (e, 1));
 914       break;
 915
 916     default:
 917       pp_cxx_pm_expression (this, e);
 918       break;
 919     }
 920 }
 921
 922 /* conditional-expression:
 923       logical-or-expression
 924       logical-or-expression ?  expression  : assignment-expression  */
 925
 926 void
 927 cxx_pretty_printer::conditional_expression (tree e)
 928 {
 929   if (TREE_CODE (e) == COND_EXPR)
 930     {
 931       pp_c_logical_or_expression (this, TREE_OPERAND (e, 0));
 932       pp_space (this);
 933       pp_question (this);
 934       pp_space (this);
 935       expression (TREE_OPERAND (e, 1));
 936       pp_space (this);
 937       assignment_expression (TREE_OPERAND (e, 2));
 938     }
 939   else
 940     pp_c_logical_or_expression (this, e);
 941 }
 942
 943 /* Pretty-print a compound assignment operator token as indicated by T.  */
 944
 945 static void
 946 pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t)
 947 {
 948   const char *op;
 949
 950   switch (TREE_CODE (t))
 951     {
 952     case NOP_EXPR:
 953       op = "=";
 954       break;
 955
 956     case PLUS_EXPR:
 957       op = "+=";
 958       break;
 959
 960     case MINUS_EXPR:
 961       op = "-=";
 962       break;
 963
 964     case TRUNC_DIV_EXPR:
 965       op = "/=";
 966       break;
 967
 968     case TRUNC_MOD_EXPR:
 969       op = "%=";
 970       break;
 971
 972     default:
 973       op = get_tree_code_name (TREE_CODE (t));
 974       break;
 975     }
 976
 977   pp_cxx_ws_string (pp, op);
 978 }
 979
 980
 981 /* assignment-expression:
 982       conditional-expression
 983       logical-or-expression assignment-operator assignment-expression
 984       throw-expression
 985
 986    throw-expression:
 987        throw assignment-expression(opt)
 988
 989    assignment-operator: one of
 990       =    *=    /=    %=    +=    -=    >>=    <<=    &=    ^=    |=  */
 991
 992 void
 993 cxx_pretty_printer::assignment_expression (tree e)
 994 {
 995   switch (TREE_CODE (e))
 996     {
 997     case MODIFY_EXPR:
 998     case INIT_EXPR:
 999       pp_c_logical_or_expression (this, TREE_OPERAND (e, 0));
1000       pp_space (this);
1001       pp_equal (this);
1002       pp_space (this);
1003       assignment_expression (TREE_OPERAND (e, 1));
1004       break;
1005
1006     case THROW_EXPR:
1007       pp_cxx_ws_string (this, "throw");
1008       if (TREE_OPERAND (e, 0))
1009         assignment_expression (TREE_OPERAND (e, 0));
1010       break;
1011
1012     case MODOP_EXPR:
1013       pp_c_logical_or_expression (this, TREE_OPERAND (e, 0));
1014       pp_cxx_assignment_operator (this, TREE_OPERAND (e, 1));
1015       assignment_expression (TREE_OPERAND (e, 2));
1016       break;
1017
1018     default:
1019       conditional_expression (e);
1020       break;
1021     }
1022 }
1023
1024 void
1025 cxx_pretty_printer::expression (tree t)
1026 {
1027   switch (TREE_CODE (t))
1028     {
1029     case STRING_CST:
1030     case VOID_CST:
1031     case INTEGER_CST:
1032     case REAL_CST:
1033     case COMPLEX_CST:
1034       constant (t);
1035       break;
1036
1037     case USERDEF_LITERAL:
1038       pp_cxx_userdef_literal (this, t);
1039       break;
1040
1041     case RESULT_DECL:
1042       pp_cxx_unqualified_id (this, t);
1043       break;
1044
1045 #if 0
1046     case OFFSET_REF:
1047 #endif
1048     case SCOPE_REF:
1049     case PTRMEM_CST:
1050       pp_cxx_qualified_id (this, t);
1051       break;
1052
1053     case OVERLOAD:
1054       t = OVL_FIRST (t);
1055       /* FALLTHRU */
1056     case VAR_DECL:
1057     case PARM_DECL:
1058     case FIELD_DECL:
1059     case CONST_DECL:
1060     case FUNCTION_DECL:
1061     case BASELINK:
1062     case TEMPLATE_DECL:
1063     case TEMPLATE_TYPE_PARM:
1064     case TEMPLATE_PARM_INDEX:
1065     case TEMPLATE_TEMPLATE_PARM:
1066     case STMT_EXPR:
1067     case REQUIRES_EXPR:
1068       primary_expression (t);
1069       break;
1070
1071     case CALL_EXPR:
1072     case DYNAMIC_CAST_EXPR:
1073     case STATIC_CAST_EXPR:
1074     case REINTERPRET_CAST_EXPR:
1075     case CONST_CAST_EXPR:
1076 #if 0
1077     case MEMBER_REF:
1078 #endif
1079     case EMPTY_CLASS_EXPR:
1080     case TYPEID_EXPR:
1081     case PSEUDO_DTOR_EXPR:
1082     case AGGR_INIT_EXPR:
1083     case ARROW_EXPR:
1084       postfix_expression (t);
1085       break;
1086
1087     case NEW_EXPR:
1088     case VEC_NEW_EXPR:
1089       pp_cxx_new_expression (this, t);
1090       break;
1091
1092     case DELETE_EXPR:
1093     case VEC_DELETE_EXPR:
1094       pp_cxx_delete_expression (this, t);
1095       break;
1096
1097     case SIZEOF_EXPR:
1098     case ALIGNOF_EXPR:
1099     case NOEXCEPT_EXPR:
1100     case UNARY_PLUS_EXPR:
1101       unary_expression (t);
1102       break;
1103
1104     case CAST_EXPR:
1105     case IMPLICIT_CONV_EXPR:
1106       pp_cxx_cast_expression (this, t);
1107       break;
1108
1109     case OFFSET_REF:
1110     case MEMBER_REF:
1111     case DOTSTAR_EXPR:
1112       pp_cxx_pm_expression (this, t);
1113       break;
1114
1115     case MULT_EXPR:
1116     case TRUNC_DIV_EXPR:
1117     case TRUNC_MOD_EXPR:
1118     case EXACT_DIV_EXPR:
1119     case RDIV_EXPR:
1120       multiplicative_expression (t);
1121       break;
1122
1123     case COND_EXPR:
1124       conditional_expression (t);
1125       break;
1126
1127     case MODIFY_EXPR:
1128     case INIT_EXPR:
1129     case THROW_EXPR:
1130     case MODOP_EXPR:
1131       assignment_expression (t);
1132       break;
1133
1134     case NON_DEPENDENT_EXPR:
1135     case MUST_NOT_THROW_EXPR:
1136       expression (TREE_OPERAND (t, 0));
1137       break;
1138
1139     case EXPR_PACK_EXPANSION:
1140       expression (PACK_EXPANSION_PATTERN (t));
1141       pp_cxx_ws_string (this, "...");
1142       break;
1143
1144     case UNARY_LEFT_FOLD_EXPR:
1145       pp_cxx_unary_left_fold_expression (this, t);
1146       break;
1147
1148     case UNARY_RIGHT_FOLD_EXPR:
1149       pp_cxx_unary_right_fold_expression (this, t);
1150     break;
1151
1152     case BINARY_LEFT_FOLD_EXPR:
1153     case BINARY_RIGHT_FOLD_EXPR:
1154       pp_cxx_binary_fold_expression (this, t);
1155       break;
1156
1157     case TEMPLATE_ID_EXPR:
1158       pp_cxx_template_id (this, t);
1159       break;
1160
1161     case NONTYPE_ARGUMENT_PACK:
1162       {
1163         tree args = ARGUMENT_PACK_ARGS (t);
1164         int i, len = TREE_VEC_LENGTH (args);
1165         for (i = 0; i < len; ++i)
1166           {
1167             if (i > 0)
1168               pp_cxx_separate_with (this, ',');
1169             expression (TREE_VEC_ELT (args, i));
1170           }
1171       }
1172       break;
1173
1174     case LAMBDA_EXPR:
1175       pp_cxx_ws_string (this, "<lambda>");
1176       break;
1177
1178     case TRAIT_EXPR:
1179       pp_cxx_trait_expression (this, t);
1180       break;
1181
1182     case PRED_CONSTR:
1183     case CHECK_CONSTR:
1184     case EXPR_CONSTR:
1185     case TYPE_CONSTR:
1186     case ICONV_CONSTR:
1187     case DEDUCT_CONSTR:
1188     case EXCEPT_CONSTR:
1189     case PARM_CONSTR:
1190     case CONJ_CONSTR:
1191     case DISJ_CONSTR:
1192       pp_cxx_constraint (this, t);
1193       break;
1194
1195     case PAREN_EXPR:
1196       pp_cxx_left_paren (this);
1197       expression (TREE_OPERAND (t, 0));
1198       pp_cxx_right_paren (this);
1199       break;
1200
1201     default:
1202       c_pretty_printer::expression (t);
1203       break;
1204     }
1205 }
1206
1207
1208 /* Declarations.  */
1209
1210 /* function-specifier:
1211       inline
1212       virtual
1213       explicit   */
1214
1215 void
1216 cxx_pretty_printer::function_specifier (tree t)
1217 {
1218   switch (TREE_CODE (t))
1219     {
1220     case FUNCTION_DECL:
1221       if (DECL_VIRTUAL_P (t))
1222         pp_cxx_ws_string (this, "virtual");
1223       else if (DECL_CONSTRUCTOR_P (t) && DECL_NONCONVERTING_P (t))
1224         pp_cxx_ws_string (this, "explicit");
1225       else
1226         c_pretty_printer::function_specifier (t);
1227
1228     default:
1229       break;
1230     }
1231 }
1232
1233 /* decl-specifier-seq:
1234       decl-specifier-seq(opt) decl-specifier
1235
1236    decl-specifier:
1237       storage-class-specifier
1238       type-specifier
1239       function-specifier
1240       friend
1241       typedef  */
1242
1243 void
1244 cxx_pretty_printer::declaration_specifiers (tree t)
1245 {
1246   switch (TREE_CODE (t))
1247     {
1248     case VAR_DECL:
1249     case PARM_DECL:
1250     case CONST_DECL:
1251     case FIELD_DECL:
1252       storage_class_specifier (t);
1253       declaration_specifiers (TREE_TYPE (t));
1254       break;
1255
1256     case TYPE_DECL:
1257       pp_cxx_ws_string (this, "typedef");
1258       declaration_specifiers (TREE_TYPE (t));
1259       break;
1260
1261     case FUNCTION_DECL:
1262       /* Constructors don't have return types.  And conversion functions
1263          do not have a type-specifier in their return types.  */
1264       if (DECL_CONSTRUCTOR_P (t) || DECL_CONV_FN_P (t))
1265         function_specifier (t);
1266       else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
1267         declaration_specifiers (TREE_TYPE (TREE_TYPE (t)));
1268       else
1269         c_pretty_printer::declaration_specifiers (t);
1270       break;
1271     default:
1272         c_pretty_printer::declaration_specifiers (t);
1273       break;
1274     }
1275 }
1276
1277 /* simple-type-specifier:
1278       ::(opt) nested-name-specifier(opt) type-name
1279       ::(opt) nested-name-specifier(opt) template(opt) template-id
1280       char
1281       wchar_t
1282       bool
1283       short
1284       int
1285       long
1286       signed
1287       unsigned
1288       float
1289       double
1290       void  */
1291
1292 void
1293 cxx_pretty_printer::simple_type_specifier (tree t)
1294 {
1295   switch (TREE_CODE (t))
1296     {
1297     case RECORD_TYPE:
1298     case UNION_TYPE:
1299     case ENUMERAL_TYPE:
1300       pp_cxx_qualified_id (this, t);
1301       break;
1302
1303     case TEMPLATE_TYPE_PARM:
1304     case TEMPLATE_TEMPLATE_PARM:
1305     case TEMPLATE_PARM_INDEX:
1306     case BOUND_TEMPLATE_TEMPLATE_PARM:
1307       pp_cxx_unqualified_id (this, t);
1308       break;
1309
1310     case TYPENAME_TYPE:
1311       pp_cxx_ws_string (this, "typename");
1312       pp_cxx_nested_name_specifier (this, TYPE_CONTEXT (t));
1313       pp_cxx_unqualified_id (this, TYPE_NAME (t));
1314       break;
1315
1316     default:
1317       c_pretty_printer::simple_type_specifier (t);
1318       break;
1319     }
1320 }
1321
1322 /* type-specifier-seq:
1323       type-specifier type-specifier-seq(opt)
1324
1325    type-specifier:
1326       simple-type-specifier
1327       class-specifier
1328       enum-specifier
1329       elaborated-type-specifier
1330       cv-qualifier   */
1331
1332 static void
1333 pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t)
1334 {
1335   switch (TREE_CODE (t))
1336     {
1337     case TEMPLATE_DECL:
1338     case TEMPLATE_TYPE_PARM:
1339     case TEMPLATE_TEMPLATE_PARM:
1340     case TYPE_DECL:
1341     case BOUND_TEMPLATE_TEMPLATE_PARM:
1342       pp_cxx_cv_qualifier_seq (pp, t);
1343       pp->simple_type_specifier (t);
1344       break;
1345
1346     case METHOD_TYPE:
1347       pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
1348       pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
1349       pp_cxx_nested_name_specifier (pp, TYPE_METHOD_BASETYPE (t));
1350       break;
1351
1352     case DECLTYPE_TYPE:
1353       pp_cxx_ws_string (pp, "decltype");
1354       pp_cxx_left_paren (pp);
1355       pp->expression (DECLTYPE_TYPE_EXPR (t));
1356       pp_cxx_right_paren (pp);
1357       break;
1358
1359     case RECORD_TYPE:
1360       if (TYPE_PTRMEMFUNC_P (t))
1361         {
1362           tree pfm = TYPE_PTRMEMFUNC_FN_TYPE (t);
1363           pp->declaration_specifiers (TREE_TYPE (TREE_TYPE (pfm)));
1364           pp_cxx_whitespace (pp);
1365           pp_cxx_ptr_operator (pp, t);
1366           break;
1367         }
1368       /* fall through */
1369
1370     default:
1371       if (!(TREE_CODE (t) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (t)))
1372         pp_c_specifier_qualifier_list (pp, t);
1373     }
1374 }
1375
1376 /* ptr-operator:
1377       * cv-qualifier-seq(opt)
1378       &
1379       ::(opt) nested-name-specifier * cv-qualifier-seq(opt)  */
1380
1381 static void
1382 pp_cxx_ptr_operator (cxx_pretty_printer *pp, tree t)
1383 {
1384   if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
1385     t = TREE_TYPE (t);
1386   switch (TREE_CODE (t))
1387     {
1388     case REFERENCE_TYPE:
1389     case POINTER_TYPE:
1390       if (TYPE_PTR_OR_PTRMEM_P (TREE_TYPE (t)))
1391         pp_cxx_ptr_operator (pp, TREE_TYPE (t));
1392       pp_c_attributes_display (pp, TYPE_ATTRIBUTES (TREE_TYPE (t)));
1393       if (TYPE_PTR_P (t))
1394         {
1395           pp_star (pp);
1396           pp_cxx_cv_qualifier_seq (pp, t);
1397         }
1398       else
1399         pp_ampersand (pp);
1400       break;
1401
1402     case RECORD_TYPE:
1403       if (TYPE_PTRMEMFUNC_P (t))
1404         {
1405           pp_cxx_left_paren (pp);
1406           pp_cxx_nested_name_specifier (pp, TYPE_PTRMEMFUNC_OBJECT_TYPE (t));
1407           pp_star (pp);
1408           break;
1409         }
1410       /* FALLTHRU */
1411     case OFFSET_TYPE:
1412       if (TYPE_PTRMEM_P (t))
1413         {
1414           if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
1415             pp_cxx_left_paren (pp);
1416           pp_cxx_nested_name_specifier (pp, TYPE_PTRMEM_CLASS_TYPE (t));
1417           pp_star (pp);
1418           pp_cxx_cv_qualifier_seq (pp, t);
1419           break;
1420         }
1421       /* fall through.  */
1422
1423     default:
1424       pp_unsupported_tree (pp, t);
1425       break;
1426     }
1427 }
1428
1429 static inline tree
1430 pp_cxx_implicit_parameter_type (tree mf)
1431 {
1432   return class_of_this_parm (TREE_TYPE (mf));
1433 }
1434
1435 /*
1436    parameter-declaration:
1437       decl-specifier-seq declarator
1438       decl-specifier-seq declarator = assignment-expression
1439       decl-specifier-seq abstract-declarator(opt)
1440       decl-specifier-seq abstract-declarator(opt) assignment-expression  */
1441
1442 static inline void
1443 pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t)
1444 {
1445   pp->declaration_specifiers (t);
1446   if (TYPE_P (t))
1447     pp->abstract_declarator (t);
1448   else
1449     pp->declarator (t);
1450 }
1451
1452 /* parameter-declaration-clause:
1453       parameter-declaration-list(opt) ...(opt)
1454       parameter-declaration-list , ...
1455
1456    parameter-declaration-list:
1457       parameter-declaration
1458       parameter-declaration-list , parameter-declaration  */
1459
1460 static void
1461 pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t)
1462 {
1463   tree args;
1464   tree types;
1465   bool abstract;
1466
1467   // For a requires clause or the explicit printing of a parameter list
1468   // we expect T to be a chain of PARM_DECLs. Otherwise, the list of
1469   // args and types are taken from the function decl T.
1470   if (TREE_CODE (t) == PARM_DECL)
1471     {
1472       args = t;
1473       types = t;
1474       abstract = false;
1475     }
1476   else
1477     {
1478       bool type_p = TYPE_P (t);
1479       args = type_p ? NULL : FUNCTION_FIRST_USER_PARM (t);
1480       types = type_p ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t);
1481       abstract = args == NULL || pp->flags & pp_c_flag_abstract;
1482     }
1483   bool first = true;
1484
1485   /* Skip artificial parameter for nonstatic member functions.  */
1486   if (TREE_CODE (t) == METHOD_TYPE)
1487     types = TREE_CHAIN (types);
1488
1489   pp_cxx_left_paren (pp);
1490   for (; args; args = TREE_CHAIN (args), types = TREE_CHAIN (types))
1491     {
1492       if (!first)
1493         pp_cxx_separate_with (pp, ',');
1494       first = false;
1495       pp_cxx_parameter_declaration (pp, abstract ? TREE_VALUE (types) : args);
1496       if (!abstract && pp->flags & pp_cxx_flag_default_argument)
1497         {
1498           pp_cxx_whitespace (pp);
1499           pp_equal (pp);
1500           pp_cxx_whitespace (pp);
1501           pp->assignment_expression (TREE_PURPOSE (types));
1502         }
1503     }
1504   pp_cxx_right_paren (pp);
1505 }
1506
1507 /* exception-specification:
1508       throw ( type-id-list(opt) )
1509
1510    type-id-list
1511       type-id
1512       type-id-list , type-id   */
1513
1514 static void
1515 pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t)
1516 {
1517   tree ex_spec = TYPE_RAISES_EXCEPTIONS (t);
1518   bool need_comma = false;
1519
1520   if (ex_spec == NULL)
1521     return;
1522   if (TREE_PURPOSE (ex_spec))
1523     {
1524       pp_cxx_ws_string (pp, "noexcept");
1525       pp_cxx_whitespace (pp);
1526       pp_cxx_left_paren (pp);
1527       if (DEFERRED_NOEXCEPT_SPEC_P (ex_spec))
1528         pp_cxx_ws_string (pp, "<uninstantiated>");
1529       else
1530         pp->expression (TREE_PURPOSE (ex_spec));
1531       pp_cxx_right_paren (pp);
1532       return;
1533     }
1534   pp_cxx_ws_string (pp, "throw");
1535   pp_cxx_left_paren (pp);
1536   for (; ex_spec && TREE_VALUE (ex_spec); ex_spec = TREE_CHAIN (ex_spec))
1537     {
1538       tree type = TREE_VALUE (ex_spec);
1539       tree argpack = NULL_TREE;
1540       int i, len = 1;
1541
1542       if (ARGUMENT_PACK_P (type))
1543         {
1544           argpack = ARGUMENT_PACK_ARGS (type);
1545           len = TREE_VEC_LENGTH (argpack);
1546         }
1547
1548       for (i = 0; i < len; ++i)
1549         {
1550           if (argpack)
1551             type = TREE_VEC_ELT (argpack, i);
1552
1553           if (need_comma)
1554             pp_cxx_separate_with (pp, ',');
1555           else
1556             need_comma = true;
1557
1558           pp->type_id (type);
1559         }
1560     }
1561   pp_cxx_right_paren (pp);
1562 }
1563
1564 /* direct-declarator:
1565       declarator-id
1566       direct-declarator ( parameter-declaration-clause ) cv-qualifier-seq(opt)
1567                                             exception-specification(opt)
1568       direct-declaration [ constant-expression(opt) ]
1569       ( declarator )  */
1570
1571 void
1572 cxx_pretty_printer::direct_declarator (tree t)
1573 {
1574   switch (TREE_CODE (t))
1575     {
1576     case VAR_DECL:
1577     case PARM_DECL:
1578     case CONST_DECL:
1579     case FIELD_DECL:
1580       if (DECL_NAME (t))
1581         {
1582           pp_cxx_space_for_pointer_operator (this, TREE_TYPE (t));
1583
1584           if ((TREE_CODE (t) == PARM_DECL && DECL_PACK_P (t))
1585               || template_parameter_pack_p (t))
1586             /* A function parameter pack or non-type template
1587                parameter pack.  */
1588             pp_cxx_ws_string (this, "...");
1589
1590           id_expression (DECL_NAME (t));
1591         }
1592       abstract_declarator (TREE_TYPE (t));
1593       break;
1594
1595     case FUNCTION_DECL:
1596       pp_cxx_space_for_pointer_operator (this, TREE_TYPE (TREE_TYPE (t)));
1597       expression (t);
1598       pp_cxx_parameter_declaration_clause (this, t);
1599
1600       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
1601         {
1602           padding = pp_before;
1603           pp_cxx_cv_qualifier_seq (this, pp_cxx_implicit_parameter_type (t));
1604         }
1605
1606       pp_cxx_exception_specification (this, TREE_TYPE (t));
1607       break;
1608
1609     case TYPENAME_TYPE:
1610     case TEMPLATE_DECL:
1611     case TEMPLATE_TYPE_PARM:
1612     case TEMPLATE_PARM_INDEX:
1613     case TEMPLATE_TEMPLATE_PARM:
1614       break;
1615
1616     default:
1617       c_pretty_printer::direct_declarator (t);
1618       break;
1619     }
1620 }
1621
1622 /* declarator:
1623    direct-declarator
1624    ptr-operator declarator  */
1625
1626 void
1627 cxx_pretty_printer::declarator (tree t)
1628 {
1629   direct_declarator (t);
1630
1631   // Print a requires clause.
1632   if (flag_concepts)
1633     if (tree ci = get_constraints (t))
1634       if (tree reqs = CI_DECLARATOR_REQS (ci))
1635         pp_cxx_requires_clause (this, reqs);
1636 }
1637
1638 /* ctor-initializer:
1639       : mem-initializer-list
1640
1641    mem-initializer-list:
1642       mem-initializer
1643       mem-initializer , mem-initializer-list
1644
1645    mem-initializer:
1646       mem-initializer-id ( expression-list(opt) )
1647
1648    mem-initializer-id:
1649       ::(opt) nested-name-specifier(opt) class-name
1650       identifier   */
1651
1652 static void
1653 pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t)
1654 {
1655   t = TREE_OPERAND (t, 0);
1656   pp_cxx_whitespace (pp);
1657   pp_colon (pp);
1658   pp_cxx_whitespace (pp);
1659   for (; t; t = TREE_CHAIN (t))
1660     {
1661       tree purpose = TREE_PURPOSE (t);
1662       bool is_pack = PACK_EXPANSION_P (purpose);
1663
1664       if (is_pack)
1665         pp->primary_expression (PACK_EXPANSION_PATTERN (purpose));
1666       else
1667         pp->primary_expression (purpose);
1668       pp_cxx_call_argument_list (pp, TREE_VALUE (t));
1669       if (is_pack)
1670         pp_cxx_ws_string (pp, "...");
1671       if (TREE_CHAIN (t))
1672         pp_cxx_separate_with (pp, ',');
1673     }
1674 }
1675
1676 /* function-definition:
1677       decl-specifier-seq(opt) declarator ctor-initializer(opt) function-body
1678       decl-specifier-seq(opt) declarator function-try-block  */
1679
1680 static void
1681 pp_cxx_function_definition (cxx_pretty_printer *pp, tree t)
1682 {
1683   tree saved_scope = pp->enclosing_scope;
1684   pp->declaration_specifiers (t);
1685   pp->declarator (t);
1686   pp_needs_newline (pp) = true;
1687   pp->enclosing_scope = DECL_CONTEXT (t);
1688   if (DECL_SAVED_TREE (t))
1689     pp->statement (DECL_SAVED_TREE (t));
1690   else
1691     pp_cxx_semicolon (pp);
1692   pp_newline_and_flush (pp);
1693   pp->enclosing_scope = saved_scope;
1694 }
1695
1696 /* abstract-declarator:
1697       ptr-operator abstract-declarator(opt)
1698       direct-abstract-declarator  */
1699
1700 void
1701 cxx_pretty_printer::abstract_declarator (tree t)
1702 {
1703   if (TYPE_PTRMEM_P (t))
1704     pp_cxx_right_paren (this);
1705   else if (INDIRECT_TYPE_P (t))
1706     {
1707       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
1708           || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
1709         pp_cxx_right_paren (this);
1710       t = TREE_TYPE (t);
1711     }
1712   direct_abstract_declarator (t);
1713 }
1714
1715 /* direct-abstract-declarator:
1716       direct-abstract-declarator(opt) ( parameter-declaration-clause )
1717                            cv-qualifier-seq(opt) exception-specification(opt)
1718       direct-abstract-declarator(opt) [ constant-expression(opt) ]
1719       ( abstract-declarator )  */
1720
1721 void
1722 cxx_pretty_printer::direct_abstract_declarator (tree t)
1723 {
1724   switch (TREE_CODE (t))
1725     {
1726     case REFERENCE_TYPE:
1727       abstract_declarator (t);
1728       break;
1729
1730     case RECORD_TYPE:
1731       if (TYPE_PTRMEMFUNC_P (t))
1732         direct_abstract_declarator (TYPE_PTRMEMFUNC_FN_TYPE (t));
1733       break;
1734
1735     case METHOD_TYPE:
1736     case FUNCTION_TYPE:
1737       pp_cxx_parameter_declaration_clause (this, t);
1738       direct_abstract_declarator (TREE_TYPE (t));
1739       if (TREE_CODE (t) == METHOD_TYPE)
1740         {
1741           padding = pp_before;
1742           pp_cxx_cv_qualifier_seq (this, class_of_this_parm (t));
1743         }
1744       pp_cxx_exception_specification (this, t);
1745       break;
1746
1747     case TYPENAME_TYPE:
1748     case TEMPLATE_TYPE_PARM:
1749     case TEMPLATE_TEMPLATE_PARM:
1750     case BOUND_TEMPLATE_TEMPLATE_PARM:
1751     case UNBOUND_CLASS_TEMPLATE:
1752       break;
1753
1754     default:
1755       c_pretty_printer::direct_abstract_declarator (t);
1756       break;
1757     }
1758 }
1759
1760 /* type-id:
1761      type-specifier-seq abstract-declarator(opt) */
1762
1763 void
1764 cxx_pretty_printer::type_id (tree t)
1765 {
1766   pp_flags saved_flags = flags;
1767   flags |= pp_c_flag_abstract;
1768
1769   switch (TREE_CODE (t))
1770     {
1771     case TYPE_DECL:
1772     case UNION_TYPE:
1773     case RECORD_TYPE:
1774     case ENUMERAL_TYPE:
1775     case TYPENAME_TYPE:
1776     case BOUND_TEMPLATE_TEMPLATE_PARM:
1777     case UNBOUND_CLASS_TEMPLATE:
1778     case TEMPLATE_TEMPLATE_PARM:
1779     case TEMPLATE_TYPE_PARM:
1780     case TEMPLATE_PARM_INDEX:
1781     case TEMPLATE_DECL:
1782     case TYPEOF_TYPE:
1783     case UNDERLYING_TYPE:
1784     case DECLTYPE_TYPE:
1785     case TEMPLATE_ID_EXPR:
1786       pp_cxx_type_specifier_seq (this, t);
1787       break;
1788
1789     case TYPE_PACK_EXPANSION:
1790       type_id (PACK_EXPANSION_PATTERN (t));
1791       pp_cxx_ws_string (this, "...");
1792       break;
1793
1794     default:
1795       c_pretty_printer::type_id (t);
1796       break;
1797     }
1798
1799   flags = saved_flags;
1800 }
1801
1802 /* template-argument-list:
1803       template-argument ...(opt)
1804       template-argument-list, template-argument ...(opt)
1805
1806    template-argument:
1807       assignment-expression
1808       type-id
1809       template-name  */
1810
1811 static void
1812 pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
1813 {
1814   int i;
1815   bool need_comma = false;
1816
1817   if (t == NULL)
1818     return;
1819   for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
1820     {
1821       tree arg = TREE_VEC_ELT (t, i);
1822       tree argpack = NULL_TREE;
1823       int idx, len = 1;
1824
1825       if (ARGUMENT_PACK_P (arg))
1826         {
1827           argpack = ARGUMENT_PACK_ARGS (arg);
1828           len = TREE_VEC_LENGTH (argpack);
1829         }
1830
1831       for (idx = 0; idx < len; idx++)
1832         {
1833           if (argpack)
1834             arg = TREE_VEC_ELT (argpack, idx);
1835
1836           if (need_comma)
1837             pp_cxx_separate_with (pp, ',');
1838           else
1839             need_comma = true;
1840
1841           if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
1842                                && TYPE_P (DECL_TEMPLATE_RESULT (arg))))
1843             pp->type_id (arg);
1844           else
1845             pp->expression (arg);
1846         }
1847     }
1848 }
1849
1850
1851 static void
1852 pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t)
1853 {
1854   t = DECL_EXPR_DECL (t);
1855   pp_cxx_type_specifier_seq (pp, t);
1856   if (TYPE_P (t))
1857     pp->abstract_declarator (t);
1858   else
1859     pp->declarator (t);
1860 }
1861
1862 /* Statements.  */
1863
1864 void
1865 cxx_pretty_printer::statement (tree t)
1866 {
1867   switch (TREE_CODE (t))
1868     {
1869     case CTOR_INITIALIZER:
1870       pp_cxx_ctor_initializer (this, t);
1871       break;
1872
1873     case USING_STMT:
1874       pp_cxx_ws_string (this, "using");
1875       pp_cxx_ws_string (this, "namespace");
1876       if (DECL_CONTEXT (t))
1877         pp_cxx_nested_name_specifier (this, DECL_CONTEXT (t));
1878       pp_cxx_qualified_id (this, USING_STMT_NAMESPACE (t));
1879       break;
1880
1881     case USING_DECL:
1882       pp_cxx_ws_string (this, "using");
1883       pp_cxx_nested_name_specifier (this, USING_DECL_SCOPE (t));
1884       pp_cxx_unqualified_id (this, DECL_NAME (t));
1885       break;
1886
1887     case EH_SPEC_BLOCK:
1888       break;
1889
1890       /* try-block:
1891             try compound-statement handler-seq  */
1892     case TRY_BLOCK:
1893       pp_maybe_newline_and_indent (this, 0);
1894       pp_cxx_ws_string (this, "try");
1895       pp_newline_and_indent (this, 3);
1896       statement (TRY_STMTS (t));
1897       pp_newline_and_indent (this, -3);
1898       if (CLEANUP_P (t))
1899         ;
1900       else
1901         statement (TRY_HANDLERS (t));
1902       break;
1903
1904       /*
1905          handler-seq:
1906             handler handler-seq(opt)
1907
1908          handler:
1909          catch ( exception-declaration ) compound-statement
1910
1911          exception-declaration:
1912             type-specifier-seq declarator
1913             type-specifier-seq abstract-declarator
1914             ...   */
1915     case HANDLER:
1916       pp_cxx_ws_string (this, "catch");
1917       pp_cxx_left_paren (this);
1918       pp_cxx_exception_declaration (this, HANDLER_PARMS (t));
1919       pp_cxx_right_paren (this);
1920       pp_indentation (this) += 3;
1921       pp_needs_newline (this) = true;
1922       statement (HANDLER_BODY (t));
1923       pp_indentation (this) -= 3;
1924       pp_needs_newline (this) = true;
1925       break;
1926
1927       /* selection-statement:
1928             if ( expression ) statement
1929             if ( expression ) statement else statement  */
1930     case IF_STMT:
1931       pp_cxx_ws_string (this, "if");
1932       pp_cxx_whitespace (this);
1933       pp_cxx_left_paren (this);
1934       expression (IF_COND (t));
1935       pp_cxx_right_paren (this);
1936       pp_newline_and_indent (this, 2);
1937       statement (THEN_CLAUSE (t));
1938       pp_newline_and_indent (this, -2);
1939       if (ELSE_CLAUSE (t))
1940         {
1941           tree else_clause = ELSE_CLAUSE (t);
1942           pp_cxx_ws_string (this, "else");
1943           if (TREE_CODE (else_clause) == IF_STMT)
1944             pp_cxx_whitespace (this);
1945           else
1946             pp_newline_and_indent (this, 2);
1947           statement (else_clause);
1948           if (TREE_CODE (else_clause) != IF_STMT)
1949             pp_newline_and_indent (this, -2);
1950         }
1951       break;
1952
1953     case SWITCH_STMT:
1954       pp_cxx_ws_string (this, "switch");
1955       pp_space (this);
1956       pp_cxx_left_paren (this);
1957       expression (SWITCH_STMT_COND (t));
1958       pp_cxx_right_paren (this);
1959       pp_indentation (this) += 3;
1960       pp_needs_newline (this) = true;
1961       statement (SWITCH_STMT_BODY (t));
1962       pp_newline_and_indent (this, -3);
1963       break;
1964
1965       /* iteration-statement:
1966             while ( expression ) statement
1967             do statement while ( expression ) ;
1968             for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
1969             for ( declaration expression(opt) ; expression(opt) ) statement  */
1970     case WHILE_STMT:
1971       pp_cxx_ws_string (this, "while");
1972       pp_space (this);
1973       pp_cxx_left_paren (this);
1974       expression (WHILE_COND (t));
1975       pp_cxx_right_paren (this);
1976       pp_newline_and_indent (this, 3);
1977       statement (WHILE_BODY (t));
1978       pp_indentation (this) -= 3;
1979       pp_needs_newline (this) = true;
1980       break;
1981
1982     case DO_STMT:
1983       pp_cxx_ws_string (this, "do");
1984       pp_newline_and_indent (this, 3);
1985       statement (DO_BODY (t));
1986       pp_newline_and_indent (this, -3);
1987       pp_cxx_ws_string (this, "while");
1988       pp_space (this);
1989       pp_cxx_left_paren (this);
1990       expression (DO_COND (t));
1991       pp_cxx_right_paren (this);
1992       pp_cxx_semicolon (this);
1993       pp_needs_newline (this) = true;
1994       break;
1995
1996     case FOR_STMT:
1997       pp_cxx_ws_string (this, "for");
1998       pp_space (this);
1999       pp_cxx_left_paren (this);
2000       if (FOR_INIT_STMT (t))
2001         statement (FOR_INIT_STMT (t));
2002       else
2003         pp_cxx_semicolon (this);
2004       pp_needs_newline (this) = false;
2005       pp_cxx_whitespace (this);
2006       if (FOR_COND (t))
2007         expression (FOR_COND (t));
2008       pp_cxx_semicolon (this);
2009       pp_needs_newline (this) = false;
2010       pp_cxx_whitespace (this);
2011       if (FOR_EXPR (t))
2012         expression (FOR_EXPR (t));
2013       pp_cxx_right_paren (this);
2014       pp_newline_and_indent (this, 3);
2015       statement (FOR_BODY (t));
2016       pp_indentation (this) -= 3;
2017       pp_needs_newline (this) = true;
2018       break;
2019
2020     case RANGE_FOR_STMT:
2021       pp_cxx_ws_string (this, "for");
2022       pp_space (this);
2023       pp_cxx_left_paren (this);
2024       statement (RANGE_FOR_DECL (t));
2025       pp_space (this);
2026       pp_needs_newline (this) = false;
2027       pp_colon (this);
2028       pp_space (this);
2029       statement (RANGE_FOR_EXPR (t));
2030       pp_cxx_right_paren (this);
2031       pp_newline_and_indent (this, 3);
2032       statement (FOR_BODY (t));
2033       pp_indentation (this) -= 3;
2034       pp_needs_newline (this) = true;
2035       break;
2036
2037       /* jump-statement:
2038             goto identifier;
2039             continue ;
2040             return expression(opt) ;  */
2041     case BREAK_STMT:
2042     case CONTINUE_STMT:
2043       pp_string (this, TREE_CODE (t) == BREAK_STMT ? "break" : "continue");
2044       pp_cxx_semicolon (this);
2045       pp_needs_newline (this) = true;
2046       break;
2047
2048       /* expression-statement:
2049             expression(opt) ;  */
2050     case EXPR_STMT:
2051       expression (EXPR_STMT_EXPR (t));
2052       pp_cxx_semicolon (this);
2053       pp_needs_newline (this) = true;
2054       break;
2055
2056     case CLEANUP_STMT:
2057       pp_cxx_ws_string (this, "try");
2058       pp_newline_and_indent (this, 2);
2059       statement (CLEANUP_BODY (t));
2060       pp_newline_and_indent (this, -2);
2061       pp_cxx_ws_string (this, CLEANUP_EH_ONLY (t) ? "catch" : "finally");
2062       pp_newline_and_indent (this, 2);
2063       statement (CLEANUP_EXPR (t));
2064       pp_newline_and_indent (this, -2);
2065       break;
2066
2067     case STATIC_ASSERT:
2068       declaration (t);
2069       break;
2070
2071     default:
2072       c_pretty_printer::statement (t);
2073       break;
2074     }
2075 }
2076
2077 /* original-namespace-definition:
2078       namespace identifier { namespace-body }
2079
2080   As an edge case, we also handle unnamed namespace definition here.  */
2081
2082 static void
2083 pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t)
2084 {
2085   pp_cxx_ws_string (pp, "namespace");
2086   if (DECL_CONTEXT (t))
2087     pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
2088   if (DECL_NAME (t))
2089     pp_cxx_unqualified_id (pp, t);
2090   pp_cxx_whitespace (pp);
2091   pp_cxx_left_brace (pp);
2092   /* We do not print the namespace-body.  */
2093   pp_cxx_whitespace (pp);
2094   pp_cxx_right_brace (pp);
2095 }
2096
2097 /* namespace-alias:
2098       identifier
2099
2100    namespace-alias-definition:
2101       namespace identifier = qualified-namespace-specifier ;
2102
2103    qualified-namespace-specifier:
2104       ::(opt) nested-name-specifier(opt) namespace-name   */
2105
2106 static void
2107 pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t)
2108 {
2109   pp_cxx_ws_string (pp, "namespace");
2110   if (DECL_CONTEXT (t))
2111     pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
2112   pp_cxx_unqualified_id (pp, t);
2113   pp_cxx_whitespace (pp);
2114   pp_equal (pp);
2115   pp_cxx_whitespace (pp);
2116   if (DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)))
2117     pp_cxx_nested_name_specifier (pp,
2118                                   DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)));
2119   pp_cxx_qualified_id (pp, DECL_NAMESPACE_ALIAS (t));
2120   pp_cxx_semicolon (pp);
2121 }
2122
2123 /* simple-declaration:
2124       decl-specifier-seq(opt) init-declarator-list(opt)  */
2125
2126 static void
2127 pp_cxx_simple_declaration (cxx_pretty_printer *pp, tree t)
2128 {
2129   pp->declaration_specifiers (t);
2130   pp_cxx_init_declarator (pp, t);
2131   pp_cxx_semicolon (pp);
2132   pp_needs_newline (pp) = true;
2133 }
2134
2135 /*
2136   template-parameter-list:
2137      template-parameter
2138      template-parameter-list , template-parameter  */
2139
2140 static inline void
2141 pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t)
2142 {
2143   const int n = TREE_VEC_LENGTH (t);
2144   int i;
2145   for (i = 0; i < n; ++i)
2146     {
2147       if (i)
2148         pp_cxx_separate_with (pp, ',');
2149       pp_cxx_template_parameter (pp, TREE_VEC_ELT (t, i));
2150     }
2151 }
2152
2153 /* template-parameter:
2154       type-parameter
2155       parameter-declaration
2156
2157    type-parameter:
2158      class ...(opt) identifier(opt)
2159      class identifier(opt) = type-id
2160      typename identifier(opt)
2161      typename ...(opt) identifier(opt) = type-id
2162      template < template-parameter-list > class ...(opt) identifier(opt)
2163      template < template-parameter-list > class identifier(opt) = template-name  */
2164
2165 static void
2166 pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t)
2167 {
2168   tree parameter =  TREE_VALUE (t);
2169   switch (TREE_CODE (parameter))
2170     {
2171     case TYPE_DECL:
2172       pp_cxx_ws_string (pp, "class");
2173       if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
2174         pp_cxx_ws_string (pp, "...");
2175       if (DECL_NAME (parameter))
2176         pp_cxx_tree_identifier (pp, DECL_NAME (parameter));
2177       /* FIXME: Check if we should print also default argument.  */
2178       break;
2179
2180     case PARM_DECL:
2181       pp_cxx_parameter_declaration (pp, parameter);
2182       break;
2183
2184     case TEMPLATE_DECL:
2185       break;
2186
2187     default:
2188       pp_unsupported_tree (pp, t);
2189       break;
2190     }
2191 }
2192
2193 /* Pretty-print a template parameter in the canonical form
2194    "template-parameter-<level>-<position in parameter list>".  */
2195
2196 void
2197 pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm)
2198 {
2199   const enum tree_code code = TREE_CODE (parm);
2200
2201   /* Brings type template parameters to the canonical forms.  */
2202   if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
2203       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
2204     parm = TEMPLATE_TYPE_PARM_INDEX (parm);
2205
2206   pp_cxx_begin_template_argument_list (pp);
2207   pp->translate_string ("template-parameter-");
2208   pp_wide_integer (pp, TEMPLATE_PARM_LEVEL (parm));
2209   pp_minus (pp);
2210   pp_wide_integer (pp, TEMPLATE_PARM_IDX (parm) + 1);
2211   pp_cxx_end_template_argument_list (pp);
2212 }
2213
2214 /* Print a constrained-type-specifier.  */
2215
2216 void
2217 pp_cxx_constrained_type_spec (cxx_pretty_printer *pp, tree c)
2218 {
2219   tree t, a;
2220   if (c == error_mark_node)
2221     {
2222       pp_cxx_ws_string(pp, "<unsatisfied-constrained-placeholder>");
2223       return;
2224     }
2225   placeholder_extract_concept_and_args (c, t, a);
2226   pp->id_expression (t);
2227   if (TREE_VEC_LENGTH (a) > 1)
2228     {
2229       pp_cxx_begin_template_argument_list (pp);
2230       tree args = make_tree_vec (TREE_VEC_LENGTH (a) - 1);
2231       for (int i = TREE_VEC_LENGTH (a) - 1; i > 0; --i)
2232         TREE_VEC_ELT (args, i-1) = TREE_VEC_ELT (a, i);
2233       pp_cxx_template_argument_list (pp, args);
2234       ggc_free (args);
2235       pp_cxx_end_template_argument_list (pp);
2236     }
2237 }
2238
2239 /*
2240   template-declaration:
2241      export(opt) template < template-parameter-list > declaration
2242
2243   Concept extensions:
2244
2245   template-declaration:
2246      export(opt) template < template-parameter-list >
2247        requires-clause(opt) declaration */
2248
2249 static void
2250 pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
2251 {
2252   tree tmpl = most_general_template (t);
2253   tree level;
2254
2255   pp_maybe_newline_and_indent (pp, 0);
2256   for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level))
2257     {
2258       pp_cxx_ws_string (pp, "template");
2259       pp_cxx_begin_template_argument_list (pp);
2260       pp_cxx_template_parameter_list (pp, TREE_VALUE (level));
2261       pp_cxx_end_template_argument_list (pp);
2262       pp_newline_and_indent (pp, 3);
2263     }
2264
2265   if (flag_concepts)
2266     if (tree ci = get_constraints (t))
2267       if (tree reqs = CI_TEMPLATE_REQS (ci))
2268          {
2269             pp_cxx_requires_clause (pp, reqs);
2270             pp_newline_and_indent (pp, 6);
2271          }
2272
2273   if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_TREE (t))
2274     pp_cxx_function_definition (pp, t);
2275   else
2276     pp_cxx_simple_declaration (pp, t);
2277 }
2278
2279 static void
2280 pp_cxx_explicit_specialization (cxx_pretty_printer *pp, tree t)
2281 {
2282   pp_unsupported_tree (pp, t);
2283 }
2284
2285 static void
2286 pp_cxx_explicit_instantiation (cxx_pretty_printer *pp, tree t)
2287 {
2288   pp_unsupported_tree (pp, t);
2289 }
2290
2291 /*
2292     declaration:
2293        block-declaration
2294        function-definition
2295        template-declaration
2296        explicit-instantiation
2297        explicit-specialization
2298        linkage-specification
2299        namespace-definition
2300
2301     block-declaration:
2302        simple-declaration
2303        asm-definition
2304        namespace-alias-definition
2305        using-declaration
2306        using-directive
2307        static_assert-declaration */
2308 void
2309 cxx_pretty_printer::declaration (tree t)
2310 {
2311   if (TREE_CODE (t) == STATIC_ASSERT)
2312     {
2313       pp_cxx_ws_string (this, "static_assert");
2314       pp_cxx_left_paren (this);
2315       expression (STATIC_ASSERT_CONDITION (t));
2316       pp_cxx_separate_with (this, ',');
2317       expression (STATIC_ASSERT_MESSAGE (t));
2318       pp_cxx_right_paren (this);
2319     }
2320   else if (!DECL_LANG_SPECIFIC (t))
2321     pp_cxx_simple_declaration (this, t);
2322   else if (DECL_USE_TEMPLATE (t))
2323     switch (DECL_USE_TEMPLATE (t))
2324       {
2325       case 1:
2326         pp_cxx_template_declaration (this, t);
2327         break;
2328
2329       case 2:
2330         pp_cxx_explicit_specialization (this, t);
2331         break;
2332
2333       case 3:
2334         pp_cxx_explicit_instantiation (this, t);
2335         break;
2336
2337       default:
2338         break;
2339       }
2340   else switch (TREE_CODE (t))
2341     {
2342     case VAR_DECL:
2343     case TYPE_DECL:
2344       pp_cxx_simple_declaration (this, t);
2345       break;
2346
2347     case FUNCTION_DECL:
2348       if (DECL_SAVED_TREE (t))
2349         pp_cxx_function_definition (this, t);
2350       else
2351         pp_cxx_simple_declaration (this, t);
2352       break;
2353
2354     case NAMESPACE_DECL:
2355       if (DECL_NAMESPACE_ALIAS (t))
2356         pp_cxx_namespace_alias_definition (this, t);
2357       else
2358         pp_cxx_original_namespace_definition (this, t);
2359       break;
2360
2361     default:
2362       pp_unsupported_tree (this, t);
2363       break;
2364     }
2365 }
2366
2367 static void
2368 pp_cxx_typeid_expression (cxx_pretty_printer *pp, tree t)
2369 {
2370   t = TREE_OPERAND (t, 0);
2371   pp_cxx_ws_string (pp, "typeid");
2372   pp_cxx_left_paren (pp);
2373   if (TYPE_P (t))
2374     pp->type_id (t);
2375   else
2376     pp->expression (t);
2377   pp_cxx_right_paren (pp);
2378 }
2379
2380 void
2381 pp_cxx_va_arg_expression (cxx_pretty_printer *pp, tree t)
2382 {
2383   pp_cxx_ws_string (pp, "va_arg");
2384   pp_cxx_left_paren (pp);
2385   pp->assignment_expression (TREE_OPERAND (t, 0));
2386   pp_cxx_separate_with (pp, ',');
2387   pp->type_id (TREE_TYPE (t));
2388   pp_cxx_right_paren (pp);
2389 }
2390
2391 static bool
2392 pp_cxx_offsetof_expression_1 (cxx_pretty_printer *pp, tree t)
2393 {
2394   switch (TREE_CODE (t))
2395     {
2396     case ARROW_EXPR:
2397       if (TREE_CODE (TREE_OPERAND (t, 0)) == STATIC_CAST_EXPR
2398           && INDIRECT_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0))))
2399         {
2400           pp->type_id (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))));
2401           pp_cxx_separate_with (pp, ',');
2402           return true;
2403         }
2404       return false;
2405     case COMPONENT_REF:
2406       if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2407         return false;
2408       if (TREE_CODE (TREE_OPERAND (t, 0)) != ARROW_EXPR)
2409         pp_cxx_dot (pp);
2410       pp->expression (TREE_OPERAND (t, 1));
2411       return true;
2412     case ARRAY_REF:
2413       if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2414         return false;
2415       pp_left_bracket (pp);
2416       pp->expression (TREE_OPERAND (t, 1));
2417       pp_right_bracket (pp);
2418       return true;
2419     default:
2420       return false;
2421     }
2422 }
2423
2424 void
2425 pp_cxx_offsetof_expression (cxx_pretty_printer *pp, tree t)
2426 {
2427   pp_cxx_ws_string (pp, "offsetof");
2428   pp_cxx_left_paren (pp);
2429   if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2430     pp->expression (TREE_OPERAND (t, 0));
2431   pp_cxx_right_paren (pp);
2432 }
2433
2434 void
2435 pp_cxx_addressof_expression (cxx_pretty_printer *pp, tree t)
2436 {
2437   pp_cxx_ws_string (pp, "__builtin_addressof");
2438   pp_cxx_left_paren (pp);
2439   pp->expression (TREE_OPERAND (t, 0));
2440   pp_cxx_right_paren (pp);
2441 }
2442
2443 static char const*
2444 get_fold_operator (tree t)
2445 {
2446   int op = int_cst_value (FOLD_EXPR_OP (t));
2447   if (FOLD_EXPR_MODIFY_P (t))
2448     {
2449       switch (op)
2450         {
2451         case NOP_EXPR: return "=";
2452         case PLUS_EXPR: return "+=";
2453         case MINUS_EXPR: return "-=";
2454         case MULT_EXPR: return "*=";
2455         case TRUNC_DIV_EXPR: return "/=";
2456         case TRUNC_MOD_EXPR: return "%=";
2457         case BIT_XOR_EXPR: return "^=";
2458         case BIT_AND_EXPR: return "&=";
2459         case BIT_IOR_EXPR: return "|=";
2460         case LSHIFT_EXPR: return "<<=";
2461         case RSHIFT_EXPR: return ">>=";
2462         default: gcc_unreachable ();
2463         }
2464     }
2465   else
2466     {
2467       switch (op)
2468         {
2469         case PLUS_EXPR: return "+";
2470         case MINUS_EXPR: return "-";
2471         case MULT_EXPR: return "*";
2472         case TRUNC_DIV_EXPR: return "/";
2473         case TRUNC_MOD_EXPR: return "%";
2474         case BIT_XOR_EXPR: return "^";
2475         case BIT_AND_EXPR: return "&";
2476         case BIT_IOR_EXPR: return "|";
2477         case LSHIFT_EXPR: return "<<";
2478         case RSHIFT_EXPR: return ">>";
2479         case EQ_EXPR: return "==";
2480         case NE_EXPR: return "!=";
2481         case LT_EXPR: return "<";
2482         case GT_EXPR: return ">";
2483         case LE_EXPR: return "<=";
2484         case GE_EXPR: return ">=";
2485         case TRUTH_ANDIF_EXPR: return "&&";
2486         case TRUTH_ORIF_EXPR: return "||";
2487         case MEMBER_REF: return "->*";
2488         case DOTSTAR_EXPR: return ".*";
2489         case OFFSET_REF: return ".*";
2490         default: return ","; /* FIXME: Not the right default.  */
2491         }
2492     }
2493 }
2494
2495 void
2496 pp_cxx_unary_left_fold_expression (cxx_pretty_printer *pp, tree t)
2497 {
2498   char const* op = get_fold_operator (t);
2499   tree expr = PACK_EXPANSION_PATTERN (FOLD_EXPR_PACK (t));
2500   pp_cxx_left_paren (pp);
2501   pp_cxx_ws_string (pp, "...");
2502   pp_cxx_ws_string (pp, op);
2503   pp->expression (expr);
2504   pp_cxx_right_paren (pp);
2505 }
2506
2507 void
2508 pp_cxx_unary_right_fold_expression (cxx_pretty_printer *pp, tree t)
2509 {
2510   char const* op = get_fold_operator (t);
2511   tree expr = PACK_EXPANSION_PATTERN (FOLD_EXPR_PACK (t));
2512   pp_cxx_left_paren (pp);
2513   pp->expression (expr);
2514   pp_space (pp);
2515   pp_cxx_ws_string (pp, op);
2516   pp_cxx_ws_string (pp, "...");
2517   pp_cxx_right_paren (pp);
2518 }
2519
2520 void
2521 pp_cxx_binary_fold_expression (cxx_pretty_printer *pp, tree t)
2522 {
2523   char const* op = get_fold_operator (t);
2524   tree t1 = TREE_OPERAND (t, 1);
2525   tree t2 = TREE_OPERAND (t, 2);
2526   if (t1 == FOLD_EXPR_PACK (t))
2527     t1 = PACK_EXPANSION_PATTERN (t1);
2528   else
2529     t2 = PACK_EXPANSION_PATTERN (t2);
2530   pp_cxx_left_paren (pp);
2531   pp->expression (t1);
2532   pp_cxx_ws_string (pp, op);
2533   pp_cxx_ws_string (pp, "...");
2534   pp_cxx_ws_string (pp, op);
2535   pp->expression (t2);
2536   pp_cxx_right_paren (pp);
2537 }
2538
2539 void
2540 pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t)
2541 {
2542   cp_trait_kind kind = TRAIT_EXPR_KIND (t);
2543
2544   switch (kind)
2545     {
2546     case CPTK_HAS_NOTHROW_ASSIGN:
2547       pp_cxx_ws_string (pp, "__has_nothrow_assign");
2548       break;
2549     case CPTK_HAS_TRIVIAL_ASSIGN:
2550       pp_cxx_ws_string (pp, "__has_trivial_assign");
2551       break;
2552     case CPTK_HAS_NOTHROW_CONSTRUCTOR:
2553       pp_cxx_ws_string (pp, "__has_nothrow_constructor");
2554       break;
2555     case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
2556       pp_cxx_ws_string (pp, "__has_trivial_constructor");
2557       break;
2558     case CPTK_HAS_NOTHROW_COPY:
2559       pp_cxx_ws_string (pp, "__has_nothrow_copy");
2560       break;
2561     case CPTK_HAS_TRIVIAL_COPY:
2562       pp_cxx_ws_string (pp, "__has_trivial_copy");
2563       break;
2564     case CPTK_HAS_TRIVIAL_DESTRUCTOR:
2565       pp_cxx_ws_string (pp, "__has_trivial_destructor");
2566       break;
2567     case CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS:
2568       pp_cxx_ws_string (pp, "__has_unique_object_representations");
2569       break;
2570     case CPTK_HAS_VIRTUAL_DESTRUCTOR:
2571       pp_cxx_ws_string (pp, "__has_virtual_destructor");
2572       break;
2573     case CPTK_IS_ABSTRACT:
2574       pp_cxx_ws_string (pp, "__is_abstract");
2575       break;
2576     case CPTK_IS_AGGREGATE:
2577       pp_cxx_ws_string (pp, "__is_aggregate");
2578       break;
2579     case CPTK_IS_BASE_OF:
2580       pp_cxx_ws_string (pp, "__is_base_of");
2581       break;
2582     case CPTK_IS_CLASS:
2583       pp_cxx_ws_string (pp, "__is_class");
2584       break;
2585     case CPTK_IS_EMPTY:
2586       pp_cxx_ws_string (pp, "__is_empty");
2587       break;
2588     case CPTK_IS_ENUM:
2589       pp_cxx_ws_string (pp, "__is_enum");
2590       break;
2591     case CPTK_IS_FINAL:
2592       pp_cxx_ws_string (pp, "__is_final");
2593       break;
2594     case CPTK_IS_POD:
2595       pp_cxx_ws_string (pp, "__is_pod");
2596       break;
2597     case CPTK_IS_POLYMORPHIC:
2598       pp_cxx_ws_string (pp, "__is_polymorphic");
2599       break;
2600     case CPTK_IS_SAME_AS:
2601       pp_cxx_ws_string (pp, "__is_same_as");
2602       break;
2603     case CPTK_IS_STD_LAYOUT:
2604       pp_cxx_ws_string (pp, "__is_std_layout");
2605       break;
2606     case CPTK_IS_TRIVIAL:
2607       pp_cxx_ws_string (pp, "__is_trivial");
2608       break;
2609     case CPTK_IS_TRIVIALLY_ASSIGNABLE:
2610       pp_cxx_ws_string (pp, "__is_trivially_assignable");
2611       break;
2612     case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE:
2613       pp_cxx_ws_string (pp, "__is_trivially_constructible");
2614       break;
2615     case CPTK_IS_TRIVIALLY_COPYABLE:
2616       pp_cxx_ws_string (pp, "__is_trivially_copyable");
2617       break;
2618     case CPTK_IS_UNION:
2619       pp_cxx_ws_string (pp, "__is_union");
2620       break;
2621     case CPTK_IS_LITERAL_TYPE:
2622       pp_cxx_ws_string (pp, "__is_literal_type");
2623       break;
2624     case CPTK_IS_ASSIGNABLE:
2625       pp_cxx_ws_string (pp, "__is_assignable");
2626       break;
2627     case CPTK_IS_CONSTRUCTIBLE:
2628       pp_cxx_ws_string (pp, "__is_constructible");
2629       break;
2630
2631     default:
2632       gcc_unreachable ();
2633     }
2634
2635   pp_cxx_left_paren (pp);
2636   pp->type_id (TRAIT_EXPR_TYPE1 (t));
2637
2638   if (kind == CPTK_IS_BASE_OF || kind == CPTK_IS_SAME_AS)
2639     {
2640       pp_cxx_separate_with (pp, ',');
2641       pp->type_id (TRAIT_EXPR_TYPE2 (t));
2642     }
2643
2644   pp_cxx_right_paren (pp);
2645 }
2646
2647 // requires-clause:
2648 //    'requires' logical-or-expression
2649 void
2650 pp_cxx_requires_clause (cxx_pretty_printer *pp, tree t)
2651 {
2652   if (!t)
2653     return;
2654   pp->padding = pp_before;
2655   pp_cxx_ws_string (pp, "requires");
2656   pp_space (pp);
2657   pp->expression (t);
2658 }
2659
2660 /* requirement:
2661      simple-requirement
2662      compound-requirement
2663      type-requirement
2664      nested-requirement */
2665 static void
2666 pp_cxx_requirement (cxx_pretty_printer *pp, tree t)
2667 {
2668   switch (TREE_CODE (t))
2669     {
2670     case SIMPLE_REQ:
2671       pp_cxx_simple_requirement (pp, t);
2672       break;
2673
2674     case TYPE_REQ:
2675       pp_cxx_type_requirement (pp, t);
2676       break;
2677
2678     case COMPOUND_REQ:
2679       pp_cxx_compound_requirement (pp, t);
2680       break;
2681
2682     case NESTED_REQ:
2683       pp_cxx_nested_requirement (pp, t);
2684       break;
2685
2686     default:
2687       gcc_unreachable ();
2688     }
2689 }
2690
2691 // requirement-list:
2692 //    requirement
2693 //    requirement-list ';' requirement[opt]
2694 //
2695 static void
2696 pp_cxx_requirement_list (cxx_pretty_printer *pp, tree t)
2697 {
2698   for (; t; t = TREE_CHAIN (t))
2699     pp_cxx_requirement (pp, TREE_VALUE (t));
2700 }
2701
2702 // requirement-body:
2703 //    '{' requirement-list '}'
2704 static void
2705 pp_cxx_requirement_body (cxx_pretty_printer *pp, tree t)
2706 {
2707   pp_cxx_left_brace (pp);
2708   pp_cxx_requirement_list (pp, t);
2709   pp_cxx_right_brace (pp);
2710 }
2711
2712 // requires-expression:
2713 //    'requires' requirement-parameter-list requirement-body
2714 void
2715 pp_cxx_requires_expr (cxx_pretty_printer *pp, tree t)
2716 {
2717   pp_string (pp, "requires");
2718   if (tree parms = TREE_OPERAND (t, 0))
2719     {
2720       pp_cxx_parameter_declaration_clause (pp, parms);
2721       pp_cxx_whitespace (pp);
2722     }
2723   pp_cxx_requirement_body (pp, TREE_OPERAND (t, 1));
2724 }
2725
2726 /* simple-requirement:
2727      expression ';' */
2728 void
2729 pp_cxx_simple_requirement (cxx_pretty_printer *pp, tree t)
2730 {
2731   pp->expression (TREE_OPERAND (t, 0));
2732   pp_cxx_semicolon (pp);
2733 }
2734
2735 /* type-requirement:
2736      typename type-name ';' */
2737 void
2738 pp_cxx_type_requirement (cxx_pretty_printer *pp, tree t)
2739 {
2740   pp->type_id (TREE_OPERAND (t, 0));
2741   pp_cxx_semicolon (pp);
2742 }
2743
2744 /* compound-requirement:
2745      '{' expression '}' 'noexcept' [opt] trailing-return-type [opt] */
2746 void
2747 pp_cxx_compound_requirement (cxx_pretty_printer *pp, tree t)
2748 {
2749   pp_cxx_left_brace (pp);
2750   pp->expression (TREE_OPERAND (t, 0));
2751   pp_cxx_right_brace (pp);
2752
2753   if (COMPOUND_REQ_NOEXCEPT_P (t))
2754     pp_cxx_ws_string (pp, "noexcept");
2755
2756   if (tree type = TREE_OPERAND (t, 1))
2757     {
2758       pp_cxx_ws_string (pp, "->");
2759       pp->type_id (type);
2760     }
2761   pp_cxx_semicolon (pp);
2762 }
2763
2764 /* nested requirement:
2765      'requires' constraint-expression */
2766 void
2767 pp_cxx_nested_requirement (cxx_pretty_printer *pp, tree t)
2768 {
2769   pp_cxx_ws_string (pp, "requires");
2770   pp->expression (TREE_OPERAND (t, 0));
2771   pp_cxx_semicolon (pp);
2772 }
2773
2774 void
2775 pp_cxx_predicate_constraint (cxx_pretty_printer *pp, tree t)
2776 {
2777   pp->expression (TREE_OPERAND (t, 0));
2778 }
2779
2780 void
2781 pp_cxx_check_constraint (cxx_pretty_printer *pp, tree t)
2782 {
2783   tree decl = CHECK_CONSTR_CONCEPT (t);
2784   tree tmpl = DECL_TI_TEMPLATE (decl);
2785   tree args = CHECK_CONSTR_ARGS (t);
2786   tree id = build_nt (TEMPLATE_ID_EXPR, tmpl, args);
2787
2788   if (VAR_P (decl))
2789     pp->expression (id);
2790   else if (TREE_CODE (decl) == FUNCTION_DECL)
2791     {
2792       tree call = build_vl_exp (CALL_EXPR, 2);
2793       TREE_OPERAND (call, 0) = integer_two_node;
2794       TREE_OPERAND (call, 1) = id;
2795       pp->expression (call);
2796     }
2797   else
2798     gcc_unreachable ();
2799 }
2800
2801 void
2802 pp_cxx_expression_constraint (cxx_pretty_printer *pp, tree t)
2803 {
2804   pp_string (pp, "<valid-expression ");
2805   pp_cxx_left_paren (pp);
2806   pp->expression (TREE_OPERAND (t, 0));
2807   pp_cxx_right_paren (pp);
2808   pp_string (pp, ">");
2809 }
2810
2811 void
2812 pp_cxx_type_constraint (cxx_pretty_printer *pp, tree t)
2813 {
2814   pp_string (pp, "<valid-type ");
2815   pp->type_id (TREE_OPERAND (t, 0));
2816   pp_string (pp, ">");
2817 }
2818
2819 void
2820 pp_cxx_implicit_conversion_constraint (cxx_pretty_printer *pp, tree t)
2821 {
2822   pp_string (pp, "<implicitly-conversion ");
2823   pp_cxx_left_paren (pp);
2824   pp->expression (ICONV_CONSTR_EXPR (t));
2825   pp_cxx_right_paren (pp);
2826   pp_cxx_ws_string (pp, "to");
2827   pp->type_id (ICONV_CONSTR_TYPE (t));
2828   pp_string (pp, ">");
2829 }
2830
2831 void
2832 pp_cxx_argument_deduction_constraint (cxx_pretty_printer *pp, tree t)
2833 {
2834   pp_string (pp, "<argument-deduction ");
2835   pp_cxx_left_paren (pp);
2836   pp->expression (DEDUCT_CONSTR_EXPR (t));
2837   pp_cxx_right_paren (pp);
2838   pp_cxx_ws_string (pp, "as");
2839   pp->expression (DEDUCT_CONSTR_PATTERN (t));
2840   pp_string (pp, ">");
2841 }
2842
2843 void
2844 pp_cxx_exception_constraint (cxx_pretty_printer *pp, tree t)
2845 {
2846   pp_cxx_ws_string (pp, "noexcept");
2847   pp_cxx_whitespace (pp);
2848   pp_cxx_left_paren (pp);
2849   pp->expression (TREE_OPERAND (t, 0));
2850   pp_cxx_right_paren (pp);
2851 }
2852
2853 void
2854 pp_cxx_parameterized_constraint (cxx_pretty_printer *pp, tree t)
2855 {
2856   pp_left_paren (pp);
2857   pp_string (pp, "<requires ");
2858   if (tree parms = PARM_CONSTR_PARMS (t))
2859     {
2860         pp_cxx_parameter_declaration_clause (pp, parms);
2861       pp_cxx_whitespace (pp);
2862     }
2863   pp_cxx_constraint (pp, PARM_CONSTR_OPERAND (t));
2864   pp_string (pp, ">");
2865 }
2866
2867 void
2868 pp_cxx_conjunction (cxx_pretty_printer *pp, tree t)
2869 {
2870   pp_cxx_constraint (pp, TREE_OPERAND (t, 0));
2871   pp_string (pp, " and ");
2872   pp_cxx_constraint (pp, TREE_OPERAND (t, 1));
2873 }
2874
2875 void
2876 pp_cxx_disjunction (cxx_pretty_printer *pp, tree t)
2877 {
2878   pp_cxx_constraint (pp, TREE_OPERAND (t, 0));
2879   pp_string (pp, " or ");
2880   pp_cxx_constraint (pp, TREE_OPERAND (t, 1));
2881 }
2882
2883 void
2884 pp_cxx_constraint (cxx_pretty_printer *pp, tree t)
2885 {
2886   if (t == error_mark_node)
2887     return pp->expression (t);
2888
2889   switch (TREE_CODE (t))
2890     {
2891     case PRED_CONSTR:
2892       pp_cxx_predicate_constraint (pp, t);
2893       break;
2894
2895     case CHECK_CONSTR:
2896       pp_cxx_check_constraint (pp, t);
2897       break;
2898
2899     case EXPR_CONSTR:
2900       pp_cxx_expression_constraint (pp, t);
2901       break;
2902
2903     case TYPE_CONSTR:
2904       pp_cxx_type_constraint (pp, t);
2905       break;
2906
2907     case ICONV_CONSTR:
2908       pp_cxx_implicit_conversion_constraint (pp, t);
2909       break;
2910
2911     case DEDUCT_CONSTR:
2912       pp_cxx_argument_deduction_constraint (pp, t);
2913       break;
2914
2915     case EXCEPT_CONSTR:
2916       pp_cxx_exception_constraint (pp, t);
2917       break;
2918
2919     case PARM_CONSTR:
2920       pp_cxx_parameterized_constraint (pp, t);
2921       break;
2922
2923     case CONJ_CONSTR:
2924       pp_cxx_conjunction (pp, t);
2925       break;
2926
2927     case DISJ_CONSTR:
2928       pp_cxx_disjunction (pp, t);
2929       break;
2930
2931     case EXPR_PACK_EXPANSION:
2932       pp->expression (TREE_OPERAND (t, 0));
2933       break;
2934
2935     default:
2936       gcc_unreachable ();
2937     }
2938 }
2939
2940
2941 \f
2942 typedef c_pretty_print_fn pp_fun;
2943
2944 /* Initialization of a C++ pretty-printer object.  */
2945
2946 cxx_pretty_printer::cxx_pretty_printer ()
2947   : c_pretty_printer (),
2948     enclosing_scope (global_namespace)
2949 {
2950   type_specifier_seq = (pp_fun) pp_cxx_type_specifier_seq;
2951   parameter_list = (pp_fun) pp_cxx_parameter_declaration_clause;
2952 }