4 files changed, 265 insertions, 70 deletions

diff --git a/src/macfont.m b/src/macfont.m
index d0cdbcd08c7..9f9f6f4efaf 100644
--- a/src/macfont.m
+++ b/src/macfont.m
@@ -632,21 +632,35 @@ get_cgcolor_from_nscolor (NSColor *nsColor, struct frame *f)
 
 #define CG_SET_FILL_COLOR_WITH_FACE_FOREGROUND(context, face)           \
   do {                                                                  \
-    CGColorRef refcol_ = get_cgcolor (NS_FACE_FOREGROUND (face));       \
-    CGContextSetFillColorWithColor (context, refcol_) ;                 \
-    CGColorRelease (refcol_);                                           \
+    CGColorRef refcol = get_cgcolor (NS_FACE_FOREGROUND (face));        \
+    CGContextSetFillColorWithColor (context, refcol);                   \
+    CGColorRelease (refcol);                                            \
   } while (0)
 #define CG_SET_FILL_COLOR_WITH_FACE_BACKGROUND(context, face)           \
   do {                                                                  \
-    CGColorRef refcol_ = get_cgcolor (NS_FACE_BACKGROUND (face));       \
-    CGContextSetFillColorWithColor (context, refcol_);                  \
-    CGColorRelease (refcol_);                                           \
+    CGColorRef refcol = get_cgcolor (NS_FACE_BACKGROUND (face));        \
+    CGContextSetFillColorWithColor (context, refcol);                   \
+    CGColorRelease (refcol);                                            \
+  } while (0)
+#define CG_SET_FILL_COLOR_WITH_FRAME_CURSOR(context, frame)             \
+  do {                                                                  \
+    CGColorRef refcol                                                   \
+      = get_cgcolor_from_nscolor (FRAME_CURSOR_COLOR (frame), frame);   \
+    CGContextSetFillColorWithColor (context, refcol);                   \
+    CGColorRelease (refcol);                                            \
+  } while (0)
+#define CG_SET_FILL_COLOR_WITH_FRAME_BACKGROUND(context, frame)         \
+  do {                                                                  \
+    CGColorRef refcol                                                   \
+      = get_cgcolor_from_nscolor (FRAME_BACKGROUND_COLOR (frame), frame); \
+    CGContextSetFillColorWithColor (context, refcol);                   \
+    CGColorRelease (refcol);                                            \
   } while (0)
 #define CG_SET_STROKE_COLOR_WITH_FACE_FOREGROUND(context, face)         \
   do {                                                                  \
-    CGColorRef refcol_ = get_cgcolor (NS_FACE_FOREGROUND (face));       \
-    CGContextSetStrokeColorWithColor (context, refcol_);                \
-    CGColorRelease (refcol_);                                           \
+    CGColorRef refcol = get_cgcolor (NS_FACE_FOREGROUND (face));        \
+    CGContextSetStrokeColorWithColor (context, refcol);                 \
+    CGColorRelease (refcol);                                            \
   } while (0)
 
 
