diff --git a/src/backend/utils/adt/tsquery_util.c b/src/backend/utils/adt/tsquery_util.c
index 0f338aa653d..9add11f6574 100644
--- a/src/backend/utils/adt/tsquery_util.c
+++ b/src/backend/utils/adt/tsquery_util.c
@@ -17,6 +17,9 @@
 #include "tsearch/ts_utils.h"
 #include "miscadmin.h"
 
+/*
+ * Build QTNode tree for a tsquery given in QueryItem array format.
+ */
 QTNode *
 QT2QTN(QueryItem *in, char *operand)
 {
@@ -50,6 +53,12 @@ QT2QTN(QueryItem *in, char *operand)
 	return node;
 }
 
+/*
+ * Free a QTNode tree.
+ *
+ * Referenced "word" and "valnode" items are freed if marked as transient
+ * by flags.
+ */
 void
 QTNFree(QTNode *in)
 {
@@ -62,26 +71,27 @@ QTNFree(QTNode *in)
 	if (in->valnode->type == QI_VAL && in->word && (in->flags & QTN_WORDFREE) != 0)
 		pfree(in->word);
 
-	if (in->child)
+	if (in->valnode->type == QI_OPR)
 	{
-		if (in->valnode)
-		{
-			if (in->valnode->type == QI_OPR && in->nchild > 0)
-			{
-				int			i;
+		int			i;
 
-				for (i = 0; i < in->nchild; i++)
-					QTNFree(in->child[i]);
-			}
-			if (in->flags & QTN_NEEDFREE)
-				pfree(in->valnode);
-		}
-		pfree(in->child);
+		for (i = 0; i < in->nchild; i++)
+			QTNFree(in->child[i]);
 	}
+	if (in->child)
+		pfree(in->child);
+
+	if (in->flags & QTN_NEEDFREE)
+		pfree(in->valnode);
 
 	pfree(in);
 }
 
+/*
+ * Sort comparator for QTNodes.
+ *
+ * The sort order is somewhat arbitrary.
+ */
 int
 QTNodeCompare(QTNode *an, QTNode *bn)
 {
@@ -135,12 +145,19 @@ QTNodeCompare(QTNode *an, QTNode *bn)
 	}
 }
 
+/*
+ * qsort comparator for QTNode pointers.
+ */
 static int
 cmpQTN(const void *a, const void *b)
 {
 	return QTNodeCompare(*(QTNode *const *) a, *(QTNode *const *) b);
 }
 
+/*
+ * Canonicalize a QTNode tree by sorting the children of AND/OR nodes
+ * into an arbitrary but well-defined order.
+ */
 void
 QTNSort(QTNode *in)
 {
@@ -158,13 +175,16 @@ QTNSort(QTNode *in)
 		qsort((void *) in->child, in->nchild, sizeof(QTNode *), cmpQTN);
 }
 
+/*
+ * Are two QTNode trees equal according to QTNodeCompare?
+ */
 bool
 QTNEq(QTNode *a, QTNode *b)
 {
 	uint32		sign = a->sign & b->sign;
 
 	if (!(sign == a->sign && sign == b->sign))
-		return 0;
+		return false;
 
 	return (QTNodeCompare(a, b) == 0) ? true : false;
 }
@@ -190,14 +210,17 @@ QTNTernary(QTNode *in)
 	for (i = 0; i < in->nchild; i++)
 		QTNTernary(in->child[i]);
 
