diff --git a/src/parser/xhpast/bin/PhutilXHPASTBinary.php b/src/parser/xhpast/bin/PhutilXHPASTBinary.php
index 59b121e..4d94533 100644
--- a/src/parser/xhpast/bin/PhutilXHPASTBinary.php
+++ b/src/parser/xhpast/bin/PhutilXHPASTBinary.php
@@ -1,134 +1,134 @@
 <?php
 
 final class PhutilXHPASTBinary extends Phobject {
 
   /**
    * The expected XHPAST version.
    *
    * This is the version that would be obtained with an up-to-date XHPAST
    * build. The //actual// XHPAST build version may vary.
    */
-  const EXPECTED_VERSION = '5.5.8/1i';
+  const EXPECTED_VERSION = '5.5.9';
 
   /**
    * The XHPAST build version.
    *
    * Cache the result from @{method:getVersion} to prevent excessive calls to
    * @{function:execx}.
    */
   private static $version;
 
   /**
    * Builds XHPAST automatically.
    *
    * Attempts to build the XHPAST binary automatically.
    *
    * @return void
    */
   public static function build() {
     if (Filesystem::binaryExists('gmake')) {
       $command = 'gmake';
     } else {
       $command = 'make';
     }
 
     $root = phutil_get_library_root('phutil');
     $path = Filesystem::resolvePath($root.'/../support/xhpast');
 
     // Run the build.
     execx(
       '%s -C %s %Ls',
       $command,
       $path,
       array('clean', 'all', 'install'));
 
     // Test the binary.
     if (!self::isAvailable()) {
       throw new Exception(pht('%s is broken.', 'xhpast'));
     }
 
     self::$version = null;
   }
 
   /**
    * Returns human-readable instructions for building XHPAST.
    *
    * @return string
    */
   public static function getBuildInstructions() {
     $root = phutil_get_library_root('phutil');
     $make = Filesystem::resolvePath($root.'/../scripts/build_xhpast.php');
 
     return phutil_console_format(
       "%s:\n\n  \$ %s\n",
       pht(
         "Your version of '%s' is unbuilt or out of date. Run this ".
         "script to build it.",
         'xhpast'),
       $make);
   }
 
   /**
    * Constructs an @{class:ExecFuture} for XHPAST.
    *
    * @param  wild        Data to pass to the future.
    * @return ExecFuture
    */
   public static function getParserFuture($data) {
     if (!self::isAvailable()) {
       try {
         // Try to build XHPAST automatically. If we can't then just ask the
         // user to build it themselves.
         self::build();
       } catch (CommandException $ex) {
         throw new PhutilProxyException(self::getBuildInstructions(), $ex);
       }
     }
     $future = new ExecFuture('%s', self::getPath());
     $future->write($data);
 
     return $future;
   }
 
   /**
    * Returns the path to the XHPAST binary.
    *
    * @return string
    */
   public static function getPath() {
     if (phutil_is_windows()) {
       return dirname(__FILE__).'\\xhpast.exe';
     }
     return dirname(__FILE__).'/xhpast';
   }
 
   /**
    * Returns the XHPAST version.
    *
    * @return string
    */
   public static function getVersion() {
     if (self::$version === null) {
       $bin = self::getPath();
 
       if (Filesystem::pathExists($bin)) {
         list($err, $stdout) = exec_manual('%s --version', $bin);
         if (!$err) {
           self::$version = trim($stdout);
         }
       }
     }
 
     return self::$version;
   }
 
   /**
    * Checks if XHPAST is built and up-to-date.
    *
    * @return bool
    */
   public static function isAvailable() {
     return self::getVersion() == self::EXPECTED_VERSION;
   }
 
 }
diff --git a/support/xhpast/xhpast.cpp b/support/xhpast/xhpast.cpp
index 0361822..a6b9825 100644
--- a/support/xhpast/xhpast.cpp
+++ b/support/xhpast/xhpast.cpp
@@ -1,127 +1,127 @@
 #include "ast.hpp"
 #include <vector>
 #include <string>
 #include <iostream>
 #include <sstream>
 #include <fstream>
 using namespace std;
 
 int xhpastparse(void*, xhpast::Node **);
 
 int xhpast_process(std::string &in);
 void print_node(xhpast::Node *node);
 
 int main(int argc, char* argv[]) {
   if (argc != 1) {
     // Coupling: modify also src/parser/xhpast/bin/PhutilXHPASTBinary.php
-    cout << "5.5.8/1i\n";
+    cout << "5.5.9\n";
     return 0;
   }
 
   ifstream inputFile;
   istream *inputStream;
   inputStream = &cin;
 
   std::stringbuf sb;
   *inputStream >> noskipws >> &sb;
   std::string buffer = sb.str();
   inputFile.close();
 
   return xhpast_process(buffer);
 }
 
 int xhpast_process(std::string &in) {
 
   char *buffer;
   in.reserve(in.size() + 1);
   buffer = const_cast<char*>(in.c_str());
   buffer[in.size() + 1] = 0; // need double NULL for scan_buffer
 
   void* scanner;
   yy_extra_type extra;
   extra.idx_expr = true;//flags.idx_expr;
   extra.include_debug = true;//flags.include_debug;
   extra.insert_token = 0;//flags.eval ? T_OPEN_TAG_FAKE : 0;
   extra.short_tags = true;//flags.short_tags;
   extra.asp_tags = false;//flags.asp_tags;
 
   xhpast::Node *root = NULL;
 
   xhpastlex_init(&scanner);
   xhpastset_extra(&extra, scanner);
   xhpast_scan_buffer(buffer, in.size() + 2, scanner);
   xhpastparse(scanner, &root);
   xhpastlex_destroy(scanner);
 
   if (extra.terminated) {
     fprintf(
       stderr,
       "XHPAST Parse Error: %s on line %d\n",
       extra.error.c_str(),
       (int)extra.lineno);
     return 1;
   }
 
   printf("{");
   printf("\"tree\":");
   if (root) {
     // Extend the right token for the root node to the end of the concrete
     // token stream. This ensure all tokens appear in the tree. If we don't
     // do this and the file ends in tokens which don't go to the parser (like
     // comments and whitespace) they won't be represented in the tree.
     root->r_tok = (extra.token_list.size() - 1);
     print_node(root);
   } else {
     printf("null");
   }
   printf(",");
   printf("\"stream\":");
   printf("[");
 
   if (!extra.token_list.empty()) {
     for (xhpast::token_list_t::iterator ii = extra.token_list.begin();;) {
       printf("[%d, %d]", (*ii)->type, (int)(*ii)->value.length());
       if (++ii != extra.token_list.end()) {
         printf(",");
       } else {
         break;
       }
     }
   }
   printf("]");
   printf("}\n");
 
   return 0;
 }
 
 void print_node(xhpast::Node *node) {
   int l = -1;
   if (node->l_tok != -1) {
     l = node->l_tok;
   }
 
   if (l == -1) {
     printf("[%u]", node->type);
   } else {
     int r = -1;
 
     if (node->r_tok != -1) {
       r = node->r_tok;
     }
 
     printf("[%u, %d, %d", node->type, l, r);
     if (!node->children.empty()) {
       printf(", [");
       for (xhpast::node_list_t::iterator ii = node->children.begin();;) {
         print_node(*ii);
         if (++ii != node->children.end()) {
           printf(",");
         } else {
           break;
         }
       }
       printf("]");
     }
     printf("]");
   }
 }