@@ -2933,9 +2947,12 @@ macfont_draw (struct glyph_string *s, int from, int to, int x, int y,
     {
       if (s->hl == DRAW_CURSOR)
         {
-          CGColorRef colorref = get_cgcolor_from_nscolor (FRAME_CURSOR_COLOR (f), f);
-          CGContextSetFillColorWithColor (context, colorref);
-          CGColorRelease (colorref);
+          if (face && (NS_FACE_BACKGROUND (face)
+                       == [(NSColor *) FRAME_CURSOR_COLOR (f)
+                                       unsignedLong]))
+            CG_SET_FILL_COLOR_WITH_FACE_FOREGROUND (context, face);
+          else
+            CG_SET_FILL_COLOR_WITH_FRAME_CURSOR (context, f);
         }
       else
         CG_SET_FILL_COLOR_WITH_FACE_BACKGROUND (context, face);
@@ -2949,9 +2966,12 @@ macfont_draw (struct glyph_string *s, int from, int to, int x, int y,
       CGContextScaleCTM (context, 1, -1);
       if (s->hl == DRAW_CURSOR)
         {
-          CGColorRef colorref = get_cgcolor_from_nscolor (FRAME_BACKGROUND_COLOR (f), f);
-          CGContextSetFillColorWithColor (context, colorref);
-          CGColorRelease (colorref);
+          if (face && (NS_FACE_BACKGROUND (face)
+                       == [(NSColor *) FRAME_CURSOR_COLOR (f)
+                                       unsignedLong]))
+            CG_SET_FILL_COLOR_WITH_FACE_BACKGROUND (context, face);
+          else
+            CG_SET_FILL_COLOR_WITH_FRAME_BACKGROUND (context, f);
         }
       else
         CG_SET_FILL_COLOR_WITH_FACE_FOREGROUND (context, face);
diff --git a/src/nsterm.m b/src/nsterm.m
index 87bdb44eadc..ecbf80ff72d 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -3750,14 +3750,18 @@ ns_maybe_dumpglyphs_background (struct glyph_string *s, char force_p)
         {
           struct face *face = s->face;
           if (!face->stipple)
-            {
-              if (s->hl != DRAW_CURSOR)
-                [(NS_FACE_BACKGROUND (face) != 0
-                  ? [NSColor colorWithUnsignedLong:NS_FACE_BACKGROUND (face)]
-                  : FRAME_BACKGROUND_COLOR (s->f)) set];
-              else
-                [FRAME_CURSOR_COLOR (s->f) set];
-            }
+            {
+              if (s->hl != DRAW_CURSOR)
+                [(NS_FACE_BACKGROUND (face) != 0
+                  ? [NSColor colorWithUnsignedLong:NS_FACE_BACKGROUND (face)]
+                  : FRAME_BACKGROUND_COLOR (s->f)) set];
+              else if (face && (NS_FACE_BACKGROUND (face)
+                                == [(NSColor *) FRAME_CURSOR_COLOR (s->f)
+                                                unsignedLong]))
+                [[NSColor colorWithUnsignedLong:NS_FACE_FOREGROUND (face)] set];
+              else
+                [FRAME_CURSOR_COLOR (s->f) set];
+            }
           else
             {
               struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (s->f);
diff --git a/src/treesit.c b/src/treesit.c
index dbbfa29c19d..d2dd83b29fe 100644
--- a/src/treesit.c
+++ b/src/treesit.c
@@ -421,10 +421,17 @@ static Lisp_Object Vtreesit_str_match;
 static Lisp_Object Vtreesit_str_pred;
 
 /* This is the limit on recursion levels for some tree-sitter
-   functions.  Remember to update docstrings when changing this
-   value. */
-const ptrdiff_t treesit_recursion_limit = 1000;
-bool treesit_initialized = false;
+   functions.  Remember to update docstrings when changing this value.
+
+   If we think of programs and AST, it is very rare for any program to
+   have a very deep AST. For example, you would need 1000+ levels of
+   nested if-statements, or a struct somehow nested for 1000+ levels.
+   It’s hard for me to imagine any hand-written or machine generated
+   program to be like that.  So I think 1000 is already generous.  If
+   we look at xdisp.c, its AST only have 30 levels.  */
+#define TREESIT_RECURSION_LIMIT 1000
+
+static bool treesit_initialized = false;
 
 static bool
 load_tree_sitter_if_necessary (bool required)
@@ -478,40 +485,47 @@ treesit_initialize (void)
 static void
 treesit_symbol_to_c_name (char *symbol_name)
 {
-  for (int idx = 0; idx < strlen (symbol_name); idx++)
+  size_t len = strlen (symbol_name);
+  for (int idx = 0; idx < len; idx++)
     {
       if (symbol_name[idx] == '-')
         symbol_name[idx] = '_';
     }
 }
 
+/* Find the override name for LANGUAGE_SYMBOL in
+   treesit-load-name-override-list.  Set NAME and C_SYMBOL to the
+   override name, and return true if there exists one, otherwise
+   return false.
+
+   This function may signal if treesit-load-name-override-list is
+   malformed.  */
 static bool
 treesit_find_override_name (Lisp_Object language_symbol, Lisp_Object *name,
                             Lisp_Object *c_symbol)
 {
-  Lisp_Object tem;
-
   CHECK_LIST (Vtreesit_load_name_override_list);
+  Lisp_Object tail = Vtreesit_load_name_override_list;
 
-  tem = Vtreesit_load_name_override_list;
-
-  FOR_EACH_TAIL (tem)
+  FOR_EACH_TAIL (tail)
     {
-      Lisp_Object lang = XCAR (XCAR (tem));
+      Lisp_Object entry = XCAR (tail);
+      CHECK_LIST (entry);
+      Lisp_Object lang = XCAR (entry);
       CHECK_SYMBOL (lang);
 
       if (EQ (lang, language_symbol))
         {
-          *name = Fnth (make_fixnum (1), XCAR (tem));
+          *name = Fnth (make_fixnum (1), entry);
           CHECK_STRING (*name);
-          *c_symbol = Fnth (make_fixnum (2), XCAR (tem));
+          *c_symbol = Fnth (make_fixnum (2), entry);
           CHECK_STRING (*c_symbol);
 
           return true;
         }
     }
 
-  CHECK_LIST_END (tem, Vtreesit_load_name_override_list);
+  CHECK_LIST_END (tail, Vtreesit_load_name_override_list);
 
   return false;
 }
@@ -1619,6 +1633,9 @@ buffer.  */)
       TSRange *treesit_ranges = xmalloc (sizeof (TSRange) * len);
       struct buffer *buffer = XBUFFER (XTS_PARSER (parser)->buffer);
 
+      /* We can use XFUXNUM, XCAR, XCDR freely because we have checked
+         the input by treesit_check_range_argument.  */
+
       for (int idx = 0; !NILP (ranges); idx++, ranges = XCDR (ranges))
         {
           Lisp_Object range = XCAR (ranges);
@@ -1639,9 +1656,6 @@ buffer.  */)
         }
       success = ts_parser_set_included_ranges (XTS_PARSER (parser)->parser,
                                                treesit_ranges, len);
-      /* Although XFIXNUM could signal, it should be impossible
-         because we have checked the input by treesit_check_range_argument.
-         So there is no need for unwind-protect.  */
       xfree (treesit_ranges);
     }
 
@@ -2295,11 +2309,11 @@ See Info node `(elisp)Pattern Matching' for detailed explanation.  */)
 {
   if (BASE_EQ (pattern, QCanchor))
     return Vtreesit_str_dot;
-  if (BASE_EQ (pattern, intern_c_string (":?")))
+  if (BASE_EQ (pattern, QCquestion))
     return Vtreesit_str_question_mark;
-  if (BASE_EQ (pattern, intern_c_string (":*")))
+  if (BASE_EQ (pattern, QCstar))
     return Vtreesit_str_star;
-  if (BASE_EQ (pattern, intern_c_string (":+")))
+  if (BASE_EQ (pattern, QCplus))
     return Vtreesit_str_plus;
   if (BASE_EQ (pattern, QCequal))
     return Vtreesit_str_pound_equal;
@@ -3008,7 +3022,7 @@ treesit_cursor_helper (TSTreeCursor *cursor, TSNode node, Lisp_Object parser)
   TSNode root = ts_tree_root_node (XTS_PARSER (parser)->tree);
   *cursor = ts_tree_cursor_new (root);
   bool success = treesit_cursor_helper_1 (cursor, &node, end_pos,
-                                          treesit_recursion_limit);
+                                          TREESIT_RECURSION_LIMIT);
   if (!success)
     ts_tree_cursor_delete (cursor);
   return success;
@@ -3139,17 +3153,80 @@ treesit_traverse_child_helper (TSTreeCursor *cursor,
     }
 }
 
+/* Assq but doesn't signal.  */
+static Lisp_Object
+safe_assq (Lisp_Object key, Lisp_Object alist)
+{
+  Lisp_Object tail = alist;
+  FOR_EACH_TAIL_SAFE (tail)
+    if (CONSP (XCAR (tail)) && EQ (XCAR (XCAR (tail)), key))
+      return XCAR (tail);
+  return Qnil;
+}
+
+/* Given a symbol THING, and a language symbol LANGUAGE, find the
+   corresponding predicate definition in treesit-things-settings.
+   Don't check for the type of THING and LANGUAGE.
+
+   If there isn't one, return Qnil.  */
+static Lisp_Object
+treesit_traverse_get_predicate (Lisp_Object thing, Lisp_Object language)
+{
+  Lisp_Object cons = safe_assq (language, Vtreesit_thing_settings);
+  if (NILP (cons))
+    return Qnil;
+  Lisp_Object definitions = XCDR (cons);
+  Lisp_Object entry = safe_assq (thing, definitions);
+  if (NILP (entry))
+    return Qnil;
+  /* ENTRY looks like (THING PRED).  */
+  Lisp_Object cdr = XCDR (entry);
+  if (!CONSP (cdr))
+    return Qnil;
+  return XCAR (cdr);
+}
+
 /* Validate the PRED passed to treesit_traverse_match_predicate.  If
    there's an error, set SIGNAL_DATA to something signal accepts, and
-   return false, otherwise return true.  */
+   return false, otherwise return true.  This function also check for
+   recusion levels: we place a arbitrary 100 level limit on recursive
+   predicates.  RECURSION_LEVEL is the current recursion level (that
+   starts at 0), if it goes over 99, return false and set
+   SIGNAL_DATA.  LANGUAGE is a LANGUAGE symbol.  */
 static bool
 treesit_traverse_validate_predicate (Lisp_Object pred,
-                                     Lisp_Object *signal_data)
+                                     Lisp_Object language,
+                                     Lisp_Object *signal_data,
+                                     ptrdiff_t recursion_level)
 {
+  if (recursion_level > 99)
+    {
+      *signal_data = list1 (build_string ("Predicate recursion level "
+                                          "exceeded: it must not exceed "
+                                          "100 levels"));
+      return false;
+    }
   if (STRINGP (pred))
     return true;
   else if (FUNCTIONP (pred))
     return true;
+  else if (SYMBOLP (pred))
+    {
+      Lisp_Object definition = treesit_traverse_get_predicate (pred,
+                                                               language);
+      if (NILP (definition))
+        {
+          *signal_data = list2 (build_string ("Cannot find the definition "
+                                              "of the predicate in "
+                                              "`treesit-things-settings'"),
+                                pred);
+          return false;
+        }
+      return treesit_traverse_validate_predicate (definition,
+                                                  language,
+                                                  signal_data,
+                                                  recursion_level + 1);
+    }
   else if (CONSP (pred))
     {
       Lisp_Object car = XCAR (pred);
@@ -3172,7 +3249,9 @@ treesit_traverse_validate_predicate (Lisp_Object pred,
               return false;
             }
           return treesit_traverse_validate_predicate (XCAR (cdr),
-                                                      signal_data);
+                                                      language,
+                                                      signal_data,
+                                                      recursion_level + 1);
         }
       else if (BASE_EQ (car, Qor))
         {
@@ -3187,7 +3266,9 @@ treesit_traverse_validate_predicate (Lisp_Object pred,
           FOR_EACH_TAIL (cdr)
             {
               if (!treesit_traverse_validate_predicate (XCAR (cdr),
-                                                        signal_data))
+                                                        language,
+                                                        signal_data,
+                                                        recursion_level + 1))
                 return false;
             }
           return true;