+	/* Only AND and OR are associative, so don't flatten other node types */
+	if (in->valnode->qoperator.oper != OP_AND &&
+		in->valnode->qoperator.oper != OP_OR)
+		return;
+
 	for (i = 0; i < in->nchild; i++)
 	{
 		QTNode	   *cc = in->child[i];
 
-		/* OP_Phrase isn't associative */
 		if (cc->valnode->type == QI_OPR &&
-			in->valnode->qoperator.oper == cc->valnode->qoperator.oper &&
-			in->valnode->qoperator.oper != OP_PHRASE)
+			in->valnode->qoperator.oper == cc->valnode->qoperator.oper)
 		{
 			int			oldnchild = in->nchild;
 
@@ -236,9 +259,6 @@ QTNBinary(QTNode *in)
 	for (i = 0; i < in->nchild; i++)
 		QTNBinary(in->child[i]);
 
-	if (in->nchild <= 2)
-		return;
-
 	while (in->nchild > 2)
 	{
 		QTNode	   *nn = (QTNode *) palloc0(sizeof(QTNode));
@@ -263,8 +283,9 @@ QTNBinary(QTNode *in)
 }
 
 /*
- * Count the total length of operand string in tree, including '\0'-
- * terminators.
+ * Count the total length of operand strings in tree (including '\0'-
+ * terminators) and the total number of nodes.
+ * Caller must initialize *sumlen and *nnode to zeroes.
  */
 static void
 cntsize(QTNode *in, int *sumlen, int *nnode)
@@ -293,6 +314,10 @@ typedef struct
 	char	   *curoperand;
 } QTN2QTState;
 
+/*
+ * Recursively convert a QTNode tree into flat tsquery format.
+ * Caller must have allocated arrays of the correct size.
+ */
 static void
 fillQT(QTN2QTState *state, QTNode *in)
 {
@@ -330,6 +355,9 @@ fillQT(QTN2QTState *state, QTNode *in)
 	}
 }
 
+/*
+ * Build flat tsquery from a QTNode tree.
+ */
 TSQuery
 QTN2QT(QTNode *in)
 {
@@ -358,6 +386,11 @@ QTN2QT(QTNode *in)
 	return out;
 }
 
+/*
+ * Copy a QTNode tree.
+ *
+ * Modifiable copies of the words and valnodes are made, too.
+ */
 QTNode *
 QTNCopy(QTNode *in)
 {
@@ -393,6 +426,9 @@ QTNCopy(QTNode *in)
 	return out;
 }
 
+/*
+ * Clear the specified flag bit(s) in all nodes of a QTNode tree.
+ */
 void
 QTNClearFlags(QTNode *in, uint32 flags)
 {
diff --git a/src/test/regress/expected/tsearch.out b/src/test/regress/expected/tsearch.out
index 129d06ef07e..55d6a857387 100644
--- a/src/test/regress/expected/tsearch.out
+++ b/src/test/regress/expected/tsearch.out
@@ -1184,6 +1184,13 @@ SELECT ts_rewrite('foo & bar & qq & new & york',  'new & york'::tsquery, 'big &
  'foo' & 'bar' & 'qq' & ( 'city' & 'new' & 'york' | 'nyc' | 'big' & 'apple' )
 (1 row)
 
+SELECT ts_rewrite(ts_rewrite('new & !york ', 'york', '!jersey'),
+                  'jersey', 'mexico');
+     ts_rewrite     
+--------------------
+ 'new' & !!'mexico'
+(1 row)
+
 SELECT ts_rewrite('moscow', 'SELECT keyword, sample FROM test_tsquery'::text );
      ts_rewrite      
 ---------------------
diff --git a/src/test/regress/sql/tsearch.sql b/src/test/regress/sql/tsearch.sql
index 65eb9438d49..afd990e6969 100644
--- a/src/test/regress/sql/tsearch.sql
+++ b/src/test/regress/sql/tsearch.sql
@@ -402,6 +402,8 @@ SELECT COUNT(*) FROM test_tsquery WHERE keyword >  'new & york';
 RESET enable_seqscan;
 
 SELECT ts_rewrite('foo & bar & qq & new & york',  'new & york'::tsquery, 'big & apple | nyc | new & york & city');
+SELECT ts_rewrite(ts_rewrite('new & !york ', 'york', '!jersey'),
+                  'jersey', 'mexico');
 
 SELECT ts_rewrite('moscow', 'SELECT keyword, sample FROM test_tsquery'::text );
 SELECT ts_rewrite('moscow & hotel', 'SELECT keyword, sample FROM test_tsquery'::text );