;ELC ;;; Compiled ;;; in Emacs version 29.4 ;;; with all optimizations. (byte-code "\300\301!\210\300\302!\210\300\303!\210\304\305\306\307\310\311\312\313&\210\314\315\316\317\320DD\321\322\323\312\313&\207" [require cl-seq font-lock seq custom-declare-group treesit nil "Incremental parser.\nIt is used to enhance major mode features like font-lock,\nindent, imenu, etc." :group tools :version "29.1" custom-declare-variable treesit-max-buffer-size funcall function #[0 "\302W\204\303 \304\305\306$\266\203\203\307\207\310\207" [most-positive-fixnum system-configuration-options 2147483648.0 "--with-wide-int" nil string-match t 15728640 41943040] 8 ""] "Maximum buffer size (in bytes) for enabling tree-sitter parsing.\n\nA typical tree-sitter parser needs 10 times as much memory as the\nbuffer it parses. Also, the tree-sitter library has a hard limit\nof max unsigned 32-bit value for byte offsets into buffer text." :type integer] 8)#@106 Parse STRING using a parser for LANGUAGE. Return the root node of the syntax tree. (fn STRING LANGUAGE) (defalias 'treesit-parse-string #[514 "\300\301!r\211q\210c\210\302\303!!)\207" [generate-new-buffer " *treesit-parse-string*" treesit-parser-root-node treesit-parser-create] 6 (#$ . 964)])#@527 A function that returns the language at point. This is used by `treesit-language-at', which is used by various functions to determine which parser to use at point. The function is called with one argument, the position of point. In general, this function should call `treesit-node-at' with an explicit language (usually the host language), and determine the language at point using the type of the returned node. DO NOT derive the language at point from parser ranges. It's cumbersome and can't deal with some edge cases. (defvar treesit-language-at-point-function nil (#$ . 1267)) (make-variable-buffer-local 'treesit-language-at-point-function)#@302 Return the language at POSITION. This function assumes that parser ranges are up-to-date. It returns the return value of `treesit-language-at-point-function' if it's non-nil, otherwise it returns the language of the first parser in `treesit-parser-list', or nil if there is no parser. (fn POSITION) (defalias 'treesit-language-at #[257 "\203!\207\301 @\211\205\302!\207" [treesit-language-at-point-function treesit-parser-list treesit-parser-language] 4 (#$ . 1924)]) (define-error 'treesit-no-parser "No available parser for this buffer" 'treesit-error)#@53 Return the buffer in which NODE belongs. (fn NODE) (defalias 'treesit-node-buffer #[257 "\300\301!!\207" [treesit-parser-buffer treesit-node-parser] 4 (#$ . 2494)])#@64 Return the language symbol that NODE's parser uses. (fn NODE) (defalias 'treesit-node-language #[257 "\300\301!!\207" [treesit-parser-language treesit-node-parser] 4 (#$ . 2666)])#@877 Return the leaf node at position POS. A leaf node is a node that doesn't have any child nodes. The returned node's span covers POS: the node's beginning is before or at POS, and the node's end is after POS. If no such node exists, but there's a leaf node which ends at POS, return that node. Otherwise (e.g., when POS is on whitespace between two leaf nodes), return the first leaf node after POS. If there is no leaf node after POS, return the first leaf node before POS. Return nil if no leaf node can be returned. If NAMED is non-nil, only look for named nodes. If PARSER-OR-LANG is a parser, use that parser; if PARSER-OR-LANG is a language, find the first parser for that language in the current buffer, or create one if none exists; If PARSER-OR-LANG is nil, try to guess the language at POS using `treesit-language-at'. (fn POS &optional PARSER-OR-LANG NAMED) (defalias 'treesit-node-at #[769 "\300!\203\f\301!\202\302\206\303!!\211Se]\304\205x\305 #\211\262\2033\211\262\202 \306\"\203O\307\310#\211\262\203M\211\262\202;\207\311!X\203Z\207\305#\211\262\203l\211\262\202Z\312!=\203w\207\207" [treesit-parser-p treesit-parser-root-node treesit-buffer-root-node treesit-language-at nil treesit-node-first-child-for-pos treesit-node-eq treesit-node-child -1 treesit-node-start treesit-node-end] 12 (#$ . 2854)])#@722 Return the smallest node covering BEG to END. BEWARE! Calling this function on an empty line that is not inside any top-level construct (function definition, etc.) most probably will give you the root node, because the root node is the smallest node that covers that empty line. You probably want to use `treesit-node-at' instead. Return nil if none was found. If NAMED is non-nil, only look for named node. If PARSER-OR-LANG is a parser, use that parser; if PARSER-OR-LANG is a language, find the first parser for that language in the current buffer, or create one if none exists; If PARSER-OR-LANG is nil, try to guess the language at BEG using `treesit-language-at'. (fn BEG END &optional PARSER-OR-LANG NAMED) (defalias 'treesit-node-on #[1026 "\300!\203\f\301!\202\302\206\303!!\304\206 $\207" [treesit-parser-p treesit-parser-root-node treesit-buffer-root-node treesit-language-at treesit-node-descendant-for-range] 10 (#$ . 4238)])#@470 Return the top-level equivalent of NODE. Specifically, return the highest parent of NODE that has the same type as it. If no such parent exists, return nil. If PRED is non-nil, match each parent's type with PRED as a regexp, rather than using NODE's type. PRED can also be a function that takes the node as an argument, and return non-nil/nil for match/no match. If INCLUDE-NODE is non-nil, return NODE if it satisfies PRED. (fn NODE &optional PRED INCLUDE-NODE) (defalias 'treesit-node-top-level #[769 "\206\300!\301\211\302\211\203\203\202!\303!\202!\303!\262\203K;\203<\300!\301\304\302$\266\203\202?!\203E\262\301\262\202\n\266\207" [treesit-node-type nil t treesit-node-parent string-match] 15 (#$ . 5208)])#@243 Return the root node of the current buffer. Use the first parser in the parser list if LANGUAGE is omitted. If LANGUAGE is non-nil, use the first parser for LANGUAGE in the parser list, or create one if none exists. (fn &optional LANGUAGE) (defalias 'treesit-buffer-root-node #[256 "\211\203\n\300!\202\301 @\206\302\303pC\"\211\205\304!\207" [treesit-parser-create treesit-parser-list signal treesit-no-parser treesit-parser-root-node] 4 (#$ . 5968)])#@215 Return children of NODE that satisfies predicate PRED. PRED is a function that takes one argument, the child node. If optional argument NAMED is non-nil, only search for named node. (fn NODE PRED &optional NAMED) (defalias 'treesit-filter-child #[770 "\300\301#\302\203!\203B\262\303\"\262\202\304!\207" [treesit-node-child 0 nil treesit-node-next-sibling reverse] 8 (#$ . 6438)])#@164 Return the buffer (or string) content corresponding to NODE. If optional argument NO-PROPERTY is non-nil, remove text properties. (fn NODE &optional NO-PROPERTY) (defalias 'treesit-node-text #[513 "\205!r\300!q\210\211\203\301\302!\303!\"\202 \302!\303!{)\207" [treesit-node-buffer buffer-substring-no-properties treesit-node-start treesit-node-end] 6 (#$ . 6844)])#@572 Return the closest parent of NODE that satisfies PRED. This function successively examines the parent of NODE, then the parent of the parent, etc., until it finds the first ancestor node which satisfies the predicate PRED; then it returns that ancestor node. It returns nil if no ancestor node was found that satisfies PRED. PRED should be a function that takes one argument, the node to examine, and returns a boolean value indicating whether that node is a match. If INCLUDE-NODE is non-nil, return NODE if it satisfies PRED. (fn NODE PRED &optional INCLUDE-NODE) (defalias 'treesit-parent-until #[770 "\211\203\202 \300!\211\203!\204\300!\262\202 \207" [treesit-node-parent] 6 (#$ . 7227)])#@499 Return the furthest parent of NODE (including NODE) that satisfies PRED. This function successively examines NODE, the parent of NODE, then the parent of the parent, etc., until it finds a node which no longer satisfies the predicate PRED; it returns the last examined node that satisfies PRED. If no node satisfies PRED, it returns nil. PRED should be a function that takes one argument, the node to examine, and returns a boolean value indicating whether that node is a match. (fn NODE PRED) (defalias 'treesit-parent-while #[514 "\300\203!\203\262\301!\262\202\207" [nil treesit-node-parent] 5 (#$ . 7946)])#@109 Return a list of NODE's children. If NAMED is non-nil, collect named child only. (fn NODE &optional NAMED) (defalias 'treesit-node-children #[513 "\300\301\302#\303\304\305\"S\"\"\207" [mapcar make-closure #[257 "\302\301\300#\207" [V0 V1 treesit-node-child] 5 "\n\n(fn IDX)"] number-sequence 0 treesit-node-child-count] 9 (#$ . 8580)])#@113 Return the index of NODE in its parent. If NAMED is non-nil, count named child only. (fn NODE &optional NAMED) (defalias 'treesit-node-index #[513 "\300\301\"\211\262\203\211T\262\202\207" [0 treesit-node-prev-sibling] 6 (#$ . 8931)])#@68 Return the field name of NODE as a child of its parent. (fn NODE) (defalias 'treesit-node-field-name #[257 "\300!\211\205\n\301!\211\205\302\"\207" [treesit-node-parent treesit-node-index treesit-node-field-name-for-child] 6 (#$ . 9180)])#@105 Query STRING with QUERY in LANGUAGE. See `treesit-query-capture' for QUERY. (fn STRING QUERY LANGUAGE) (defalias 'treesit-query-string #[771 "\300\301\302\"r\211q\210\303\304\"\216c\210\305!\306\307!\"*\207" [generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205 \302\300!\207" [V0 buffer-name kill-buffer] 2] treesit-parser-create treesit-query-capture treesit-parser-root-node] 8 (#$ . 9433)])#@368 Query the current buffer and return ranges of captured nodes. QUERY, NODE, BEG, END are the same as in `treesit-query-capture'. This function returns a list of (START . END), where START and END specifics the range of each captured node. Capture names generally don't matter, but names that starts with an underscore are ignored. (fn NODE QUERY &optional BEG END) (defalias 'treesit-query-range #[1026 "\300$\301\211\211\211\211:\203;@\262@\262A\262\302\303\304!\"\2041\305!\306!BB\262A\262\301\262\202 \237\207" [treesit-query-capture nil string-prefix-p "_" symbol-name treesit-node-start treesit-node-end] 14 (#$ . 9852)])#@677 A list of range settings. Each element of the list is of the form (QUERY LANGUAGE). When updating the range of each parser in the buffer, `treesit-update-ranges' queries each QUERY, and sets LANGUAGE's range to the range spanned by captured nodes. QUERY must be a compiled query. Capture names generally don't matter, but names that starts with an underscore are ignored. QUERY can also be a function, in which case it is called with 2 arguments, START and END. It should ensure parsers' ranges are correct in the region between START and END. The exact form of each setting is considered internal and subject to change. Use `treesit-range-rules' to set this variable. (defvar treesit-range-settings nil (#$ . 10511)) (make-variable-buffer-local 'treesit-range-settings)#@1292 Produce settings for `treesit-range-settings'. QUERY-SPECS are a series of QUERY-SPECs, where each QUERY-SPEC is a QUERY preceded by zero or more pairs of :KEYWORD and VALUE, like this: :KEYWORD VALUE... QUERY Each QUERY is a tree-sitter query in either the string, s-expression or compiled form. Capture names generally don't matter, but names that starts with an underscore are ignored. For each QUERY, :KEYWORD and VALUE pairs add meta information to it. For example, (treesit-range-rules :embed \='javascript :host \='html \='((script_element (raw_text) @cap))) The `:embed' keyword specifies the embedded language, and the `:host' keyword specifies the host language. They are used in this way: Emacs queries QUERY in the host language's parser, computes the ranges spanned by the captured nodes, and applies these ranges to parsers for the embedded language. QUERY can also be a function that takes two arguments, START and END. If QUERY is a function, it doesn't need the :KEYWORD VALUE pair preceding it. This function should set the ranges for parsers in the current buffer in the region between START and END. It is OK for this function to set ranges in a larger region that encompasses the region between START and END. (fn &rest QUERY-SPECS) (defalias 'treesit-range-rules #[128 "\300\211\211\203}\211A\262\242\211\301\267\202C\211A\262\242\2119\204%\302\303\304D\"\210\262\210\202\211A\262\242\2119\204=\302\303\305D\"\210\262\210\202\306!\203T\211\300\211EB\262\202s\204^\302\303\307C\"\210\204h\302\303\310C\"\210\311\"EB\262\300\262\300\262\210\202\211\237\207" [nil #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:host 19 :embed 43)) signal treesit-error "Value of :host option should be a symbol" "Value of :embed option should be a symbol" functionp "Value of :embed option cannot be omitted" "Value of :host option cannot be omitted" treesit-query-compile] 10 (#$ . 11296)])#@468 Merge OLD-RANGES and NEW-RANGES, discarding ranges between START and END. OLD-RANGES and NEW-RANGES are lists of cons of the form (BEG . END). When merging the two ranges, if a range in OLD-RANGES intersects with another range in NEW-RANGES, discard the one in OLD-RANGES and keep the one in NEW-RANGES. Also discard any range in OLD-RANGES that intersects the region marked by START and END. Return the merged list of ranges. (fn OLD-RANGES NEW-RANGES START END) (defalias 'treesit--merge-ranges #[1028 "\300\203g\203g@@@A@@@AW\203/W\203/A\262 \266\202X\203F@B\262A\262\266\202\211X\203]@B\262A\262 \266\202A\262 \266\202\206l\211\211\203\211@\211B\262A\266\202\202m\266\211\237\207" [nil] 11 (#$ . 13311)])#@210 Clip RANGES in between START and END. RANGES is a list of ranges of the form (BEG . END). Ranges outside of the region between START and END are thrown away, and those inside are kept. (fn RANGES START END) (defalias 'treesit--clip-ranges #[771 "\300\211:\203$@\262\301@A$\203B\262A\262\202\211\237\207" [nil <=] 11 (#$ . 14091)])#@154 Update the ranges for each language in the current buffer. If BEG and END are non-nil, only update parser ranges in that region. (fn &optional BEG END) (defalias 'treesit-update-ranges #[512 "\211\205p\211@\211@A@\206e\206d\301!\203%\"\266\202i\302!\303!\304!\305$\306\307  $ed#\310 \211\203g\211@\311!\n=\203`\312\206^eeBC\"\210A\266\202\202E\266\nA\266\202\202\207" [treesit-range-settings functionp treesit-query-language treesit-parser-create treesit-parser-included-ranges treesit-query-range treesit--clip-ranges treesit--merge-ranges treesit-parser-list treesit-parser-language treesit-parser-set-included-ranges] 19 (#$ . 14449)])#@248 Check if PARSER's range covers the portion between BEG and END. If it does, return the range covering that portion in the form of (RANGE-BEG . RANGE-END), if not, return nil. If nil or omitted, default END to BEG. (fn PARSER BEG &optional END) (defalias 'treesit-parser-range-on #[770 "\300!\206\204edB\207\301\302\301:\203@@\262\303@ A$\2035\262\301\211\262\2026\302\203@A\262\202?\205F\211\207" [treesit-parser-included-ranges nil t <=] 14 (#$ . 15137)]) (define-error 'treesit-font-lock-error "Generic tree-sitter font-lock error" 'treesit-error)#@747 A list of SETTINGs for treesit-based fontification. The exact format of each SETTING is considered internal. Use `treesit-font-lock-rules' to set this variable. Each SETTING has the form: (QUERY ENABLE FEATURE OVERRIDE) QUERY must be a compiled query. See Info node `(elisp)Pattern Matching' for how to write a query and compile it. For SETTING to be activated for font-lock, ENABLE must be t. To disable this SETTING, set ENABLE to nil. FEATURE is the "feature name" of the query. Users can control which features are enabled with `treesit-font-lock-level' and `treesit-font-lock-feature-list'. OVERRIDE is the override flag for this query. Its value can be t, nil, append, prepend, keep. See more in `treesit-font-lock-rules'. (defvar treesit-font-lock-settings nil (#$ . 15727)) (make-variable-buffer-local 'treesit-font-lock-settings)#@211 Custom setter for `treesit-font-lock-level'. Set the default value of SYM to VAL, recompute fontification features and refontify for every buffer where tree-sitter-based fontification is enabled. (fn SYM VAL) (defalias 'treesit--font-lock-level-setter #[514 "\300\"\210\301 \205\302C\211\303\304#\240\210\211\242\262\302\305 \"\207" [set-default treesit-available-p nil make-closure #[514 "\211\204\f\303\304\305\301\"\"\207\211@r\211q\210\n\203#\300\242\306C\"A\"\202)\300\242A\")\207" [V0 V1 treesit-font-lock-settings mapc make-closure #[257 "r\211q\210\302\301!\210\300\303 \210\304ed\")\207" [V0 treesit-font-lock-level make-local-variable treesit-font-lock-recompute-features treesit-font-lock-fontify-region] 4 "\n\n(fn B)"] append] 7 "\n\n(fn RES BUFFERS)"] buffer-list] 8 (#$ . 16589)]) (byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313& \207" [custom-declare-variable treesit-font-lock-level funcall function #[0 "\300\207" [3] 1 ""] "Decoration level to be used by tree-sitter fontifications.\n\nMajor modes categorize their fontification features into levels,\nfrom 1 which is the absolute minimum, to 4 that yields the maximum\nfontifications.\n\nLevel 1 usually contains only comments and definitions.\nLevel 2 usually adds keywords, strings, data types, etc.\nLevel 3 usually represents full-blown fontifications, including\nassignments, constants, numbers and literals, etc.\nLevel 4 adds everything else that can be fontified: delimiters,\noperators, brackets, punctuation, all functions, properties,\nvariables, etc.\n\nIn addition to the decoration level, individual features can be\nturned on/off by calling `treesit-font-lock-recompute-features'.\nChanging the decoration level requires calling\n`treesit-font-lock-recompute-features' to have an effect, unless\ndone via `customize-variable'.\n\nTo see which syntactical categories are fontified by each level\nin a particular major mode, examine the buffer-local value of the\nvariable `treesit-font-lock-feature-list'." :type integer :set treesit--font-lock-level-setter :version "29.1"] 10)#@353 The amount to expand the start and end of the region when fontifying. This should be a cons cell (START . END). When fontifying a buffer, Emacs will move the start of the query range backward by START amount, and the end of the query range by END amount. Both START and END should be positive integers or 0. This doesn't affect the fontified range. (defvar treesit--font-lock-query-expand-range (byte-code "\300\211B\207" [0] 2) (#$ . 18691)) (make-variable-buffer-local 'treesit--font-lock-query-expand-range)#@940 A list of lists of feature symbols. Use `treesit-font-lock-recompute-features' and `treesit-font-lock-level' to configure enabled features. Each sublist represents a decoration level. `treesit-font-lock-level' controls which levels are activated. Inside each sublist are feature symbols, which correspond to the :feature value of a query defined in `treesit-font-lock-rules'. Removing a feature symbol from this list disables the corresponding query during font-lock. Common feature names (for general programming languages) include definition, type, assignment, builtin, constant, keyword, string-interpolation, comment, doc, string, operator, property, preprocessor, escape-sequence, key (in key-value pairs). Major modes are free to subdivide or extend on these common features. See the manual for more explanations on some of the features. For changes to this variable to take effect, run `treesit-font-lock-recompute-features'. (defvar treesit-font-lock-feature-list nil (#$ . 19211)) (make-variable-buffer-local 'treesit-font-lock-feature-list)#@2174 Return a value suitable for `treesit-font-lock-settings'. QUERY-SPECS is a series of QUERY-SPECs. Each QUERY-SPEC is a QUERY preceded by multiple pairs of :KEYWORD and VALUE: :KEYWORD VALUE... QUERY QUERY is a tree-sitter query in either the string, s-expression or compiled form. For each query, captured nodes are highlighted with the capture name as its face. :KEYWORD and VALUE pairs preceding a QUERY add meta information to QUERY. For example, (treesit-font-lock-rules :language \='javascript :override t :feature\='constant \='((true) @font-lock-constant-face (false) @font-lock-constant-face) :language \='html :feature \='script "(script_element) @font-lock-builtin-face") For each QUERY, a :language keyword and a :feature keyword are required. Each query's :feature is a symbol summarizing what the query fontifies. It is used to allow users to enable/disable certain features. See `treesit-font-lock-feature-list' for more. Other keywords include: KEYWORD VALUE DESCRIPTION :override nil If the region already has a face, discard the new face. t Always apply the new face. `append' Append the new face to existing ones. `prepend' Prepend the new face to existing ones. `keep' Fill-in regions without an existing face. Capture names in QUERY should be face names like `font-lock-keyword-face'. The captured node will be fontified with that face. Capture names can also be function names, in which case the function will be called with the following argument list: (NODE OVERRIDE START END &rest _) where NODE is the tree-sitter node object, OVERRIDE is the override option of that rule, and START and END specify the region to be fontified. This function should accept more arguments as optional arguments for future extensibility, and it shouldn't fontify text outside the region given by START and END. If a capture name is both a face and a function, the face takes priority. If a capture name is not a face name nor a function name, it is ignored. (fn &rest QUERY-SPECS) (defalias 'treesit-font-lock-rules #[128 "\300 \205\310\301\211\211\211\203\304\211A\262\242\211\302\267\202s\211A\262\242\2119\203(\211\204/\303\304\305D\"\210\262\210\202 \211A\262\242\211\306>\204O\303\304\307D\"\210\303\310\311D\"\210\262\210\202 \211A\262\242\2119\203f\211\312>\203m\303\304\313D\"\210\262\210\202 \314!\203\271\204\204\303\304\315D\"\210\204\217\303\304\316D\"\210\317!\203\237\320BB\262\202\254\321\"\322FB\262\301\262\301\262\301\262\210\202 \303\304\323D\"\266\202 \211\237\266\204\207" [treesit-available-p nil #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:language 25 :override 53 :feature 85)) signal treesit-font-lock-error "Value of :language should be a symbol" (t nil append prepend keep) "Value of :override should be one of t, nil, append, prepend, keep" wrong-type-argument (or t nil append prepend keep) (t nil) "Value of :feature should be a symbol" treesit-query-p "Language unspecified, use :language keyword to specify a language for this query" "Feature unspecified, use :feature keyword to specify the feature name for this query" treesit-compiled-query-p (token) treesit-query-compile t "Unexpected value"] 11 (#$ . 20275)])#@51 If non-nil, print debug messages when fontifying. (defvar treesit--font-lock-verbose nil (#$ . 23718))#@659 Enable/disable font-lock features. Enable each feature in ADD-LIST, disable each feature in REMOVE-LIST. If both ADD-LIST and REMOVE-LIST are omitted, recompute each feature according to `treesit-font-lock-feature-list' and `treesit-font-lock-level'. If the value of `treesit-font-lock-level', is N, then the features in the first N sublists of `treesit-font-lock-feature-list' are enabled, and the rest of the features are disabled. ADD-LIST and REMOVE-LIST are lists of feature symbols. The same feature symbol cannot appear in both lists; the function signals the `treesit-font-lock-error' error if that happens. (fn &optional ADD-LIST REMOVE-LIST) (defalias 'treesit-font-lock-recompute-features #[512 "\303\"\211\203\304\305\306D\"\210\210\307 \307\211\310\211\203\311\202 T\262:\203I@\262\310=\2048TY\203?\312!\244\262A\262\307\262\202\237\266\205\313\314\"\"\206Z\307\n\307\211\211\310\211\203h\311\202jT\262:\203\266@\262\3158\262A@\262\n8A\211\204\222\n>??\202\251>\203\235\310\202\251 >\203\250\307\202\251\240\266A\262\307\262\202`\266\307\207" [treesit-font-lock-level treesit-font-lock-feature-list treesit-font-lock-settings cl-intersection signal treesit-font-lock-error "ADD-LIST and REMOVE-LIST contain the same feature" nil t 0 reverse cl-set-difference cl-union 2] 16 (#$ . 23827)])#@301 Apply FACE to the region between START and END. OVERRIDE can be nil, t, `append', `prepend', or `keep'. See `treesit-font-lock-rules' for their semantic. If BOUND-START and BOUND-END are non-nil, only fontify the region in between them. (fn START END FACE OVERRIDE &optional BOUND-START BOUND-END) (defalias 'treesit-fontify-with-override #[1540 "\203\211\203\205z\211\205zX\205z\211Y\205z\2030\211\2030]\262\211^\262\300\267\202t\301\302\303$?\205z\304\302$\207\304\302$\207\305\302$\207\306\302$\207\307\302$\207\310\311\312D\"\207" [#s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 54 t 76 append 86 prepend 96 keep 106)) text-property-not-all face nil put-text-property font-lock-append-text-property font-lock-prepend-text-property font-lock-fillin-text-property signal treesit-font-lock-error "Unrecognized value of :override option"] 11 (#$ . 25212)])#@228 Set `rear-nonsticky' property between START and END. Set the property to a list containing SYM. If there is already a list, add SYM to that list. If REMOVE is non-nil, remove SYM instead. (fn START END SYM &optional REMOVE) (defalias 'treesit--set-nonsticky #[1027 "\300\301\"\211<\203\203\302\"\202!B\202!?\205!C\211\204-\303\304#\207\305\301$\207" [get-text-property rear-nonsticky remove remove-text-properties (rear-nonsticky nil) put-text-property] 11 (#$ . 26181)])#@110 Return a list of children of NODE covering a range. The range is between START and END. (fn NODE START END) (defalias 'treesit--children-covering-range #[771 "\300\"\211\205\n\211C\211\203.\203+\301!W\203+\302!\211\262\203+B\262\202\211\237\207C\207" [treesit-node-first-child-for-pos treesit-node-end treesit-node-next-sibling] 7 (#$ . 26687)])#@314 Return a list of children of NODE covering a range. Recursively go down the parse tree and collect children, until all nodes in the returned list are smaller than THRESHOLD. The range is between START and END. LIMIT is the recursion limit, which defaults to 100. (fn NODE START END THRESHOLD &optional LIMIT) (defalias 'treesit--children-covering-range-recurse #[1284 "\300\"\206 \301\302\303V\203X\203X\304!X\203X\305!\304!ZV\203K\306S%\211\203G\211@\211B\262A\266\202\2025\210\202PB\262\307!\262\202\n\211\206e\303V\205eC\207" [treesit-node-first-child-for-pos 100 nil 0 treesit-node-start treesit-node-end treesit--children-covering-range-recurse treesit-node-next-sibling] 14 (#$ . 27058)])#@51 Return the length of the text of NODE. (fn NODE) (defalias 'treesit--node-length #[257 "\300!\301!Z\207" [treesit-node-end treesit-node-start] 4 (#$ . 27804)]) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put treesit--node-length speed -1 put byte-optimizer byte-compile-inline-expand] 5)#@196 If this variable is t, change the way we query so it's faster. This is not a general optimization and should be RARELY needed! See comments in `treesit-font-lock-fontify-region' for more detail. (defvar treesit--font-lock-fast-mode 'unspecified (#$ . 28119)) (make-variable-buffer-local 'treesit--font-lock-fast-mode)#@134 Fontify the region between START and END. If LOUDLY is non-nil, display some debugging information. (fn START END &optional LOUDLY) (defalias 'treesit-font-lock-fontify-region #[770 "\211\204\203\306\307#\210\310\"\210\311\"\210 \211\203A\211@\211@A@\3128\313!\n\314=\203T\315\316!!\211\242\243\211\242\243\317V\204I\320V\203P\321\266\202T\322\266\316!\211\205r\n\321=\203n\323  \324 _$\202r\316!C\211\205y\321=\211\2038\211\2037\211@\f@\fA\325\fZe]\\d^$\326 \321\211\"\321#\327\330\"\216\211\203-\211@\211@A\331!\332!\333!\203\341Y\204\315Y\203\341\204\326\203$\306\334$\266\202&\333!\203\371\335]^$\210\202 \336!\203 $\210\204\203$\306\337]^\340!%\210\266A\266\202\202\251,\266A\266\202\202~\210\266A\266\202\202\210\341BB\207" [treesit--font-lock-verbose treesit-font-lock-settings treesit--font-lock-fast-mode jit-lock-chunk-size treesit--font-lock-query-expand-range buffer-undo-list message "Fontifying region: %s-%s" treesit-update-ranges font-lock-unfontify-region 3 treesit-query-language unspecified treesit-subtree-stat treesit-buffer-root-node 100 4000 t nil treesit--children-covering-range-recurse 4 treesit-query-capture buffer-modified-p make-closure #[0 "\300\203\n\300\301=\205 \302\300!\207" [V0 autosaved restore-buffer-modified-p] 2] treesit-node-start treesit-node-end facep "Captured node %s(%s-%s) but it is outside of fontifing region" treesit-fontify-with-override functionp "Fontifying text from %d to %d, Face: %s, Node: %s" treesit-node-type jit-lock-bounds inhibit-read-only inhibit-modification-hooks] 32 (#$ . 28443)])#@176 Ensures updated parts of the parse-tree are refontified. RANGES is a list of (BEG . END) ranges, PARSER is the tree-sitter parser notifying of the change. (fn RANGES PARSER) (defalias 'treesit--font-lock-notifier #[514 "r\304!q\210\211\2058\211@\203\305\306@A#\210\307 \310\211\310\311\312\"\216\313@A\314\315$,\266A\266\202\202)\207" [treesit--font-lock-verbose buffer-undo-list inhibit-read-only inhibit-modification-hooks treesit-parser-buffer message "Notifier received range: %s-%s" buffer-modified-p t make-closure #[0 "\300\203\n\300\301=\205 \302\300!\207" [V0 autosaved restore-buffer-modified-p] 2] put-text-property fontified nil] 11 (#$ . 30132)])#@251 If non-nil, next `syntax-propertize' should start at this position. When tree-sitter parser reparses, it calls `treesit--syntax-propertize-notifier' with the affected region, and that function sets this variable to the start of the affected region. (defvar treesit--syntax-propertize-start nil (#$ . 30819)) (make-variable-buffer-local 'treesit--syntax-propertize-start)#@169 Sets `treesit--syntax-propertize-start' to the smallest start. Specifically, the smallest start position among all the ranges in RANGES for PARSER. (fn RANGES PARSER) (defalias 'treesit--syntax-propertize-notifier #[514 "r\301!q\210\302\303\"\211\205\304\305A@#\211\205*\204%\211\211\266\202\202,^\211\266\202)\207" [treesit--syntax-propertize-start treesit-parser-buffer mapcar car seq-reduce min] 7 (#$ . 31197)])#@224 The last `buffer-chars-modified-tick' that we've processed. Because `pre-redisplay-functions' could be called multiple times during a single command loop, we use this variable to debounce calls to `treesit--pre-redisplay'. (defvar treesit--pre-redisplay-tick nil (#$ . 31634)) (make-variable-buffer-local 'treesit--pre-redisplay-tick)#@430 Force reparse and consequently run all notifiers. One of the notifiers is `treesit--font-lock-notifier', which will mark the region whose syntax has changed to "need to refontify". For example, when the user types the final slash of a C block comment /* xxx */, not only do we need to fontify the slash, but also the whole block comment, which previously wasn't fontified as comment due to incomplete parse tree. (fn &rest _) (defalias 'treesit--pre-redisplay #[128 "\301 =?\205#\302 \210\303 \211\203\211@\304!\210A\266\202\202 \210\301 \211\207" [treesit--pre-redisplay-tick buffer-chars-modified-tick treesit-update-ranges treesit-parser-list treesit-parser-root-node] 5 (#$ . 31975)])#@353 Force reparse and consequently run all notifiers. Similar to font-lock, we want to update the `syntax' text property before `syntax-ppss' starts working on the text. We also want to extend the to-be-propertized region to include the whole region affected by the last reparse. START and END mark the current to-be-propertized region. (fn START END) (defalias 'treesit--pre-syntax-ppss #[514 "\301 \210\211\205\211W\205\302\211e]B\207" [treesit--syntax-propertize-start treesit--pre-redisplay nil] 5 (#$ . 32681)]) (define-error 'treesit-indent-error "Generic tree-sitter indentation error" 'treesit-error)#@42 If non-nil, log progress when indenting. (defvar treesit--indent-verbose nil (#$ . 33303))#@1061 A list of indent rule settings. Each indent rule setting should be (LANGUAGE . RULES), where LANGUAGE is a language symbol, and RULES is a list of (MATCHER ANCHOR OFFSET). MATCHER determines whether this rule applies, ANCHOR and OFFSET together determines which column to indent to. A MATCHER is a function that takes three arguments (NODE PARENT BOL). BOL is the point where we are indenting: the beginning of line content, the position of the first non-whitespace character. NODE is the largest (highest-in-tree) node starting at that point. PARENT is the parent of NODE. If MATCHER returns non-nil, meaning the rule matches, Emacs then uses ANCHOR to find an anchor, it should be a function that takes the same argument (NODE PARENT BOL) and returns a point. Finally Emacs computes the column of that point returned by ANCHOR and adds OFFSET to it, and indents to that column. OFFSET can be an integer or a variable whose value is an integer. For MATCHER and ANCHOR, Emacs provides some convenient presets. See `treesit-simple-indent-presets'. (defvar treesit-simple-indent-rules nil (#$ . 33401)) (make-variable-buffer-local 'treesit-simple-indent-rules)#@2970 A list of indent rule presets. These presets can be used as MATCHER and ANCHOR values in `treesit-simple-indent-rules'. MATCHERs and ANCHORs are functions that take 3 arguments: NODE, PARENT, and BOL. MATCHER: (match NODE-TYPE PARENT-TYPE NODE-FIELD NODE-INDEX-MIN NODE-INDEX-MAX) NODE-TYPE checks for NODE's type, PARENT-TYPE checks for PARENT's type, NODE-FIELD checks for the field name of NODE in PARENT, NODE-INDEX-MIN and NODE-INDEX-MAX check for NODE's index in PARENT. Therefore, to match the first child where PARENT is "argument_list", use (match nil "argument_list" nil 0 0). NODE-TYPE, PARENT-TYPE, and NODE-FIELD are regexps. NODE-TYPE can also be `null', which matches when NODE is nil. no-node Matches the case where NODE is nil, i.e., there is no node that starts at point. This is the case when indenting an empty line. (parent-is TYPE) Check that PARENT's type matches regexp TYPE. (node-is TYPE) Checks that NODE's type matches regexp TYPE. (field-is NAME) Checks that NODE's field name in PARENT matches regexp NAME. (n-p-gp NODE-TYPE PARENT-TYPE GRANDPARENT-TYPE) Checks for NODE's, its parent's, and its grandparent's type. (query QUERY) Queries PARENT with QUERY, and checks if NODE is captured (by any capture name). comment-end Matches if text after point matches `comment-end-skip'. catch-all Always matches. ANCHOR: first-sibling Returns the start of the first child of PARENT. (nth-sibling N &optional NAMED) Returns the start of the Nth child of PARENT. NAMED non-nil means count only named nodes. parent Returns the start of PARENT. grand-parent Returns the start of PARENT's parent. great-grand-parent Returns the start of PARENT's parent's parent. parent-bol Returns the beginning of non-space characters on the line where PARENT is on. standalone-parent Finds the first ancestor node (parent, grandparent, etc.) that starts on its own line, and returns the start of that node. prev-sibling Returns the start of NODE's previous sibling. no-indent Returns the start of NODE. prev-line Returns the first non-whitespace character on the previous line. column-0 Returns the beginning of the current line, which is at column 0. comment-start Goes to the position that `comment-start-skip' would return, skips whitespace backwards, and returns the resulting position. Assumes PARENT is a comment node. prev-adaptive-prefix Goes to the beginning of previous non-empty line, and tries to match `adaptive-fill-regexp'. If it matches, return the end of the match, otherwise return nil. However, if the current line begins with a prefix, return the beginning of the prefix of the previous line instead, so that the two prefixes aligns. This is useful for an `indent-relative'-like indent behavior for block comments. (defvar treesit-simple-indent-presets (byte-code "\300\301B\302\303B\304\305B\306\307B\310\311B\312\313B\314\315B\316\317B\320\321B\322\323B\324\325B\326\327B\330\331B\332\333B\334\335B\336\337B\340\341B\342\343B\344\345B\346\347B\350\351B\352\353B\354\355B\356\357B\360\361B\362\363B\257\207" [match #[1280 "\300\301\n&\207" [make-closure #[642 "\304\203#\304\305=\203?\202 \304\306!\206\307\310\311\312$\266\203\205e\303\2037\303\306!\310\311\312$\266\203\205e\302\203O\302\313!\206C\307\310\311\312$\266\203\205e\301\203[\314!\301Y\205e\300?\206e\314!\300X\207" [V0 V1 V2 V3 V4 null treesit-node-type #1="" nil string-match t treesit-node-field-name treesit-node-index] 11 "\n\n(fn NODE PARENT &rest _)"]] 12 "\n\n(fn &optional NODE-TYPE PARENT-TYPE NODE-FIELD NODE-INDEX-MIN NODE-INDEX-MAX)"] n-p-gp #[771 "\300\301$\207" [make-closure #[642 "\302\203\302\303!\206\f\304\305\306\307$\266\203\205F\301\203,\301\303!\305\306\307$\266\203\205F\300?\206F\310!\205F\300\303\310!!\305\306\307$\266\203\207" [V0 V1 V2 treesit-node-type #1# nil string-match t treesit-node-parent] 11 "\n\n(fn NODE PARENT &rest _)"]] 8 "\n\n(fn NODE-T PARENT-T GRAND-PARENT-T)"] no-node #[385 "?\207" #2=[] 3 "\n\n(fn NODE &rest _)"] parent-is #[257 "\300\301\"\207" [make-closure #[642 "\300\301!\302\303\304$\207" [V0 treesit-node-type nil string-match t] 11 "\n\n(fn N PARENT &rest _)"]] 4 "\n\n(fn TYPE)"] node-is #[257 "\300\301\"\207" [make-closure #[385 "\300\301!\206\302\303\304\305$\207" [V0 treesit-node-type #1# nil string-match t] 10 "\n\n(fn NODE &rest _)"]] 4 "\n\n(fn TYPE)"] field-is #[257 "\300\301\"\207" [make-closure #[385 "\300\301!\206\302\303\304\305$\207" [V0 treesit-node-field-name #1# nil string-match t] 10 "\n\n(fn NODE &rest _)"]] 4 "\n\n(fn NAME)"] comment-end #[899 "\212b\210\301\302\")\207" [comment-end-skip looking-at t] 8 "\n\n(fn NODE PARENT BOL &rest _)"] catch-all #[128 "\300\207" [t] 2 "\n\n(fn &rest _)"] query #[257 "\300\301\"\207" [make-closure #[642 "\301\300\"\302\303\302:\203.@\262\304A\"\203#\303\262\302\211\262\202$\303\203.A\262\202?\2054\211\207" [V0 treesit-query-capture nil t treesit-node-eq] 10 "\n\n(fn NODE PARENT &rest _)"]] 4 "\n\n(fn PATTERN)"] first-sibling #[642 "\300\301\302\"!\207" [treesit-node-start treesit-node-child 0] 7 "\n\n(fn N PARENT &rest _)"] nth-sibling #[513 "\300\301#\207" [make-closure #[642 "\302\303\301\300#!\207" [V0 V1 treesit-node-start treesit-node-child] 8 "\n\n(fn N PARENT &rest _)"]] 6 "\n\n(fn N &optional NAMED)"] parent #[642 "\300!\207" [treesit-node-start] 5 "\n\n(fn N PARENT &rest _)"] comment-start #[642 "\212\301!b\210\302!\210\303\304!\210`)\207" [comment-start-skip treesit-node-start re-search-forward skip-syntax-backward "-"] 5 "\n\n(fn N PARENT &rest _)"] prev-adaptive-prefix #[899 "\301\211\212\302!b\210\303 \262b\210\304\305\"\262\205'\306\307\310!\301\311\305$\266\203?\262\312y\210`Y\205R\205R\304!\205R\313\304\305\"\262?\205R\211\203P\314\224\206R\310\225)\207" [adaptive-fill-regexp nil treesit-node-start line-beginning-position looking-at t "\\`[[:space:]]*\\'" match-string 0 string-match -1 "[[:space:]]*$" 1] 14 "\n\n(fn N PARENT BOL &rest _)"] grand-parent #[642 "\300\301!!\207" [treesit-node-start treesit-node-parent] 6 "\n\n(fn N PARENT &rest _)"] great-grand-parent #[642 "\300\301\211!!!\207" [treesit-node-start treesit-node-parent] 7 "\n\n(fn N PARENT &rest _)"] parent-bol #[642 "\212\300!b\210\301 \210`)\207" [treesit-node-start back-to-indentation] 5 "\n\n(fn N PARENT &rest _)"] standalone-parent #[642 "\212\3002$\205#\301!b\210\302\303\304 \"\203\305\300`\"\210\306!\262\2020)\207" [term treesit-node-start looking-back "^[[:space:]]*" line-beginning-position throw treesit-node-parent] 6 "\n\n(fn N PARENT &rest _)"] prev-sibling #[899 "\300\301\302\"\206\301\303\"\302\"\206\304\305\302#!\207" [treesit-node-start treesit-node-prev-sibling t treesit-node-first-child-for-pos treesit-node-child -1] 9 "\n\n(fn NODE PARENT BOL &rest _)"] no-indent #[899 "\207" #2# 5 "\n\n(fn N P BOL &rest _)"] prev-line #[899 "\212b\210\300y\210\301\302w\210`)\207" [-1 " " nil] 6 "\n\n(fn N P BOL &rest _)"] column-0 #[899 "\212b\210\300 )\207" [line-beginning-position] 5 "\n\n(fn N P BOL &rest _)"] and #[128 "\300\301\"\207" [make-closure #[899 "\301\3022)\300\211\205&\211@\211#\262\204\303\302\304\"\210A\266\202\202\2620\210\207" [V0 nil break throw t] 11 "\n\n(fn NODE PARENT BOL &rest _)"]] 4 "\n\n(fn &rest FNS)"] or #[128 "\300\301\"\207" [make-closure #[899 "\301\3022)\300\211\205&\211@\211#\262\203\303\302\304\"\210A\266\202\202\2620\210\207" [V0 nil break throw t] 11 "\n\n(fn NODE PARENT BOL &rest _)"]] 4 "\n\n(fn &rest FNS)"] not #[257 "\300\301\"\207" [make-closure #[899 "\300#?\207" [V0] 8 "\n\n(fn NODE PARENT BOL &rest _)"]] 4 "\n\n(fn FN)"] list #[128 "\300\301\"\207" [make-closure #[899 "\301\302\303$\300\"\207" [V0 mapcar make-closure #[257 "\211\302\301\300#\207" [V0 V1 V2] 5 "\n\n(fn FN)"]] 10 "\n\n(fn NODE PARENT BOL &rest _)"]] 4 "\n\n(fn &rest FNS)"]] 27) (#$ . 34580))#@158 Evaluate EXP. If EXP is an application and the function is a key in `treesit-simple-indent-presets', use the corresponding value as the function. (fn EXP) (defalias 'treesit--simple-indent-eval #[257 "\211:\203\301!\204\302\303@!\304\303A\"\"\207\305\"\2067\301!\203%\207\2119\2036\211\204/\207\306\307\310D\"\207\211\207" [treesit-simple-indent-presets functionp apply treesit--simple-indent-eval mapcar alist-get signal treesit-indent-error "Couldn't find the preset corresponding to expression"] 6 (#$ . 42774)])#@459 Function used by `treesit-indent' to do some of the work. This function is called with (NODE PARENT BOL &rest _) and returns (ANCHOR . OFFSET). BOL is the position of the beginning of the line; NODE is the "largest" node that starts at BOL (and isn't a root node); PARENT is its parent; ANCHOR is a point (not a node), and OFFSET is a number. Emacs finds the column of ANCHOR and adds OFFSET to it as the final indentation of the current line. (defvar treesit-indent-function 'treesit-simple-indent (#$ . 43313))#@124 Indent the current line. Return (ANCHOR . OFFSET). This function is used by `treesit-indent' and `treesit-indent-region'. (defalias 'treesit--indent-1 #[0 "\212\301y\210\302\303w\210`)\304 \204\303\2023\304 G\305=\203!\306!\2023\307!\2030\306\307!\"\2023\306!\310\311!!\312\313\314#\"\205H\311!\203V\211\203V\315!\202Z\316\211\"#\207" [treesit-indent-function 0 " " nil treesit-parser-list 1 treesit-node-at treesit-language-at treesit-parser-root-node treesit-node-parser treesit-parent-while make-closure #[257 "\301\302!=\205 \303\300\"?\207" [V0 V1 treesit-node-start treesit-node-eq] 4 "\n\n(fn NODE)"] treesit-node-parent treesit-node-on] 10 (#$ . 43846)])#@62 Indent according to the result of `treesit-indent-function'. (defalias 'treesit-indent #[0 "\300\301 \302 \"\210\303 \211\242\243\2052\211\2052\212b\210i)\\d`Z\304!\210dZ`V\2050dZb\266\202\207" [treesit-update-ranges line-beginning-position line-end-position treesit--indent-1 indent-line-to] 7 (#$ . 44550)])#@285 How many lines of indent value do we precompute. In `treesit-indent-region' we indent in batches: precompute indent for each line, apply them in one go, let parser reparse, and do it again. This way the parser doesn't need to unnecessarily reparse after indenting every single line. (defvar treesit--indent-region-batch-size 400 (#$ . 44876))#@112 Indent the region between BEG and END. Similar to `treesit-indent', but indent a region instead. (fn BEG END) (defalias 'treesit-indent-region #[514 "\301\"\210\302_\303\304\"\304\305\306\"\304\211Z\307V\212b\210\304=\203%`W\203%\304\262`\262\304=\203\325W\203\325`W\203\325\310\311\306\"\203a\302_\312I\266\302_T\312I\266\202\312\313 \211\242\243\302_H\203v\204\241\314!\203\223\315 \210\211`\312\223\210\302_T\n\304I\266\202\312\302_\n\312I\266\202\312\314!\203\257\211\312\223\210\202\276\302_\n\305\306\"I\266\302_T\nI\266T\262\316y\262\2020b\210\304\211W\203 \302_H\302_TH\203\211\203\212b\210\211i\\)\317!\266\266\316y\210\211T\262\202\331\210\211\203\320\321` Z\322_\fZ\245\"\210\202\304\211W\203F\302_H\314!\203>\211\312\211\223\210\210\211T\262\202'\266\312\211\223)\207" [treesit--indent-region-batch-size treesit-update-ranges 2 make-vector 0 copy-marker t 80000 looking-at "[[:space:]]*$" nil treesit--indent-1 markerp back-to-indentation 1 indent-line-to message "Indenting region...%s%%" 100] 19 (#$ . 45226)])#@376 Calculate indentation according to `treesit-simple-indent-rules'. BOL is the position of the first non-whitespace character on the current line. NODE is the largest node that starts at BOL, PARENT is NODE's parent. Return (ANCHOR . OFFSET) where ANCHOR is a node, OFFSET is the indentation offset, meaning indent to align with ANCHOR and add OFFSET. (fn NODE PARENT BOL) (defalias 'treesit-simple-indent #[771 "\204\203\f\302\303!\210\304C\207\305!\306 \"\211\304\211\211\211\307\304\211:\203\234@\262@\262A@\262\3108\262\311F!\203\215\203R\302\312\"\210\311F!\247\203e\2029\203u\313!\203uJ\202\311F!B\266\202\262\304\211\262\202\216\307\203\234A\262\304\262\202\203\253\203\250\302\314!\210\304C\207\207" [treesit--indent-verbose treesit-simple-indent-rules message "PARENT is nil, not indenting" nil treesit-node-language alist-get t 2 treesit--simple-indent-eval "Matched rule: %S" boundp "No matched rule"] 19 (#$ . 46377)])#@194 Check current buffer's indentation against a major mode MODE. Pop up a diff buffer showing the difference. Correct indentation (target) is in green, current indentation is in red. (fn MODE) (defalias 'treesit-check-indent #[257 "p\300\301\302\"r\211q\210\303\304\"\216\305!\210 \210\306ed\"\210\307p\"*\207" [generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205 \302\300!\207" [V0 buffer-name kill-buffer] 2] insert-buffer-substring indent-region diff-buffers] 6 (#$ . 47393) "CTarget major mode: "])#@151 Optimize simple indent RULES. RULES should be a value suitable for `treesit-simple-indent-rules'. Return the optimized version of RULES. (fn RULES) (defalias 'treesit--indent-rules-optimize #[257 "\211\300\211C\300\211\211:\203C@\262@\240\210A\262\300C\300\301\302 #\240\210\301\303\"\262\242\304\"B\266\202B\262A\262\300\262\202\237\207" [nil make-closure #[257 "\211:\203>\211\242\211\302\267\202<\243\211:\203&\211\242\243\211\204$\303\304\301\242\"D\207\207\207\243\305\306\300\242\"B\207\243\307\306\300\242\"B\207\207\207" [V0 V1 #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (query 13 and 40 or 50)) query treesit-query-compile and mapcar or] 9 "\n\n(fn FUNC)"] #[257 "\211@A@\3018\300\242!\300\242!E\207" [V0 2] 7 "\n\n(fn RULE)"] mapcar] 14 (#$ . 47919)])#@750 Search forward for a node and move to its end position. Stop at the first node after NODE that matches PREDICATE. PREDICATE can be either a regexp that matches against each node's type case-insensitively, or a function that takes a node and returns nil/non-nil for match/no match. If a node matches, move to that node and return the node, otherwise return nil. If START is non-nil, stop at the beginning rather than the end of a node. This function guarantees that the matched node it returns makes progress in terms of buffer position: the start/end position of the returned node is always STRICTLY greater/less than that of NODE. BACKWARD and ALL are the same as in `treesit-search-forward'. (fn NODE PREDICATE &optional START BACKWARD ALL) (defalias 'treesit-search-forward-goto #[1282 "\203\n\300!\202 \301!\211\205\211\211\205e\203K\203%\211Y\202(\211X\203K\302$\262\203B\300!\202F\301!\262\202\203c\203Z\211`W\202]\211`V\203c\211b\210\207" [treesit-node-start treesit-node-end treesit-search-forward] 12 (#$ . 48775)])#@416 A regexp that matches the node type of defun nodes. For example, "(function|class)_definition". Sometimes not all nodes matched by the regexp are valid defuns. In that case, set this variable to a cons cell of the form (REGEXP . PRED), where PRED is a function that takes a node (the matched node) and returns t if node is valid, or nil for invalid node. This is used by `treesit-beginning-of-defun' and friends. (defvar treesit-defun-type-regexp nil (#$ . 49857)) (make-variable-buffer-local 'treesit-defun-type-regexp)#@51 Like `treesit-defun-type-regexp', but for blocks. (defvar treesit-block-type-regexp nil (#$ . 50385)) (make-variable-buffer-local 'treesit-block-type-regexp)#@177 Determines how does Emacs treat nested defuns. If the value is `top-level', Emacs only moves across top-level defuns, if the value is `nested', Emacs recognizes nested defuns. (defvar treesit-defun-tactic 'nested (#$ . 50549)) (make-variable-buffer-local 'treesit-defun-tactic)#@294 A function called after tree-sitter navigation moved a step. It is called with no arguments. By default, this function tries to move to the beginning of a line, either by moving to the empty newline after a defun, or the beginning of a defun. If the value is nil, no skipping is performed. (defvar treesit-defun-skipper 'treesit-default-defun-skipper (#$ . 50833)) (make-variable-buffer-local 'treesit-defun-skipper)#@270 A function that is called with a node and returns its defun name or nil. If the node is a defun node, return the defun name, e.g., the function name of a function. If the node is not a defun node, or the defun node doesn't have a name, or the node is nil, return nil. (defvar treesit-defun-name-function nil (#$ . 51259)) (make-variable-buffer-local 'treesit-defun-name-function)#@101 The delimiter used to connect several defun names. This is used in `treesit-add-log-current-defun'. (defvar treesit-add-log-defun-delimiter "." (#$ . 51646)) (make-variable-buffer-local 'treesit-add-log-defun-delimiter)#@172 Unpack PATTERN in the shape of `treesit-defun-type-regexp'. Basically, (unpack REGEXP) = (REGEXP . nil) (unpack (REGEXP . PRED)) = (REGEXP . PRED) (fn PATTERN) (defalias 'treesit--thing-unpack-pattern #[257 "\211:\203\207\211C\207" [] 2 (#$ . 51872)]) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put treesit--thing-unpack-pattern speed -1 put byte-optimizer byte-compile-inline-expand] 5)#@229 Like `beginning-of-defun', but generalized into things. PATTERN is like `treesit-defun-type-regexp', ARG is the same as in `beginning-of-defun'. Return non-nil if successfully moved, nil otherwise. (fn PATTERN &optional ARG) (defalias 'treesit-beginning-of-thing #[513 "\211\206\300\211:\204\211C\262\211\242\243\301`[\302%\211\205!\211b\207" [1 treesit--navigate-thing beg] 12 (#$ . 52298)])#@217 Like `end-of-defun', but generalized into things. PATTERN is like `treesit-defun-type-regexp', ARG is the same as in `end-of-defun'. Return non-nil if successfully moved, nil otherwise. (fn PATTERN &optional ARG) (defalias 'treesit-end-of-thing #[513 "\211\206\300\211:\204\211C\262\211\242\243\301`\302%\211\205 \211b\207" [1 treesit--navigate-thing end] 12 (#$ . 52711)])#@394 Move backward to the beginning of a defun. With argument ARG, do it that many times. Negative ARG means move forward to the ARGth following beginning of defun. If search is successful, return t, otherwise return nil. This is a tree-sitter equivalent of `beginning-of-defun'. Behavior of this function depends on `treesit-defun-type-regexp' and `treesit-defun-skipper'. (fn &optional ARG) (defalias 'treesit-beginning-of-defun #[256 "\306=\203 \306=\204\n\203 \204\307 \210`\310\3112f\312\211\313W\205c\310\314\f\"\2037 \2037 \210\315\262\312=\204C`=\204L\316\311\"\266\202\\\312V\203WT\202YS\262\210\211T\262\202\2620\207" [this-command last-command transient-mark-mode mark-active treesit-defun-type-regexp treesit-defun-skipper treesit-beginning-of-defun push-mark nil done 0 2 treesit-beginning-of-thing t throw] 8 (#$ . 53105) "^p"])#@317 Move forward to next end of defun. With argument ARG, do it that many times. Negative argument -N means move back to Nth preceding end of defun. This is a tree-sitter equivalent of `end-of-defun'. Behavior of this function depends on `treesit-defun-type-regexp' and `treesit-defun-skipper'. (fn &optional ARG _) (defalias 'treesit-end-of-defun #[512 "`\203 \306U\203\307\262\310=\203% \310=\204%\n\203\" \204%\311 \210\3122o\306\211\313W\205l\314\315\f\"\203@ \203@ \210\306=\204L`=\204U\316\312\314\"\266\202e\306V\203`T\202bS\262\210\211T\262\202*\2620\207" [this-command last-command transient-mark-mode mark-active treesit-defun-type-regexp treesit-defun-skipper 0 1 treesit-end-of-defun push-mark done 2 nil treesit-end-of-thing throw] 8 (#$ . 53988) "^p\nd"])#@232 Skips spaces after navigating a defun. This function tries to move to the beginning of a line, either by moving to the empty newline after a defun, or to the beginning of the current line if the beginning of the defun is indented. (defalias 'treesit-default-defun-skipper #[0 "\300\301!\203 n\204 \302y\207\303\304\305 \"\205\306 \207" [looking-at "[ ]*\n" 1 looking-back "^[ ]+" line-beginning-position beginning-of-line] 3 (#$ . 54797)])#@360 Return the previous, next, and parent thing around POS. Return a list of (PREV NEXT PARENT), where PREV and NEXT are previous and next sibling things around POS, and PARENT is the parent thing surrounding POS. All of three could be nil if no sound things exists. REGEXP and PRED are the same as in `treesit-thing-at-point'. (fn POS REGEXP &optional PRED) (defalias 'treesit--things-around #[770 "\300!\301\211\211E\302\303\301\304\305 \"\304\306\n\"D\301C\307X\203\230:\203\230@\262:\203\230\211@\240\210\203\211\304\310  $\212\203X\242!\204X\311\312\211\313%\262\202@)\203\207\242!\203\2078\204\207\233\211\314\313#\240\266\315\f\211$\262\202Y\266T\262A\262A\262\202\266\211@\206\246\211A@\206\246\304\316\n%AA\211\317\"\240\266\207" [treesit-node-at nil 0 (t nil) make-closure #[257 "\301!\300X\207" [V0 treesit-node-end] 3 "\n\n(fn N)"] #[257 "\301!\300Y\207" [V0 treesit-node-start] 3 "\n\n(fn N)"] 1 #[257 "\302\303!\304\305\306$\266\203\205\301\203\301!\205\300\242!\207" [V0 V1 V2 treesit-node-type nil string-match t] 9 "\n\n(fn NODE)"] treesit-search-forward-goto "" t treesit-node-top-level treesit-search-forward #[257 "\302\304!\305\306\307$\266\203\2056\301\203\301!\2056\310\300@\"?\2056\310\300A@\"?\2056\311\312!\303\313!#\207" [V0 V1 V2 V3 treesit-node-type nil string-match t treesit-node-eq < treesit-node-start treesit-node-end] 9 "\n\n(fn NODE)"] treesit-parent-until] 18 (#$ . 55249)])#@138 Return the top-level parent thing of NODE. REGEXP and PRED are the same as in `treesit-thing-at-point'. (fn NODE REGEXP &optional PRED) (defalias 'treesit--top-level-thing #[770 "\300\301\302#\303#\207" [treesit-node-top-level make-closure #[257 "\301\302!\303\304\305$\266\203\205\300?\206\300!\207" [V0 V1 treesit-node-type nil string-match t] 9 "\n\n(fn NODE)"] t] 9 (#$ . 56772)])#@561 Navigate thing ARG steps from POS. If ARG is positive, move forward that many steps, if negative, move backward. If SIDE is `beg', stop at the beginning of a thing, if SIDE is `end', stop at the end. This function doesn't actually move point, it just returns the position it would move to. If there aren't enough things to move across, return nil. REGEXP and PRED are the same as in `treesit-thing-at-point'. RECURSING is an internal parameter, if non-nil, it means this function is called recursively. (fn POS ARG SIDE REGEXP &optional PRED RECURSING) (defalias 'treesit--navigate-thing #[1540 "\301!\302\3032\355\304V\205\354\305#\211\242\243\211\242\243\211\242\243\306=\203>\203>\307#\262\310\262\310\262\304V\203\225\311=\203\206\203a\f\204\206 \"=\202f\211\203\206\312\203\206\313\314\206p!\315\311\312&\206\201\316\303\310\"\262\202\342\n\206\217\"\262\202\342\317=\203\326\203\261\f\204\326 \"=\202\266\211\203\326\312\203\326\313\320\206\300!\321\317\312&\206\321\316\303\310\"\262\202\342\n\206\337\"\262 S\262\f\266\n\2020\210\304=\205\366\207" [treesit-defun-tactic abs #[514 "\300\267\202\301!\202\302!\202\303\211\204\304\305\303\"\207\207" [#s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (beg 6 end 12)) treesit-node-start treesit-node-end nil throw term] 6 "\n\n(fn SIDE NODE)"] term 0 treesit--things-around top-level treesit--top-level-thing nil beg t treesit--navigate-thing treesit-node-end 1 throw end treesit-node-start -1] 25 (#$ . 57177)])#@499 Return the thing node at point or nil if none is found. "Thing" is defined by PATTERN, which can be either a string REGEXP or a cons cell (REGEXP . PRED): if a node's type matches REGEXP, it is a thing. The "thing" could be further restricted by PRED: if non-nil, PRED should be a function that takes a node and returns t if the node is a "thing", and nil if not. Return the top-level defun if TACTIC is `top-level', return the immediate parent thing if TACTIC is `nested'. (fn PATTERN TACTIC) (defalias 'treesit-thing-at-point #[514 "\211:\204\n\211C\262\211\242\243\300`#\211\243\211\242\243\211\242\243\301!`=\203)\206*\n\302=\2039\303\n\n#\207\207" [treesit--things-around treesit-node-start top-level treesit--top-level-thing] 16 (#$ . 58810)])#@248 Return the defun node at point or nil if none is found. Respects `treesit-defun-tactic': return the top-level defun if it is `top-level', return the immediate parent defun if it is `nested'. Return nil if `treesit-defun-type-regexp' is not set. (defalias 'treesit-defun-at-point #[0 "\205\302 \"\207" [treesit-defun-type-regexp treesit-defun-tactic treesit-thing-at-point] 3 (#$ . 59588)])#@188 Return the defun name of NODE. Return nil if there is no name, or if NODE is not a defun node, or if NODE is nil. If `treesit-defun-name-function' is nil, always return nil. (fn NODE) (defalias 'treesit-defun-name #[257 "\205!\207" [treesit-defun-name-function] 3 (#$ . 59990)])#@178 Return the name of the defun at point. Used for `add-log-current-defun-function'. The delimiter between nested defun names is controlled by `treesit-add-log-defun-delimiter'. (defalias 'treesit-add-log-current-defun #[0 "\301 \302\203'\303!\211\203\203\211Q\266\202\202\211\262\210\304!\262\202\207" [treesit-add-log-defun-delimiter treesit-defun-at-point nil treesit-defun-name treesit-node-parent] 6 (#$ . 60283)])#@769 Settings that configure `treesit-simple-imenu'. It should be a list of (CATEGORY REGEXP PRED NAME-FN). CATEGORY is the name of a category, like "Function", "Class", etc. REGEXP should be a regexp matching the type of nodes that belong to CATEGORY. PRED should be either nil or a function that takes a node an the argument. It should return non-nil if the node is a valid node for CATEGORY, or nil if not. CATEGORY could also be nil. In that case the entries matched by REGEXP and PRED are not grouped under CATEGORY. NAME-FN should be either nil or a function that takes a defun node and returns the name of that defun node. If NAME-FN is nil, `treesit-defun-name' is used. `treesit-major-mode-setup' automatically sets up Imenu if this variable is non-nil. (defvar treesit-simple-imenu-settings nil (#$ . 60725))#@567 Given a sparse tree, create an Imenu index. NODE is a node in the tree returned by `treesit-induce-sparse-tree' (not a tree-sitter node, its car is a tree-sitter node). Walk that tree and return an Imenu index. Return a list of entries where each ENTRY has the form: ENTRY := (NAME . MARKER) | (NAME . ((" " . MARKER) ENTRY ...) PRED and NAME-FN are the same as described in `treesit-simple-imenu-settings'. NAME-FN computes NAME in an ENTRY. MARKER marks the start of each tree-sitter node. (fn NODE PRED NAME-FN) (defalias 'treesit--simple-imenu-1 #[771 "@A\300\301\302#\"\205\"\203!\202\303!\206\"\304\205-\305 \306!\307\223\2043\207\203A!\204A\207\203N\310BBBC\207BC\207" [mapcan make-closure #[257 "\302\301\300#\207" [V0 V1 treesit--simple-imenu-1] 5 "\n\n(fn NODE)"] treesit-defun-name "Anonymous" make-marker treesit-node-start nil " "] 11 (#$ . 61555)])#@47 Return an Imenu index for the current buffer. (defalias 'treesit-simple-imenu #[0 "\301 \302\303\304\"\"\207" [treesit-simple-imenu-settings treesit-buffer-root-node mapcan make-closure #[257 "\211\242\243\211\242\243\211\242\243\211\242\243\301\300\"\211\205\302#\211\205/ \203. BC\207\211\207" [V0 treesit-induce-sparse-tree treesit--simple-imenu-1] 14 "\n\n(fn SETTING)"]] 5 (#$ . 62513)])#@493 Check whether tree-sitter is ready to be used for MODE and LANGUAGE. LANGUAGE is the language symbol to check for availability. It can also be a list of language symbols. If tree-sitter is not ready, emit a warning and return nil. If the user has chosen to activate tree-sitter for LANGUAGE and tree-sitter is ready, return non-nil. If QUIET is t, don't emit a warning in either case; if quiet is `message', display a message instead of emitting a warning. (fn LANGUAGE &optional QUIET) (defalias 'treesit-ready-p #[513 ":\203 \202 C\301\3022t\303 \204'\304\305!\203\306\202 \307\262\310\302\301\"\210\311edS]!V\203:\312\262\310\302\301\"\210\211\205q\211@\313\314\"\211\242\243\204h\315\316@\317\320A\"\321\322\323#\266\202$\262\310\302\301\"\210\266A\266\202\202;\2620\210\211\204{\314\207\324P\262\325\267\202\223\326\327\"\210\202\223\330\331\"\210\301\207" [treesit-max-buffer-size nil term treesit-available-p fboundp treesit-node-p "tree-sitter library is not available or failed to load" "Emacs is not compiled with tree-sitter library" throw position-bytes "buffer larger than `treesit-max-buffer-size'" treesit-language-available-p t format "language grammar for %s is unavailable (%s): %s" mapcar #[257 "\300\301\"\207" [format "%s"] 4 "\n\n(fn X)"] " " mapconcat identity "Cannot activate tree-sitter, because " #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 134 message 142)) display-warning treesit message "%s"] 19 (#$ . 62931)])#@557 Activate tree-sitter to power major-mode features. If `treesit-font-lock-settings' is non-nil, set up fontification and enable `font-lock-mode'. If `treesit-simple-indent-rules' is non-nil, set up indentation. If `treesit-defun-type-regexp' is non-nil, set up `beginning-of-defun-function' and `end-of-defun-function'. If `treesit-defun-name-function' is non-nil, set up `add-log-current-defun'. If `treesit-simple-imenu-settings' is non-nil, set up Imenu. Make sure necessary parsers are created for the current buffer before calling this function. (defalias 'treesit-major-mode-setup #[0 "\203)\306\301!\210\307\310 \210\311 \211\203!\211@\312\313\"\210A\266\202\202\210\314\315\316\317\320$\210\311 \211\203=\211@\312\321\"\210A\266\202\202+\210\314\322\323\317\320$\210\n\203]\306\302!\210\324\n!\306\303!\210\325\306\304!\210\326 \203}\327\330 \331\332#\210\327\330 \333\334#\210\306\335!\210\332\306\336!\210\334#\203\211\306\337!\210\340$\205\226\306\341!\210\342\211!\207" [treesit-font-lock-settings font-lock-defaults treesit-simple-indent-rules indent-line-function indent-region-function treesit-defun-type-regexp make-local-variable (nil nil nil nil (font-lock-fontify-syntactically-function . treesit-font-lock-fontify-region)) treesit-font-lock-recompute-features treesit-parser-list treesit-parser-add-notifier treesit--font-lock-notifier add-hook pre-redisplay-functions treesit--pre-redisplay 0 t treesit--syntax-propertize-notifier syntax-propertize-extend-region-functions treesit--pre-syntax-ppss treesit--indent-rules-optimize treesit-indent treesit-indent-region keymap-set current-local-map " " treesit-beginning-of-defun " " treesit-end-of-defun beginning-of-defun-function end-of-defun-function add-log-current-defun-function treesit-add-log-current-defun imenu-create-index-function treesit-simple-imenu treesit-defun-name-function treesit-simple-imenu-settings] 5 (#$ . 64470)])#@64 Used by `treesit-inspect-mode' to show node name in mode-line. (defvar treesit--inspect-name nil (#$ . 66464)) (make-variable-buffer-local 'treesit--inspect-name)#@266 Show information of the node at point. If called interactively, show in echo area, otherwise set `treesit--inspect-name' (which will appear in the mode-line if `treesit-inspect-mode' is enabled). Uses the first parser in `treesit-parser-list'. (fn &optional ARG) (defalias 'treesit-inspect-node-at-point #[256 "\301\211\302\211\203 \303`!\202\304!\262\203)\305!`=\203#B\262\301\262\202\237\266\203\306!@\304!\204D\303`!\304\303`!!D\202I\307C\"\310\211\203\231\211@\311!\203`\312\313\311!\"\202a\314\315\316\"\203l\317\202m\320\321\322!\206u\323\324\325\f\"\205\200\326#\315\316\"\203\215\327\202\216\320\260\262A\266\202\202K\210\330\331\332#\333 \210\205\263\203\260\334\335\"\207\334\336!\207" [treesit--inspect-name nil t treesit-node-at treesit-node-parent treesit-node-start last append "" treesit-node-field-name format " %s: " " " treesit-node-check named "(" "\"" propertize treesit-node-type "N/A" face treesit-node-eq bold ")" string-replace "%" "%%" force-mode-line-update message "%s" "No node at point"] 16 (#$ . 66633) "p"])#@109 Non-nil if Treesit-Inspect mode is enabled. Use the command `treesit-inspect-mode' to change this variable. (defvar treesit-inspect-mode nil (#$ . 67733)) (make-variable-buffer-local 'treesit-inspect-mode)#@1252 Minor mode that displays in the mode-line the node which starts at point. When this mode is enabled, the mode-line displays PARENT FIELD-NAME: (NODE FIELD-NAME: (CHILD (...))) where NODE, CHILD, etc, are nodes which begin at point. PARENT is the parent of NODE. NODE is displayed in bold typeface. FIELD-NAMEs are field names of NODE and CHILD, etc (see Info node `(elisp)Language Grammar', heading "Field names"). If no node starts at point, i.e., point is in the middle of a node, then the mode line displays the earliest node that spans point, and its immediate parent. This minor mode doesn't create parsers on its own. It uses the first parser in `treesit-parser-list'. This is a minor mode. If called interactively, toggle the `Treesit-Inspect mode' mode. If the prefix argument is positive, enable the mode, and if it is zero or negative, disable the mode. If called from Lisp, toggle the mode if ARG is `toggle'. Enable the mode if ARG is nil, omitted, or is a positive number. Disable the mode if ARG is a negative number. To check whether the minor mode is enabled in the current buffer, evaluate `treesit-inspect-mode'. The mode's hook is called both when the mode is enabled and when it is disabled. (fn &optional ARG) (defalias 'treesit-inspect-mode #[256 "\303 \304=\203 ?\202\247\203\305W\203\306\202\307\310\301!\2031\311\300 \"\2031\300 B\203D\312\313\314\315\307$\210\316\302\317\"\210\202O\320\313\314\307#\210\321\322\n\"\323\324\203Y\325\202Z\326\"\210\327\330!\203}\303 \203n\211\303 \232\203}\331\332\333\203y\334\202z\335\336$\210\210\337 \210\207" [treesit-inspect-mode local-minor-modes mode-line-misc-info current-message toggle 1 nil t boundp delq add-hook post-command-hook treesit-inspect-node-at-point 0 add-to-list (:eval treesit--inspect-name) remove-hook remove (:eval treesit--inspect-name) run-hooks treesit-inspect-mode-hook treesit-inspect-mode-on-hook treesit-inspect-mode-off-hook called-interactively-p any message "%s %sabled%s" "Treesit-Inspect mode" "en" "dis" " in current buffer" force-mode-line-update] 7 (#$ . 67946) (byte-code "\203\n\301!\202 \302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)]) (defvar treesit-inspect-mode-hook nil) (byte-code "\301\302N\204\f\303\301\302\304#\210\303\301\305\306#\210\303\301\307\310C#\210\311\312\310\313\300!\205#\310\211%\207" [treesit-inspect-mode-map treesit-inspect-mode-hook variable-documentation put "Hook run after entering or leaving `treesit-inspect-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" custom-type hook standard-value nil add-minor-mode treesit-inspect-mode boundp] 6)#@175 Check if QUERY is valid for LANGUAGE. If QUERY is invalid, display the query in a popup buffer, jump to the offending pattern and highlight the pattern. (fn LANGUAGE QUERY) (defalias 'treesit-query-validate #[514 "\211:\204\211;\204\301\302!\210\303\304!\305\306\307\"r\211q\210\310\311\"\216\312!\210\31312\314\"\210\315\316!0\202\201rq\210\211A\211@A@\307\317 \210;\203M\202Q\320!c\210\211b\210\321\322\323\307#\210\324`\325\326$\210\315\327`{\"\210eb\210\330\331#c\210\211u*\266\332!\210\333 \262*\207" [inhibit-read-only cl--assertion-failed (or (consp query) (stringp query)) get-buffer-create "*tree-sitter check query*" generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205 \302\300!\207" [V0 buffer-name kill-buffer] 2] treesit-parser-create (treesit-query-error) treesit-query-capture message "QUERY is valid" erase-buffer treesit-query-expand search-forward " " nil put-text-property face error "%s" format "%s: %d\n" pop-to-buffer view-mode] 13 (#$ . 70691)]) (custom-declare-face 'treesit-explorer-anonymous-node (let ((display t) (atts '(:inherit shadow))) (list (cons display atts))) "Face for anonymous nodes in tree-sitter explorer.") (custom-declare-face 'treesit-explorer-field-name (let ((display t) (atts nil)) (list (cons display atts))) "Face for field names in tree-sitter explorer.")#@41 Buffer used to display the syntax tree. (defvar treesit--explorer-buffer nil (#$ . 72044)) (make-variable-buffer-local 'treesit--explorer-buffer)#@55 Source buffer corresponding to the playground buffer. (defvar treesit--explorer-source-buffer nil (#$ . 72195)) (make-variable-buffer-local 'treesit--explorer-source-buffer)#@38 The language used in the playground. (defvar treesit--explorer-language nil (#$ . 72374)) (make-variable-buffer-local 'treesit--explorer-language)#@46 Timer for refreshing the syntax tree buffer. (defvar treesit--explorer-refresh-timer nil (#$ . 72526)) (make-variable-buffer-local 'treesit--explorer-refresh-timer)#@61 Overlay used to highlight in syntax tree and source buffer. (defvar treesit--explorer-highlight-overlay nil (#$ . 72696)) (make-variable-buffer-local 'treesit--explorer-highlight-overlay)#@51 Last top-level node used to generate syntax tree. (defvar treesit--explorer-last-node nil (#$ . 72889)) (make-variable-buffer-local 'treesit--explorer-last-node)#@329 Return nodes for LANGUAGE covered in region. This function tries to return the largest node possible. If the region covers exactly one node, that node is returned (in a list). If the region covers more than one node, two nodes are returned: the very first one in the region and the very last one in the region. (fn LANGUAGE) (defalias 'treesit--explorer--nodes-to-highlight #[257 "\300 \301 \302#\303\304\305#\"\206\211\306\307!\310!$\203'\211C\207\311!\312\311!\304\313\"\314\211$D\207" [region-beginning region-end treesit-node-on treesit-parent-while make-closure #[257 "\302\301\303!\304!\300$\207" [V0 V1 <= treesit-node-start treesit-node-end] 6 "\n\n(fn N)"] <= treesit-node-start treesit-node-end treesit-node-at treesit-search-forward #[257 "\301!\300X\207" [V0 treesit-node-end] 3 "\n\n(fn N)"] t] 11 (#$ . 73057)])#@32 Update the syntax tree buffer. (defalias 'treesit--explorer-refresh #[0 "\205\224\306 !\205\224\307\310 \311 \n#\312 \313W\203\211\202,\314l\203)e`S]\202*`\315#\316 \2054\317\n!\320 \"p\321\303!\210r q\210\315\321\305!\210\211\203Z\204Z\322 \210\323!\210\324!\211\205d\325 !\211\205\217\203rb\210\202\213eb\210\326\"\204\213\327y\330U\203\213\331`\"\210\202u\332\"\266\202*\266\205\207" [treesit-explore-mode treesit--explorer-buffer treesit--explorer-language treesit--explorer-last-node inhibit-read-only treesit--explorer-source-buffer buffer-live-p treesit-node-on window-start window-end buffer-size 4000 treesit-node-first-child-for-pos t region-active-p treesit--explorer--nodes-to-highlight treesit-node-eq make-local-variable erase-buffer treesit--explorer-draw-node treesit--explorer-highlight-node get-buffer-window pos-visible-in-window-p 4 0 set-window-start set-window-point] 10 (#$ . 73913)])#@69 Post-command function that runs in the source buffer. (fn &rest _) (defalias 'treesit--explorer-post-command #[128 "\205 \203\f\303 !\210\n\203\304\n!\210\305\302!\210\306\307\310\311#\211\207" [treesit-explore-mode treesit--explorer-highlight-overlay treesit--explorer-refresh-timer delete-overlay cancel-timer make-local-variable run-with-timer 0.1 nil treesit--explorer-refresh] 5 (#$ . 74861)])#@62 Mark the original text corresponding to BUTTON. (fn BUTTON) (defalias 'treesit--explorer-jump #[257 "\302\303!\2054\304!\2054rq\210\305\306\"\305\307\" \203 \310 !\210\311\301!\210\312\313\314\313%\315 \316\317#\266\202)\207" [treesit--explorer-source-buffer treesit--explorer-highlight-overlay derived-mode-p treesit--explorer-tree-mode buffer-live-p button-get node-start node-end delete-overlay make-local-variable make-overlay nil t overlay-put face highlight] 9 (#$ . 75273) nil])#@129 Highlight nodes in NODES in the syntax tree buffer. Return the start of the syntax tree text corresponding to NODE. (fn NODES) (defalias 'treesit--explorer-highlight-node #[257 "\203\301!\210\211@\302!@\303\211\205n\205n\304ed\"\303:\203T@\262\203.\204T\305\306\307\"\"\203>\310!\262\305\306\307\"\"\203M\311!\262A\262\202\266\205n\211\205n\312\300!\210\313\"\314\315\316#\210\207" [treesit--explorer-highlight-overlay delete-overlay last nil overlays-in treesit-node-eq overlay-get treesit-node overlay-start overlay-end make-local-variable make-overlay overlay-put face highlight] 12 (#$ . 75776)])#@216 Draw the syntax tree of NODE. When this function is called, point should be at the position where the node should start. When this function returns, it leaves point at the end of the last line of NODE. (fn NODE) (defalias 'treesit--explorer-draw-node #[257 "\301!\302!\303!\304\305\"i\306\211\307\310\311\312\"\"\313=\314\306\211\203%\315!\210`\262 \203H\316\n\317P\320\321#c\210\203H\204H\322c\210Tj\210i\262\203j\323c\210\324 \325\326\327\314\330\331!\332\333!& \210\202\207\n\334\267\202\203\335c\210\202\207\336c\210\202\207\337c\210\202\207\nc\210i\262\211\203\337\211@\312!\313=T\203\305\203\305`\340c\210\341!\210i\342 W?\205\300\211`|\210\306\262 T\262\314\262\202\320\322c\210\211j\210\341!\210\306\204\232\262\266A\266\202\202\214\210\203\350\343c\210`\262\344\"\345\346#\210\345\347\314#\210?\205\345\320\350#\207" [treesit--explorer-highlight-overlay treesit-node-type treesit-node-field-name treesit-node-children treesit-node-check named nil apply + mapcar treesit-node-child-count 0 t delete-overlay propertize ": " face treesit-explorer-field-name "\n" "(" insert-text-button action treesit--explorer-jump follow-link node-start treesit-node-start node-end treesit-node-end #s(hash-table size 3 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ("\n" 113 " " 119 " " 125)) "\\n" "\\t" "SPC" " " treesit--explorer-draw-node window-width ")" make-overlay overlay-put treesit-node evaporate treesit-explorer-anonymous-node] 23 (#$ . 76425)])#@42 Kill the explorer buffer of this buffer. (defalias 'treesit--explorer-kill-explorer-buffer #[0 "\301!\205 \302!\207" [treesit--explorer-buffer buffer-live-p kill-buffer] 2 (#$ . 77982)]) (defvar treesit--explorer-tree-mode-hook nil) (byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [treesit--explorer-tree-mode-hook variable-documentation put "Hook run after entering TS Explorer mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp treesit--explorer-tree-mode-map definition-name treesit--explorer-tree-mode] 4) (defvar treesit--explorer-tree-mode-map (make-sparse-keymap)) (byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204*\303\307\310\311#\210\312\307\306\307!\203&\313\202(\314 \"\210\307\302N\2048\303\307\302\304\315!#\210\306\300!\204X\303\300\310\311#\210\312\300\306\300!\203P\313\202V\316\300\313\"\210\"\210\300\302N\204f\303\300\302\304\317!#\210\303\311\320\321#\207" [treesit--explorer-tree-mode-abbrev-table treesit--explorer-tree-mode-map variable-documentation put purecopy "Keymap for `treesit--explorer-tree-mode'." boundp treesit--explorer-tree-mode-syntax-table definition-name treesit--explorer-tree-mode defvar-1 nil make-syntax-table "Syntax table for `treesit--explorer-tree-mode'." define-abbrev-table "Abbrev table for `treesit--explorer-tree-mode'." derived-mode-parent special-mode] 5)#@287 Mode for displaying syntax trees for `treesit-explore-mode'. In addition to any hooks its parent mode `special-mode' might have run, this mode runs the hook `treesit--explorer-tree-mode-hook', as the final or penultimate step during initialization. \{treesit--explorer-tree-mode-map} (defalias 'treesit--explorer-tree-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315 !\204'\316 \317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324 \325\"\204R =\204R\326 \325C#\210\327 !\210\330\f!\210 )\331\332!\207" [delay-mode-hooks major-mode mode-name treesit--explorer-tree-mode-map treesit--explorer-tree-mode-syntax-table treesit--explorer-tree-mode-abbrev-table make-local-variable t special-mode treesit--explorer-tree-mode "TS Explorer" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table run-mode-hooks treesit--explorer-tree-mode-hook local-abbrev-table] 5 (#$ . 79466) nil])#@109 Non-nil if Treesit-Explore mode is enabled. Use the command `treesit-explore-mode' to change this variable. (defvar treesit-explore-mode nil (#$ . 80579)) (make-variable-buffer-local 'treesit-explore-mode)#@811 Enable exploring the current buffer's syntax tree. Pops up a window showing the syntax tree of the source in the current buffer in real time. The corresponding node enclosing the text in the active region is highlighted in the explorer window. This is a minor mode. If called interactively, toggle the `Treesit-Explore mode' mode. If the prefix argument is positive, enable the mode, and if it is zero or negative, disable the mode. If called from Lisp, toggle the mode if ARG is `toggle'. Enable the mode if ARG is nil, omitted, or is a positive number. Disable the mode if ARG is a negative number. To check whether the minor mode is enabled in the current buffer, evaluate `treesit-explore-mode'. The mode's hook is called both when the mode is enabled and when it is disabled. (fn &optional ARG) (defalias 'treesit-explore-mode #[256 "\306 \307=\203 ?\202\247\203\310W\203\311\202\312\313\301!\2031\314\300 \"\2031\300 B\203\245\315\316\317\320\321\322 \"\"!\323!\204S\324\325\323\312\"A#\266\202\264\326\n!\204s\327\302!\210\330\331\332\333 \"!\327\303!\210\211r\nq\210\334 )\210\335\n\311\336B\"\210\327\304!\210\311\337 \210\340\341\342\343\312$\210\340\344\345\343\312$\210\313\305!\203\241\334 >\204\241\334 B\210\202\264\346\341\342\312#\210\346\341\345\312#\210\345 \210\347\350\203\276\351\202\277\352\"\210\353\354!\203\342\306 \203\323\211\306 \232\203\342\355\356\357\203\336\360\202\337\361\362$\210\210\363 \210\207" [treesit-explore-mode local-minor-modes treesit--explorer-buffer treesit--explorer-language treesit--explorer-last-node desktop-modes-not-to-save current-message toggle 1 nil t boundp delq intern completing-read "Language: " mapcar treesit-parser-language treesit-parser-list treesit-language-available-p user-error "Cannot find tree-sitter grammar for %s: %s" buffer-live-p make-local-variable get-buffer-create format "*tree-sitter explorer for %s*" buffer-name treesit--explorer-tree-mode display-buffer ((inhibit-same-window . t)) treesit--explorer-refresh add-hook post-command-hook treesit--explorer-post-command 0 kill-buffer-hook treesit--explorer-kill-explorer-buffer remove-hook run-hooks treesit-explore-mode-hook treesit-explore-mode-on-hook treesit-explore-mode-off-hook called-interactively-p any message "%s %sabled%s" "Treesit-Explore mode" "en" "dis" " in current buffer" force-mode-line-update] 9 (#$ . 80791) (byte-code "\203\n\301!\202 \302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)]) (defvar treesit-explore-mode-hook nil) (byte-code "\301\302N\204\f\303\301\302\304#\210\303\301\305\306#\210\303\301\307\310C#\210\311\312\313\314\300!\205#\310\211%\207" [treesit-explore-mode-map treesit-explore-mode-hook variable-documentation put "Hook run after entering or leaving `treesit-explore-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" custom-type hook standard-value nil add-minor-mode treesit-explore-mode " TSexplore" boundp] 6)#@604 Configuration for downloading and installing tree-sitter language grammars. The value should be an alist where each element has the form (LANG . (URL REVISION SOURCE-DIR CC C++)) Only LANG and URL are mandatory. LANG is the language symbol. URL is the Git repository URL for the grammar. REVISION is the Git tag or branch of the desired version, defaulting to the latest default branch. SOURCE-DIR is the relative subdirectory in the repository in which the grammar's parser.c file resides, defaulting to "src". CC and C++ are C and C++ compilers, defaulting to "cc" and "c++", respectively. (defvar treesit-language-source-alist nil (#$ . 83848))#@131 Interactively produce a download/build recipe for LANG and return it. See `treesit-language-source-alist' for details. (fn LANG) (defalias 'treesit--install-language-grammar-build-recipe #[257 "\300\301\302\"!\2053\303\301\304\"\305\306\307!\205\"\262\305\310!!\305\311!!\305\312!!\305\313!!\257\262\207" [y-or-n-p format "There is no recipe for %s, do you want to build it interactively?" #[257 "\211\300\232?\205\211\207" [""] 3 "\n\n(fn STRING)"] "https://github.com/tree-sitter/tree-sitter-%s" read-string "Enter the URL of the Git repository of the language grammar: " treesit--check-repo-url "Enter the tag or branch (default: default branch): " "Enter the subdirectory in which the parser.c file resides (default: \"src\"): " "Enter the C compiler to use (default: auto-detect): " "Enter the C++ compiler to use (default: auto-detect): "] 10 (#$ . 84513)])#@12 (fn URL) (defalias 'treesit--check-repo-url #[257 "\301\3021\303\304\211#0\202\210\305\211\205\306\307\"\310=)\207" [url-request-method "HEAD" (file-error) url-retrieve-synchronously t nil buffer-local-value url-http-response-status 200] 5 (#$ . 85400)])#@707 Build and install the tree-sitter language grammar library for LANG. Interactively, if `treesit-language-source-alist' doesn't already have data for building the grammar for LANG, prompt for its repository URL and the C/C++ compiler to use. The recipe built by the prompts are saved for the current session if the installation is successful and the grammar is loadable. This command requires Git, a C compiler and (sometimes) a C++ compiler, and the linker to be installed and on PATH. It also requires that the recipe for LANG exists in `treesit-language-source-alist'. See `exec-path' for the current path where Emacs looks for executable programs, such as the C/C++ compiler and linker. (fn LANG) (defalias 'treesit-install-language-grammar #[257 "\301\"\206\n\302!\211\205m\3031d\304\305\306B\"\210\307\310\"\211\242\243\204B\311\312\313\314@\315\316A\"\317\320\321#\266\202$\"\266\202\202`\236A\203R\241\210\202\\B\211\262B\262\266\202\2620\207\311\312\313\322\"\"\262\207" [treesit-language-source-alist assoc treesit--install-language-grammar-build-recipe (error) apply treesit--install-language-grammar-1 nil treesit-language-available-p t display-warning treesit format "The installed language grammar for %s cannot be located or has problems (%s): %s" mapcar #[257 "\300\301\"\207" [format "%s"] 4 "\n\n(fn X)"] " " mapconcat identity "Error encountered when installing language grammar: %s"] 17 (#$ . 85672) (byte-code "\301\302\303\304\305\"\"!C\207" [treesit-language-source-alist intern completing-read "Language: " mapcar car] 6)])#@164 Run `call-process' with ARGS. If it returns anything but 0, signal an error. Use the buffer content as signal data, and erase buffer afterwards. (fn &rest ARGS) (defalias 'treesit--call-process-signal #[128 "\300\301\"\302=?\205#\303\304\305@\306\233B\307\310\311#\266\202\312\313 F\"\210\314 \207" [apply call-process 0 signal treesit-error "Command:" 4 " " mapconcat identity "Error output:" buffer-string erase-buffer] 10 (#$ . 87270)])#@479 Install and compile a tree-sitter language grammar library. OUT-DIR is the directory to put the compiled library file. If it is nil, the "tree-sitter" directory under user's Emacs configuration directory is used (and automatically created if it does not exist). For LANG, URL, REVISION, SOURCE-DIR, GRAMMAR-DIR, CC, C++, see `treesit-language-source-alist'. If anything goes wrong, this function signals an error. (fn OUT-DIR LANG URL &optional REVISION SOURCE-DIR CC C++) (defalias 'treesit--install-language-grammar-1 #[1795 "\302!\303\304\305\"\306\307!\306\206\310\"\206 \311\312\313\"\206 \314\206,\311\312\315\"\206,\316 @\2065\317\320\321\"\f\203A\306 !\206D\322\323!\324Q\325\326\"\216\327\330\305\"r\211q\210\325\331\"\216\332\333!\210\f\203{\334\335\336\305\336\337\340\341\342\343&\f\210\202\213\334\335\336\305\336\337\340\341\342&\n\210\332\344!\210\334\336\305\336\345\346\347\350&\210\351\352!\203\262\334\336\305\336\345\346\347\352&\210\351\353!\203\304\334\336\305\336\345\346\347\353&\210\354\334\351\353!\203\321\202\323\336\305\336\345\355\356\357\336\360#\361\fD\"BB&\210\351!\204\363\362\305\"\210\306\"\211\363P\351!\203\364\305#\210\365\366!\305\211$\210\3671\370!0\266\202\266\332\371#,\207" [default-directory dynamic-library-suffixes symbol-name make-temp-file "treesit-workdir" t expand-file-name "repo" "src" seq-find executable-find ("cc" "gcc" "c99") "cc" ("c++" "g++") "c++" signal treesit-error ("Emacs cannot figure out the file extension for dynamic libraries for this system, because `dynamic-library-suffixes' is nil") locate-user-emacs-file "tree-sitter" "libtree-sitter-" make-closure #[0 "\301\300!\205\n\302\300\303\"\207" [V0 file-exists-p delete-directory t] 3] generate-new-buffer " *temp*" #[0 "\301\300!\205 \302\300!\207" [V0 buffer-name kill-buffer] 2] message "Cloning repository" treesit--call-process-signal "git" nil "clone" "--depth" "1" "--quiet" "-b" "Compiling library" "-fPIC" "-c" "-I." "parser.c" file-exists-p "scanner.c" "scanner.cc" apply "-shared" append directory-files "\\`[^z-a]+\\.o\\'" "-o" make-directory ".old" rename-file copy-file file-name-as-directory (error) delete-file "Library installed to %s/%s"] 29 (#$ . 87724)])#@72 Print tree-sitter functions missing from the manual in message buffer. (defalias 'treesit--check-manual-coverage #[0 "\301\302!\210\303\304\305\"r\211q\210\306\307\"\216\310\311\312!!\210\313\314\315\212eb\210\316\317\320\316\305#\2031\321\322!B\262\202\211\237)\262\323\"\"*\262\303\304\305\"r\211q\210\306\324\"\216\310\325\326\"!\210\310\325\327\"!\210\315\212eb\210\316\317\330\316\305#\203o\321\322!B\262\202]\211\237)\262\323\"*\262\331\332\313\306\333\"\"\334\335\336#\266\202\"\207" [source-directory require find-func generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205 \302\300!\207" [V0 buffer-name kill-buffer] 2] insert-file-contents find-library-name "treesit" cl-remove-if #[257 "\300\301\"\207" [string-match "treesit--"] 4 "\n\n(fn NAME)"] cl-sort nil re-search-forward "^(defun \\([^ ]+\\)" match-string-no-properties 1 string< #[0 "\301\300!\205 \302\300!\207" [V0 buffer-name kill-buffer] 2] expand-file-name "doc/lispref/parsing.texi" "doc/lispref/modes.texi" "^@defun \\([^ ]+\\)" message "Missing: %s" #[257 "\211\300\235\207" [V0] 3 "\n\n(fn NAME)"] "\n" mapconcat identity] 10 (#$ . 90012) nil])#@33 Generate examples for shortdoc. (defalias 'treesit--generate-shortdoc-examples #[0 "\300\301\302\"r\211q\210\303\304\"\216\305\211\306c\210\307\310\311!!\210\307\312 !\210eb\210\307\313`!\211\262!\210\307\314!\211\262!\210\307\315!!\210\307\316!!\210\307\317\320\"!\266*\305\207" [generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205 \302\300!\207" [V0 buffer-name kill-buffer] 2] nil "int c = 0;" print treesit-parser-create c treesit-parser-list treesit-node-at treesit-node-parent treesit-node-children treesit-node-next-sibling treesit-node-child-by-field-name "declarator"] 7 (#$ . 91174)]) (byte-code "\301\302\236\"\302\303BB\304\302!\207" [shortdoc--groups delq treesit ("Parsers" (treesit-parser-create :no-eval (treesit-parser-create 'c) :eg-result-string "#") (treesit-parser-delete :no-value (treesit-parser-delete parser)) (treesit-parser-list :no-eval (treesit-parser-list) :eg-result-string "(#)") (treesit-parser-buffer :no-eval (treesit-parser-buffer parser) :eg-result-string "#") (treesit-parser-language :no-eval (treesit-parser-language parser) :eg-result c) (treesit-parser-add-notifier) (treesit-parser-remove-notifier) (treesit-parser-notifiers :no-eval (treesit-parser-notifiers parser) :eg-result (function1 function2 function3)) "Parser ranges" (treesit-parser-set-included-ranges :no-value (treesit-parser-set-included-ranges parser '((1 . 4) (5 . 8)))) (treesit-parser-included-ranges :no-eval (treesit-parser-included-ranges parser) :eg-result ((1 . 4) (5 . 8))) (treesit-query-range :no-eval (treesit-query-range node '((script_element) @cap)) :eg-result ((1 . 4) (5 . 8))) "Retrieving a node" (treesit-node-at :no-eval (treesit-node-at (point)) :eg-result-string "#") (treesit-node-on :no-eval (treesit-node-on 18 28) :eg-result-string "#") (treesit-buffer-root-node :no-eval (treesit-buffer-root-node) :eg-result-string "#") (treesit-parser-root-node :no-eval (treesit-parser-root-node parser) :eg-result-string "#") "Retrieving a node from another node" (treesit-node-parent :no-eval (treesit-node-parent node) :eg-result-string "#") (treesit-node-child :no-eval (treesit-node-child node 0) :eg-result-string "#") (treesit-node-children :no-eval (treesit-node-children node) :eg-result-string "(# # #)") (treesit-node-next-sibling :no-eval (treesit-node-next-sibling node) :eg-result-string "#") (treesit-node-prev-sibling :no-eval (treesit-node-prev-sibling node) :eg-result-string "#") (treesit-node-child-by-field-name :no-eval (treesit-node-child-by-field-name node "declarator") :eg-result-string "#") (treesit-node-first-child-for-pos :no-eval (treesit-node-first-child-for-pos node 1) :eg-result-string "#") (treesit-node-descendant-for-range :no-eval (treesit-node-descendant-for-range node 2 3) :eg-result-string "#") "Searching for node" (treesit-search-subtree :no-eval (treesit-search-subtree node "function_definition") :eg-result-string "#") (treesit-search-forward :no-eval (treesit-search-forward node "function_definition") :eg-result-string "#") (treesit-search-forward-goto :no-eval (treesit-search-forward-goto node "function_definition") :eg-result-string "#") (treesit-induce-sparse-tree :no-eval (treesit-induce-sparse-tree node "function_definition") :eg-result-string "(nil (#) (#) (#))") (treesit-filter-child :no-eval (treesit-filter-child node (lambda (n) (equal (treesit-node-type) "identifier"))) :eg-result-string "(#)") (treesit-parent-until :no-eval (treesit-parent-until node (lambda (p) (eq (treesit-node-start p) (point)))) :eg-result-string "#") (treesit-parent-while :no-eval (treesit-parent-while node (lambda (p) (eq (treesit-node-start p) (point)))) :eg-result-string "#") (treesit-node-top-level :no-eval (treesit-node-top-level node) :eg-result-string "#") "Retrieving node information" (treesit-node-text :no-eval (treesit-node-text node) :eg-result "int") (treesit-node-start :no-eval (treesit-node-start node) :eg-result 1) (treesit-node-end :no-eval (treesit-node-end node) :eg-result 10) (treesit-node-type :no-eval (treesit-node-type node) :eg-result "function_definition") (treesit-node-field-name :no-eval (treesit-node-field-name node) :eg-result "body") (treesit-node-parser :no-eval (treesit-node-parser node) :eg-result-string "#") (treesit-node-language :no-eval (treesit-node-language node) :eg-result c) (treesit-node-buffer :no-eval (treesit-node-buffer node) :eg-result-string "#") (treesit-node-index :no-eval (treesit-node-index node) :eg-result 0) (treesit-node-string :no-eval (treesit-node-string node) :eg-result-string "(init_declarator declarator: (identifier) value: (number_literal))") (treesit-node-check :no-eval (treesit-node-check node 'named) :eg-result t) (treesit-node-field-name-for-child :no-eval (treesit-node-field-name-for-child node) :eg-result "body") (treesit-node-child-count :no-eval (treesit-node-child-count node) :eg-result 3) "Pattern matching" (treesit-query-capture :no-eval (treesit-query-capture node '((identifier) @id "return" @ret)) :eg-result-string "((id . #) (ret . #))") (treesit-query-compile :no-eval (treesit-query-compile 'c '((identifier) @id "return" @ret)) :eg-result-string "#") (treesit-query-language :no-eval (treesit-query-language compiled-query) :eg-result c) (treesit-query-expand :eval (treesit-query-expand '((identifier) @id "return" @ret))) (treesit-pattern-expand :eval (treesit-pattern-expand :anchor) :eval (treesit-pattern-expand '(identifier)) :eval (treesit-pattern-expand :equal)) "Parsing a string" (treesit-parse-string :no-eval (treesit-parse-string "int c = 0;" 'c) :eg-result-string "#") (treesit-query-string :no-eval (treesit-query-string "int c = 0;" '((identifier) @id) 'c) :eg-result-string "((id . #))") "Misc" (treesit-subtree-stat :no-eval (treesit-subtree-stat node) :eg-result (6 33 487))) provide] 3)