@@ -3195,8 +3276,7 @@ treesit_traverse_validate_predicate (Lisp_Object pred,
       else if (STRINGP (car) && FUNCTIONP (cdr))
         return true;
     }
-  *signal_data = list2 (build_string ("Invalid predicate, see TODO for "
-                                      "valid forms of predicate"),
+  *signal_data = list2 (build_string ("Invalid predicate, see `treesit-thing-settings' for valid forms of predicate"),
                         pred);
   return false;
 }
@@ -3232,6 +3312,14 @@ treesit_traverse_match_predicate (TSTreeCursor *cursor, Lisp_Object pred,
       Lisp_Object lisp_node = make_treesit_node (parser, node);
       return !NILP (CALLN (Ffuncall, pred, lisp_node));
     }
+  else if (SYMBOLP (pred))
+    {
+      Lisp_Object language = XTS_PARSER (parser)->language_symbol;
+      Lisp_Object definition = treesit_traverse_get_predicate (pred,
+                                                               language);
+      return treesit_traverse_match_predicate (cursor, definition,
+                                               parser, named);
+    }
   else if (CONSP (pred))
     {
       Lisp_Object car = XCAR (pred);
@@ -3268,10 +3356,11 @@ treesit_traverse_match_predicate (TSTreeCursor *cursor, Lisp_Object pred,
   return false;
 }
 
-/* Traverse the parse tree starting from CURSOR.  See TODO for the
-   shapes PRED can have.  If the node satisfies PRED, leave CURSOR on
-   that node and return true.  If no node satisfies PRED, move CURSOR
-   back to starting position and return false.
+/* Traverse the parse tree starting from CURSOR.  See
+   `treesit-thing-settings' for the shapes PRED can have.  If the
+   node satisfies PRED, leave CURSOR on that node and return true.  If
+   no node satisfies PRED, move CURSOR back to starting position and
+   return false.
 
    LIMIT is the number of levels we descend in the tree.  FORWARD
    controls the direction in which we traverse the tree, true means
@@ -3384,13 +3473,9 @@ Return the first matched node, or nil if none matches.  */)
   CHECK_SYMBOL (all);
   CHECK_SYMBOL (backward);
 
