hphp/runtime/ext/factparse/parser.cpp

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16
  17 #include "hphp/runtime/ext/factparse/parser.h"
  18
  19 #include <iostream>
  20 #include <iomanip>
  21
  22 #include "hphp/runtime/base/runtime-option.h"
  23 #include "hphp/runtime/base/type-string.h"
  24 #include "hphp/util/string-vsnprintf.h"
  25
  26 namespace HPHP {
  27 namespace Facts {
  28
  29 bool Parser::parseImpl() {
  30   if (RuntimeOption::PHP7_UVS) {
  31     return parseImpl7();
  32   } else {
  33     return parseImpl5();
  34   }
  35 }
  36
  37 void Parser::parse() {
  38   m_result.error = true;
  39
  40   if (!parseImpl()) {
  41     throw ParseTimeFatalException(
  42       m_fileName,
  43       line1(),
  44       "Parse error: %s",
  45       getMessage().c_str());
  46   }
  47   std::stringstream(m_scanner.getMd5().substr(0, 128/8))
  48     >> std::hex
  49     >> m_result.md5sum[0];
  50   std::stringstream(m_scanner.getMd5().substr(128/8))
  51     >> std::hex
  52     >> m_result.md5sum[1];
  53
  54   m_result.error = false;
  55 }
  56
  57 void Parser::error(const char* fmt, ...) {
  58   va_list ap;
  59   va_start(ap, fmt);
  60   std::string msg;
  61   string_vsnprintf(msg, fmt, ap);
  62   va_end(ap);
  63
  64   fatal(&m_loc, msg.c_str());
  65 }
  66
  67 void Parser::parseFatal(const Location* loc, const char* msg) {
  68   // If the parser has a message, prepend it to the given message. Otherwise
  69   // just use the given message.
  70   std::string str = getMessage();
  71   std::string strInput;
  72   if (!str.empty()) {
  73     strInput = str;
  74     strInput += "\n";
  75   }
  76   strInput += msg;
  77
  78   auto exn = ParseTimeFatalException(
  79     m_fileName, loc->r.line0,
  80     "%s",
  81     strInput.c_str());
  82
  83   exn.setParseFatal();
  84   throw exn;
  85 }
  86
  87 void Parser::fatal(const Location* loc, const char* msg) {
  88   throw ParseTimeFatalException(m_fileName, loc->r.line0, "%s", msg);
  89 }
  90
  91 void Parser::onClassStart(int /*type*/, Token& /*name*/) {
  92   m_classScope++;
  93 }
  94
  95 // There can be multilple declarations of a class with the same name e.g.:
  96 // if (...) { class X {function a(){}} } else { class X {function b(){}}}
  97 // We take the union of base-types/traits across both declarations as this
  98 // is what is needed to answer questions like "which classes extend Y".
  99 //
 100 // We also union the flags and if two declarations differ in "kind" this is set
 101 // to MIXED. FactTypeFlags::MultipleDeclarations is always set if there are
 102 // multiple declarations of the same type, even if all other features match.
 103 //
 104 // The flag for final is set for enums, and the flag for abstract is set for
 105 // interfaces and traits.
 106 void Parser::onClass(Token& /*out*/, int type, Token& name, Token& base,
 107                      Token& baseInterface, Token& stmt, Token* /*attr*/,
 108                      Token* /*enumBase*/) {
 109   m_classScope--;
 110   if (!isOutsideOfClass()) {
 111     return;
 112   }
 113
 114   auto& name_data = name.text();
 115   bool type_already_existed =
 116     m_result.typesMap.count(name_data) != 0;
 117   auto& type_details = m_result.typesMap[name_data];
 118
 119   FactKindOf kind_of;
 120   switch (type) {
 121     case T_ENUM:
 122       kind_of = FactKindOf::Enum;
 123       type_details.flags |= (uint64_t)FactTypeFlags::Final;
 124       break;
 125     case T_INTERFACE:
 126       kind_of = FactKindOf::Interface;
 127       type_details.flags |= (uint64_t)FactTypeFlags::Abstract;
 128       break;
 129     case T_TRAIT:
 130       kind_of = FactKindOf::Trait;
 131       type_details.flags |= (uint64_t)FactTypeFlags::Abstract;
 132       break;
 133     case T_CLASS:
 134       kind_of = FactKindOf::Class;
 135       break;
 136     case T_ABSTRACT:
 137       kind_of = FactKindOf::Class;
 138       type_details.flags |= (uint64_t)FactTypeFlags::Abstract;
 139       break;
 140     case T_FINAL:
 141       kind_of = FactKindOf::Class;
 142       type_details.flags |= (uint64_t)FactTypeFlags::Final;
 143       break;
 144     case T_STATIC: // abstract + Final
 145       kind_of = FactKindOf::Class;
 146       type_details.flags |=
 147         (uint64_t)FactTypeFlags::Abstract | (uint64_t)FactTypeFlags::Final;
 148       break;
 149     default:
 150       error("Unexpected class token: %d", type);
 151   }
 152   if (type_already_existed && kind_of != type_details.kindOf) {
 153     kind_of = FactKindOf::Mixed;
 154   }
 155   type_details.kindOf = kind_of;
 156
 157   if (type_already_existed) {
 158     type_details.flags |= (uint64_t)FactTypeFlags::MultipleDeclarations;
 159   }
 160
 161   for (auto& baseType : baseInterface.m_baseTypes) {
 162     type_details.baseTypes.emplace(std::move(baseType));
 163   }
 164
 165   for (auto& baseType : stmt.m_baseTypes) {
 166     type_details.baseTypes.emplace(std::move(baseType));
 167   }
 168
 169   if (base.text().size()) {
 170     type_details.baseTypes.emplace(std::move(base.takeText()));
 171   }
 172
 173   if (!type_already_existed && type_details.kindOf == FactKindOf::Enum) {
 174     type_details.baseTypes.insert("HH\\BuiltinEnum");
 175   }
 176
 177   if (kind_of == FactKindOf::Trait || kind_of == FactKindOf::Interface) {
 178     for (auto& requireExtend : stmt.m_requireExtends) {
 179       type_details.requireExtends.emplace(std::move(requireExtend));
 180     }
 181   }
 182
 183   if (kind_of == FactKindOf::Trait) {
 184     for (auto& requireImplement : stmt.m_requireImplements) {
 185       type_details.requireImplements.emplace(std::move(requireImplement));
 186     }
 187   }
 188 }
 189
 190 void Parser::onEnum(Token& out, Token& name, Token& /*baseTy*/, Token& /*stmt*/,
 191                     Token* /*attr*/) {
 192   Token t;
 193   onClass(out, T_ENUM, name, t, t, t, nullptr, nullptr);
 194 }
 195
 196 void Parser::onInterface(Token& out, Token& name, Token& base, Token& stmt,
 197                          Token* /*attr*/) {
 198   Token t;
 199   onClass(out, T_INTERFACE, name, t, base, stmt, nullptr, nullptr);
 200 }
 201
 202 void Parser::onInterfaceName(Token &out, Token *names, Token &name) {
 203   if (names) {
 204     out = Token(std::move(*names));
 205   }
 206   out.m_baseTypes.emplace(std::move(name.takeText()));
 207 }
 208
 209 void Parser::onTypedef(Token& /*out*/, Token& name, const Token& /*type*/,
 210                        const Token* /*attr*/) {
 211   if (!isOutsideOfClass()) {
 212     return;
 213   }
 214   m_result.typeAliases.emplace_back(std::move(name.takeText()));
 215 }
 216
 217 void Parser::onConst(Token& /*out*/, Token& name, Token& /*value*/) {
 218   if (!isOutsideOfClass()) {
 219     return;
 220   }
 221   m_result.constants.emplace_back(std::move(name.takeText()));
 222 }
 223
 224 void Parser::onFunctionStart(Token &name) {
 225   SCOPE_EXIT {
 226     m_functionScope++;
 227   };
 228   if (!isOutsideOfClass()) {
 229     return;
 230   }
 231   m_result.functions.emplace_back(std::move(name.takeText()));
 232 }
 233
 234 void Parser::onFunction(Token& /*out*/, Token* /*modifiers*/, Token& /*ret*/,
 235                         Token& /*ref*/, Token& /*name*/, Token& /*params*/,
 236                         Token& /*stmt*/, Token* /*attr*/) {
 237   m_functionScope--;
 238 }
 239
 240 std::string Parser::nsDecl(const std::string &name) {
 241   if (m_namespace.empty()) {
 242     return name;
 243   }
 244   return m_namespace + NAMESPACE_SEP + name;
 245 }
 246
 247 std::string Parser::nsClassDecl(const std::string &name) {
 248   // Doesn't need to be implemented fully as we only deal with top-level
 249   return nsDecl(name);
 250 }
 251
 252 void Parser::onNamespaceStart(
 253   const std::string &ns,
 254   bool file_scope /* =false */)
 255 {
 256   if (file_scope) {
 257     m_nsStack.clear();
 258     m_namespace.clear();
 259   }
 260   m_nsStack.push_back(m_namespace.size());
 261   if (!ns.empty()) {
 262     if (!m_namespace.empty()) m_namespace += NAMESPACE_SEP;
 263     m_namespace += ns;
 264   }
 265 }
 266
 267 void Parser::onNamespaceEnd() {
 268   m_namespace.resize(m_nsStack.back());
 269   m_nsStack.pop_back();
 270 }
 271
 272 // This is needed when computing the name for onCall
 273 std::string Parser::resolve(const std::string& ns, bool /*cls*/) {
 274   auto const pos = ns.find(NAMESPACE_SEP);
 275
 276   // if qualified name, prepend current namespace
 277   if (pos != std::string::npos) {
 278     return nsDecl(ns);
 279   }
 280
 281   // unqualified name in global namespace
 282   if (m_namespace.empty()) {
 283     return ns;
 284   }
 285
 286   return nsDecl(ns);
 287 }
 288
 289 // Search for define("string", value)
 290 void Parser::onCall(Token& /*out*/, bool dynamic, Token& name, Token& params,
 291                     Token* cls) {
 292   if (
 293     !dynamic
 294     && !cls
 295     && !strcasecmp(name.text().c_str(), "define")
 296     && params.m_constArgs == 2)
 297   {
 298     m_result.constants.emplace_back(std::move(params.m_constantName));
 299   }
 300 }
 301
 302 // Match an acceptable parameter list of the form ("string literal", <expr>)
 303 void Parser::onCallParam(
 304   Token &out,
 305   Token *prevParams,
 306   Token &expr,
 307   bool ref,
 308   bool unpack)
 309 {
 310   // References or var-args are never the pattern we want
 311   if (ref || unpack) {
 312     out.m_constArgs = -1;
 313   } else {
 314     if (prevParams) {
 315       out = Token(std::move(*prevParams));
 316       if (out.m_constArgs != - 1) {
 317         out.m_constArgs++;
 318       }
 319     } else if (expr.num() == T_CONSTANT_ENCAPSED_STRING) {
 320       // First argument must be a string literal
 321       out.m_constantName.swap(expr.takeText());
 322       out.m_constArgs = 1;
 323     } else {
 324       out.m_constArgs = -1;
 325     }
 326   }
 327 }
 328
 329 // Needed for onCallParam
 330 void Parser::onScalar(Token &out, int type, Token &scalar) {
 331   out = Token(std::move(scalar));
 332   out.setNum(type);
 333 }
 334
 335 // Needed to preserve fully qualified names of base interfaces
 336 void Parser::onTypeAnnotation(Token& out, Token& name,
 337                               const Token& /*typeArgs*/) {
 338   out = Token(name);
 339 }
 340
 341 // Trait requirements are accumulated as base types for the enclosing type
 342 void Parser::onClassRequire(Token &out, Token &name, bool isExtends) {
 343   if (isExtends) {
 344     out.m_requireExtends.emplace(std::move(name.takeText()));
 345   } else {
 346     out.m_requireImplements.emplace(std::move(name.takeText()));
 347   }
 348 }
 349
 350 // Trait uses are accumulated as base types for the enclosing type
 351 void Parser::onTraitUse(Token& out, Token& traits, Token& /*rules*/) {
 352   out = Token(std::move(traits));
 353 }
 354
 355 void Parser::onTraitName(Token &out, Token *names, Token &name) {
 356   if (names) {
 357     out = Token(std::move(*names));
 358   }
 359   out.m_baseTypes.emplace(std::move(name.takeText()));
 360 }
 361
 362 // As we go through statements in a class we accumulate base types and trait
 363 // constraints.
 364 // out = stmts + new_stmt
 365 void Parser::onClassStatement(Token &out, Token &stmts, Token &new_stmt) {
 366   out = Token(std::move(stmts));
 367   out.takeAccumulate(new_stmt);
 368 }
 369
 370 void Parser::setTypeVars(Token &out, Token &name) {
 371   out = Token(std::move(name));
 372 }
 373
 374
 375 /******************************************************************************
 376  * EVERYTHING below this point is empty/unused/returns a falsey value         *
 377  ******************************************************************************/
 378
 379 void Parser::onScopeLabel(const Token& /*stmt*/, const Token& /*label*/) {}
 380
 381 void Parser::onCompleteLabelScope(bool /*fresh*/) {}
 382
 383 void Parser::onName(Token& /*out*/, Token& /*name*/, NameKind /*kind*/) {}
 384
 385 void Parser::onStaticVariable(Token& /*out*/, Token* /*exprs*/, Token& /*var*/,
 386                               Token* /*value*/) {}
 387
 388 void Parser::onClassVariable(Token& /*out*/, Token* /*exprs*/, Token& /*var*/,
 389                              Token* /*value*/) {}
 390
 391 void Parser::onClassConstant(Token& /*out*/, Token* /*exprs*/, Token& /*var*/,
 392                              Token& /*value*/) {}
 393
 394 void Parser::onClassAbstractConstant(Token& /*out*/, Token* /*exprs*/,
 395                                      Token& /*var*/) {}
 396
 397 void Parser::onClassTypeConstant(Token& /*out*/, Token& /*var*/,
 398                                  Token& /*value*/) {}
 399
 400 void Parser::onVariable(Token& /*out*/, Token* /*exprs*/, Token& /*var*/,
 401                         Token* /*value*/, bool /*constant*/ /* = false */,
 402                         const std::string& /*docComment*/ /* = "" */) {}
 403
 404 void Parser::onSimpleVariable(Token& /*out*/, Token& /*var*/) {}
 405
 406 void Parser::onPipeVariable(Token& /*out*/) {}
 407
 408 void Parser::onDynamicVariable(Token& /*out*/, Token& /*expr*/,
 409                                bool /*encap*/) {}
 410
 411 void Parser::onIndirectRef(Token& /*out*/, Token& /*refCount*/,
 412                            Token& /*var*/) {}
 413
 414 void Parser::onStaticMember(Token& /*out*/, Token& /*cls*/, Token& /*name*/) {}
 415
 416 void Parser::onRefDim(Token& /*out*/, Token& /*var*/, Token& /*offset*/) {}
 417
 418 void Parser::onObjectProperty(Token& /*out*/, Token& /*base*/,
 419                               PropAccessType /*propAccessType*/,
 420                               Token& /*prop*/) {}
 421
 422 void Parser::onObjectMethodCall(Token& /*out*/, Token& /*base*/,
 423                                 bool /*nullsafe*/, Token& /*prop*/,
 424                                 Token& /*params*/) {}
 425
 426 void Parser::onEncapsList(Token& /*out*/, int /*type*/, Token& /*list*/) {}
 427
 428 void Parser::addEncap(Token& /*out*/, Token* /*list*/, Token& /*expr*/,
 429                       int /*type*/) {}
 430
 431 void Parser::encapRefDim(Token& /*out*/, Token& /*var*/, Token& /*offset*/) {}
 432
 433 void Parser::encapObjProp(Token& /*out*/, Token& /*var*/,
 434                           PropAccessType /*propAccessType*/, Token& /*name*/) {}
 435
 436 void Parser::encapArray(Token& /*out*/, Token& /*var*/, Token& /*expr*/) {}
 437
 438 void Parser::onConstantValue(Token& /*out*/, Token& /*constant*/) {}
 439
 440 void Parser::onExprListElem(Token& /*out*/, Token* /*exprs*/, Token& /*expr*/) {
 441 }
 442
 443 void Parser::onListAssignment(Token& /*out*/, Token& /*vars*/, Token* /*expr*/,
 444                               bool /*rhsFirst*/ /* = false */) {}
 445
 446 void Parser::onAListVar(Token& /*out*/, Token* /*list*/, Token* /*var*/) {}
 447
 448 void Parser::onAListSub(Token& /*out*/, Token* /*list*/, Token& /*sublist*/) {}
 449
 450 void Parser::onAssign(Token& /*out*/, Token& /*var*/, Token& /*expr*/,
 451                       bool /*ref*/, bool /*rhsFirst*/ /* = false */) {}
 452
 453 void Parser::onAssignNew(Token& /*out*/, Token& /*var*/, Token& /*name*/,
 454                          Token& /*args*/) {}
 455
 456 void Parser::onNewObject(Token& /*out*/, Token& /*name*/, Token& /*args*/) {}
 457
 458 void Parser::onUnaryOpExp(Token& /*out*/, Token& /*operand*/, int /*op*/,
 459                           bool /*front*/) {}
 460
 461 void Parser::onBinaryOpExp(Token& /*out*/, Token& /*operand1*/,
 462                            Token& /*operand2*/, int /*op*/) {}
 463
 464 void Parser::onQOp(Token& /*out*/, Token& /*exprCond*/, Token* /*expYes*/,
 465                    Token& /*expNo*/) {}
 466
 467 void Parser::onNullCoalesce(Token& /*out*/, Token& /*expFirst*/,
 468                             Token& /*expSecond*/) {}
 469
 470 void Parser::onArray(Token& /*out*/, Token& /*pairs*/,
 471                      int /*op*/ /* = T_ARRAY */) {}
 472
 473 void Parser::onDict(Token& /*out*/, Token& /*pairs*/) {}
 474
 475 void Parser::onVec(Token& /*out*/, Token& /*exprs*/) {}
 476
 477 void Parser::onKeyset(Token& /*out*/, Token& /*exprs*/) {}
 478
 479 void Parser::onVArray(Token& /*out*/, Token& /*exprs*/) {}
 480
 481 void Parser::onDArray(Token& /*out*/, Token& /*exprs*/) {}
 482
 483 void Parser::onArrayPair(Token& /*out*/, Token* /*pairs*/, Token* /*name*/,
 484                          Token& /*value*/, bool /*ref*/) {}
 485
 486 void Parser::onEmptyCollection(Token& /*out*/) {}
 487
 488 void Parser::onUserAttribute(Token& /*out*/, Token* /*attrList*/,
 489                              Token& /*name*/, Token& /*value*/) {}
 490
 491 void Parser::onClassConst(Token& /*out*/, Token& /*cls*/, Token& /*name*/,
 492                           bool /*text*/) {}
 493
 494 void Parser::onClassClass(Token& /*out*/, Token& /*cls*/, Token& /*name*/,
 495                           bool /*inStaticContext*/) {}
 496
 497 void Parser::onMethodStart(Token& /*name*/, Token& /*mods*/,
 498                            bool /*doPushComment*/ /* = true */) {}
 499
 500 void Parser::onMethod(Token& /*out*/, Token& /*modifiers*/, Token& /*ret*/,
 501                       Token& /*ref*/, Token& /*name*/, Token& /*params*/,
 502                       Token& /*stmt*/, Token* /*attr*/,
 503                       bool /*reloc*/ /* = true */) {}
 504
 505 void Parser::onVariadicParam(Token& /*out*/, Token* /*params*/, Token& /*type*/,
 506                              Token& /*var*/, bool /*ref*/, Token* /*attr*/,
 507                              Token* /*modifier*/) {}
 508
 509 void Parser::onParam(Token& /*out*/, Token* /*params*/, Token& /*type*/,
 510                      Token& /*var*/, bool /*ref*/, Token* /*defValue*/,
 511                      Token* /*attr*/, Token* /*modifier*/) {}
 512
 513 void Parser::onClassExpressionStart() {
 514 }
 515
 516 void Parser::onClassExpression(Token& /*out*/, Token& /*args*/, Token& /*base*/,
 517                                Token& /*baseInterface*/, Token& /*stmt*/) {}
 518
 519 void Parser::onTraitRule(Token& /*out*/, Token& /*stmtList*/,
 520                          Token& /*newStmt*/) {}
 521
 522 void Parser::onTraitPrecRule(Token& /*out*/, Token& /*traitName*/,
 523                              Token& /*methodName*/, Token& /*otherTraits*/) {}
 524
 525 void Parser::onTraitAliasRuleStart(Token& /*out*/, Token& /*traitName*/,
 526                                    Token& /*methodName*/) {}
 527
 528 void Parser::onTraitAliasRuleModify(Token& /*out*/, Token& /*rule*/,
 529                                     Token& /*accessModifiers*/,
 530                                     Token& /*newMethodName*/) {}
 531
 532 void Parser::onClassVariableStart(Token& /*out*/, Token* /*modifiers*/,
 533                                   Token& /*decl*/, Token* /*type*/,
 534                                   bool /*abstract*/ /* = false */,
 535                                   bool /*typeconst*/ /* = false */) {}
 536
 537 void Parser::onMemberModifier(Token& /*out*/, Token* /*modifiers*/,
 538                               Token& /*modifier*/) {}
 539
 540 void Parser::initParseTree() {
 541 }
 542
 543 void Parser::finiParseTree() {
 544 }
 545
 546 void Parser::onHaltCompiler() {
 547 }
 548
 549 void Parser::onStatementListStart(Token& /*out*/) {}
 550
 551 void Parser::addTopStatement(Token& /*new_stmt*/) {}
 552
 553 void Parser::addStatement(Token& /*out*/, Token& /*stmts*/,
 554                           Token& /*new_stmt*/) {}
 555
 556 void Parser::finishStatement(Token& /*out*/, Token& /*stmts*/) {}
 557
 558 void Parser::onBlock(Token& /*out*/, Token& /*stmts*/) {}
 559
 560 void Parser::onIf(Token& /*out*/, Token& /*cond*/, Token& /*stmt*/,
 561                   Token& /*elseifs*/, Token& /*elseStmt*/) {}
 562
 563 void Parser::onElseIf(Token& /*out*/, Token& /*elseifs*/, Token& /*cond*/,
 564                       Token& /*stmt*/) {}
 565
 566 void Parser::onWhile(Token& /*out*/, Token& /*cond*/, Token& /*stmt*/) {}
 567
 568 void Parser::onDo(Token& /*out*/, Token& /*stmt*/, Token& /*cond*/) {}
 569
 570 void Parser::onFor(Token& /*out*/, Token& /*expr1*/, Token& /*expr2*/,
 571                    Token& /*expr3*/, Token& /*stmt*/) {}
 572
 573 void Parser::onSwitch(Token& /*out*/, Token& /*expr*/, Token& /*cases*/) {}
 574
 575 void Parser::onCase(Token& /*out*/, Token& /*cases*/, Token* /*cond*/,
 576                     Token& /*stmt*/) {}
 577
 578 void Parser::onBreakContinue(Token& /*out*/, bool /*isBreak*/,
 579                              Token* /*expr*/) {}
 580
 581 void Parser::onReturn(Token& /*out*/, Token* /*expr*/) {}
 582
 583 void Parser::onYield(Token& /*out*/, Token* /*expr*/) {}
 584
 585 void Parser::onYieldFrom(Token& /*out*/, Token* /*expr*/) {}
 586
 587 void Parser::onYieldPair(Token& /*out*/, Token* /*key*/, Token* /*val*/) {}
 588
 589 void Parser::onYieldBreak(Token& /*out*/) {}
 590
 591 void Parser::onAwait(Token& /*out*/, Token& /*expr*/) {}
 592
 593 void Parser::onGlobal(Token& /*out*/, Token& /*expr*/) {}
 594
 595 void Parser::onGlobalVar(Token& /*out*/, Token* /*exprs*/, Token& /*expr*/) {}
 596
 597 void Parser::onStatic(Token& /*out*/, Token& /*expr*/) {}
 598
 599 void Parser::onHashBang(Token& /*out*/, Token& /*text*/) {}
 600
 601 void Parser::onEcho(Token& /*out*/, Token& /*expr*/, bool /*html*/) {}
 602
 603 void Parser::onUnset(Token& /*out*/, Token& /*expr*/) {}
 604
 605 void Parser::onExpStatement(Token& /*out*/, Token& /*expr*/) {}
 606
 607 void Parser::onForEach(Token& /*out*/, Token& /*arr*/, Token& /*name*/,
 608                        Token& /*value*/, Token& /*stmt*/, bool /*awaitAs*/) {}
 609
 610 void Parser::onTry(Token& /*out*/, Token& /*tryStmt*/, Token& /*className*/,
 611                    Token& /*var*/, Token& /*catchStmt*/, Token& /*catches*/,
 612                    Token& /*finallyStmt*/) {}
 613
 614 void Parser::onTry(Token& /*out*/, Token& /*tryStmt*/, Token& /*finallyStmt*/) {
 615 }
 616
 617 void Parser::onCatch(Token& /*out*/, Token& /*catches*/, Token& /*className*/,
 618                      Token& /*var*/, Token& /*stmt*/) {}
 619
 620 void Parser::onFinally(Token& /*out*/, Token& /*stmt*/) {}
 621
 622 void Parser::onThrow(Token& /*out*/, Token& /*expr*/) {}
 623
 624 void Parser::onClosureStart(Token& /*name*/) {}
 625
 626 Token Parser::onClosure(ClosureType /*type*/, Token* /*modifiers*/,
 627                         Token& /*ref*/, Token& /*params*/, Token& /*cparams*/,
 628                         Token& /*stmts*/, Token& /*ret1*/,
 629                         Token* /*ret2*/ /* = nullptr */) {
 630   return Token();
 631 }
 632
 633 Token Parser::onExprForLambda(const Token& /*expr*/) {
 634   return Token();
 635 }
 636
 637 void Parser::onClosureParam(Token& /*out*/, Token* /*params*/, Token& /*param*/,
 638                             bool /*ref*/) {}
 639
 640 void Parser::onLabel(Token& /*out*/, Token& /*label*/) {}
 641
 642 void Parser::onGoto(Token& /*out*/, Token& /*label*/, bool /*limited*/) {}
 643
 644 void Parser::onTypeList(Token& /*type1*/, const Token& /*type2*/) {}
 645
 646 void Parser::onClsCnsShapeField(Token& /*out*/, const Token& /*cls*/,
 647                                 const Token& /*cns*/, const Token& /*value*/) {}
 648
 649 void Parser::onShapeFieldSpecialization(Token& /*shapeField*/,
 650                                         char /*specialization*/) {}
 651
 652 void Parser::onShape(Token& /*out*/, const Token& /*shapeFieldsList*/,
 653                      bool /*terminatedWithEllipsis*/) {}
 654
 655 void Parser::onTypeSpecialization(Token& /*type*/, char /*specialization*/) {}
 656
 657 void Parser::onUseDeclaration(Token& /*out*/, const std::string& /*ns*/,
 658                               const std::string& /*as*/) {}
 659
 660 void Parser::onMixedUseDeclaration(Token& /*out*/, Token& /*use*/,
 661                                    UseDeclarationConsumer /*f*/) {}
 662
 663 void Parser::onUse(const Token& /*tok*/, UseDeclarationConsumer /*f*/) {}
 664
 665 void Parser::onGroupUse(const std::string& /*prefix*/, const Token& /*tok*/,
 666                         UseDeclarationConsumer /*f*/) {}
 667
 668 void Parser::onDeclare(Token& /*out*/, Token& /*block*/) {}
 669
 670 void Parser::onDeclareList(Token& /*out*/, Token& /*ident*/, Token& /*exp*/) {}
 671
 672 void Parser::nns(int /*token*/ /* = 0 */,
 673                  const std::string& /*text*/ /* = std::string() */) {}
 674
 675 void Parser::useClassAndNamespace(const std::string& /*fn*/,
 676                                   const std::string& /*as*/) {}
 677
 678 void Parser::useClass(const std::string& /*fn*/, const std::string& /*as*/) {}
 679
 680 void Parser::useNamespace(const std::string& /*fn*/,
 681                           const std::string& /*as*/) {}
 682
 683 void Parser::useFunction(const std::string& /*fn*/, const std::string& /*as*/) {
 684 }
 685
 686 void Parser::useConst(const std::string& /*cnst*/, const std::string& /*as*/) {}
 687
 688 void Parser::invalidateGoto(TStatementPtr /*stmt*/, GotoError /*error*/) {}
 689
 690 void Parser::invalidateLabel(TStatementPtr /*stmt*/) {}
 691
 692 TStatementPtr Parser::extractStatement(ScannerToken* /*stmt*/) {
 693   return nullptr;
 694 }
 695
 696 void Parser::onNewLabelScope(bool /*fresh*/) {}
 697
 698 /******************************************************************************
 699  * ONLY put new stubs here. Put implemented methods further up with the rest. *
 700  ******************************************************************************/
 701
 702 }}