-  Lisp_Object signal_data = Qnil;
-  if (!treesit_traverse_validate_predicate (predicate, &signal_data))
-    xsignal1 (Qtreesit_invalid_predicate, signal_data);
-
   /* We use a default limit of 1000.  See bug#59426 for the
      discussion.  */
-  ptrdiff_t the_limit = treesit_recursion_limit;
+  ptrdiff_t the_limit = TREESIT_RECURSION_LIMIT;
   if (!NILP (depth))
     {
       CHECK_FIXNUM (depth);
@@ -3400,6 +3485,13 @@ Return the first matched node, or nil if none matches.  */)
   treesit_initialize ();
 
   Lisp_Object parser = XTS_NODE (node)->parser;
+  Lisp_Object language = XTS_PARSER (parser)->language_symbol;
+
+  Lisp_Object signal_data = Qnil;
+  if (!treesit_traverse_validate_predicate (predicate, language,
+                                            &signal_data, 0))
+    xsignal1 (Qtreesit_invalid_predicate, signal_data);
+
   Lisp_Object return_value = Qnil;
   TSTreeCursor cursor;
   if (!treesit_cursor_helper (&cursor, XTS_NODE (node)->node, parser))
@@ -3455,13 +3547,16 @@ always traverse leaf nodes first, then upwards.  */)
   CHECK_SYMBOL (all);
   CHECK_SYMBOL (backward);
 
-  Lisp_Object signal_data = Qnil;
-  if (!treesit_traverse_validate_predicate (predicate, &signal_data))
-    xsignal1 (Qtreesit_invalid_predicate, signal_data);
-
   treesit_initialize ();
 
   Lisp_Object parser = XTS_NODE (start)->parser;
+  Lisp_Object language = XTS_PARSER (parser)->language_symbol;
+
+  Lisp_Object signal_data = Qnil;
+  if (!treesit_traverse_validate_predicate (predicate, language,
+                                            &signal_data, 0))
+    xsignal1 (Qtreesit_invalid_predicate, signal_data);
+
   Lisp_Object return_value = Qnil;
   TSTreeCursor cursor;
   if (!treesit_cursor_helper (&cursor, XTS_NODE (start)->node, parser))
@@ -3572,16 +3667,12 @@ a regexp.  */)
 {
   CHECK_TS_NODE (root);
 
-  Lisp_Object signal_data = Qnil;
-  if (!treesit_traverse_validate_predicate (predicate, &signal_data))
-    xsignal1 (Qtreesit_invalid_predicate, signal_data);
-
   if (!NILP (process_fn))
     CHECK_TYPE (FUNCTIONP (process_fn), Qfunctionp, process_fn);
 
   /* We use a default limit of 1000.  See bug#59426 for the
      discussion.  */
-  ptrdiff_t the_limit = treesit_recursion_limit;
+  ptrdiff_t the_limit = TREESIT_RECURSION_LIMIT;
   if (!NILP (depth))
     {
       CHECK_FIXNUM (depth);
@@ -3591,6 +3682,13 @@ a regexp.  */)
   treesit_initialize ();
 
   Lisp_Object parser = XTS_NODE (root)->parser;
+  Lisp_Object language = XTS_PARSER (parser)->language_symbol;
+
+  Lisp_Object signal_data = Qnil;
+  if (!treesit_traverse_validate_predicate (predicate, language,
+                                            &signal_data, 0))
+    xsignal1 (Qtreesit_invalid_predicate, signal_data);
+
   Lisp_Object parent = Fcons (Qnil, Qnil);
   /* In this function we never traverse above NODE, so we don't need
      to use treesit_cursor_helper.  */
@@ -3612,6 +3710,40 @@ a regexp.  */)
     return parent;
 }
 
+DEFUN ("treesit-node-match-p",
+       Ftreesit_node_match_p,
+       Streesit_node_match_p, 2, 2, 0,
+       doc: /* Check whether NODE matches PREDICATE.
+
+PREDICATE can be a regexp matching node type, a predicate function,
+and more, see `treesit-things-definition' for detail.  Return non-nil
+if NODE matches PRED, nil otherwise.  */)
+  (Lisp_Object node, Lisp_Object predicate)
+{
+  CHECK_TS_NODE (node);
+
+  Lisp_Object parser = XTS_NODE (node)->parser;
+  Lisp_Object language = XTS_PARSER (parser)->language_symbol;
+
+  Lisp_Object signal_data = Qnil;
+  if (!treesit_traverse_validate_predicate (predicate, language,
+                                            &signal_data, 0))
+    xsignal1 (Qtreesit_invalid_predicate, signal_data);
+
+  TSTreeCursor cursor = ts_tree_cursor_new (XTS_NODE (node)->node);
+
+  specpdl_ref count = SPECPDL_INDEX ();
+  record_unwind_protect_ptr (treesit_traverse_cleanup_cursor, &cursor);
+
+  bool match = false;
+  match = treesit_traverse_match_predicate (&cursor, predicate,
+                                            parser, false);
+
+  unbind_to (count, Qnil);
+
+  return match ? Qt : Qnil;
+}
+
 DEFUN ("treesit-subtree-stat",
        Ftreesit_subtree_stat,
        Streesit_subtree_stat, 1, 1, 0,
@@ -3709,6 +3841,9 @@ syms_of_treesit (void)
   DEFSYM (Qnot, "not");
 
   DEFSYM (QCanchor, ":anchor");
+  DEFSYM (QCquestion, ":?");
+  DEFSYM (QCstar, ":*");
+  DEFSYM (QCplus, ":+");
   DEFSYM (QCequal, ":equal");
   DEFSYM (QCmatch, ":match");
   DEFSYM (QCpred, ":pred");
@@ -3760,7 +3895,8 @@ syms_of_treesit (void)
                 "This parser is deleted and cannot be used",
                 Qtreesit_error);
   define_error (Qtreesit_invalid_predicate,
-                "Invalid predicate, see TODO for valid forms for a predicate",
+                "Invalid predicate, see `treesit-thing-settings' "
+                "for valid forms for a predicate",
                 Qtreesit_error);
 
   DEFVAR_LISP ("treesit-load-name-override-list",
@@ -3792,6 +3928,33 @@ then in the `tree-sitter' subdirectory of `user-emacs-directory', and
 then in the system default locations for dynamic libraries, in that order.  */);
   Vtreesit_extra_load_path = Qnil;
 
+  DEFVAR_LISP ("treesit-thing-settings",
+               Vtreesit_thing_settings,
+               doc:
+               /* A list defining things.
+
+The value should be an alist of (LANGUAGE . DEFINITIONS), where
+LANGUAGE is a language symbol, and DEFINITIONS is a list of
+
+    (THING PRED)
+
+THING is a symbol representing the thing, like `defun', `sexp', or
+`block'; PRED defines what kind of node can be qualified as THING.
+
+PRED can be a regexp string that matches the type of the node; it can
+be a predicate function that takes the node as the sole argument and
+returns t if the node is the thing; it can be a cons (REGEXP . FN),
+which is a combination of a regexp and a predicate function, and the
+node has to match both to qualify as the thing.
+
+PRED can also be recursively defined.  It can be (or PRED...), meaning
+satisfying anyone of the inner PREDs qualifies the node; or (not
+PRED), meaning not satisfying the inner PRED qualifies the node.
+
+Finally, PRED can refer to other THINGs defined in this list by using
+the symbol of that THING.  For example, (or block sexp).  */);
+  Vtreesit_thing_settings = Qnil;
+
   staticpro (&Vtreesit_str_libtree_sitter);
   Vtreesit_str_libtree_sitter = build_pure_c_string ("libtree-sitter-");
   staticpro (&Vtreesit_str_tree_sitter);
@@ -3879,6 +4042,7 @@ then in the system default locations for dynamic libraries, in that order.  */);
   defsubr (&Streesit_search_subtree);
   defsubr (&Streesit_search_forward);
   defsubr (&Streesit_induce_sparse_tree);
+  defsubr (&Streesit_node_match_p);
   defsubr (&Streesit_subtree_stat);
 #endif /* HAVE_TREE_SITTER */
   defsubr (&Streesit_available_p);
diff --git a/src/w32.c b/src/w32.c
index f45750ea5c1..c75beb630e5 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -543,7 +543,14 @@ typedef LANGID (WINAPI *GetUserDefaultUILanguage_Proc) (void);
 
 typedef COORD (WINAPI *GetConsoleFontSize_Proc) (HANDLE, DWORD);
 
-#if _WIN32_WINNT < 0x0501
+/* Old versions of mingw.org's MinGW, before v5.2.0, don't have a
+   _WIN32_WINNT guard for CONSOLE_FONT_INFO in wincon.h, and so don't
+   need the conditional definition below, which causes compilation
+   errors.  Note: MinGW64 sets _WIN32_WINNT to a higher version, and
+   its w32api.h version stays fixed at 3.14.  */
+#if _WIN32_WINNT < 0x0501 \
+    && (__W32API_MAJOR_VERSION > 5 \
+        || (__W32API_MAJOR_VERSION == 5 && __W32API_MINOR_VERSION >= 2))
 typedef struct
 {
   DWORD nFont;