diff --git a/build/build-relationships.py b/build/build-relationships.py index a13c323..34acc60 100755 --- a/build/build-relationships.py +++ b/build/build-relationships.py @@ -124,11 +124,18 @@ def build_all_node_types(rules): for field, sub_rules in per_field_rules.items(): for sub_rule in sub_rules: types.add(sub_rule) - # types.add(field) return types -def process_rules(data): +def build_supertypes(data): + return [LispString(el) for el in data.get("supertypes", [])] + + +def process_grammar(data): + return build_supertypes(data) + + +def process_nodes(data): rules = defaultdict(lambda: defaultdict(set)) for obj in data: match_rule(obj, rules) @@ -141,7 +148,7 @@ def make_rules_symbol(language, *rest): return Symbol(f"combobulate-rules-{language}" + "".join(rest)) -def generate_sexp(rules, inv_rules, all_node_types, language, source): +def generate_sexp(rules, inv_rules, all_node_types, supertypes, language): l = [] for rule_name, rule_fields in rules.items(): # Ignore named fields and only generate the defaults? @@ -181,10 +188,19 @@ def generate_sexp(rules, inv_rules, all_node_types, language, source): "\n", ] ), + sexp( + [ + Symbol("defconst"), + make_rules_symbol(language, "-supertypes"), + "\n", + Quote(sexp([n for n in sorted(supertypes)]) or []) or "nil", + "\n", + ] + ), ] -def load_node_types(source): +def load_json(source): assert isinstance(source, Path), f"{source} must be a Path-like object." try: return json.loads(source.read_text()) @@ -229,7 +245,7 @@ def write_form(form, header: str | None = None, footer: str | None = None): newline() langs = [] - for src, (form, inv_form, all_node_types_form) in forms: + for src, (form, inv_form, all_node_types_form, supertypes_form) in forms: langs.append(src) if not form: log.error("Skipping %s as it is empty", src) @@ -249,6 +265,11 @@ def write_form(form, header: str | None = None, footer: str | None = None): header=f"All node types in {src}", footer=f"All node types in {src}", ) + write_form( + supertypes_form, + header=f"All supertypes in {src}", + footer=f"All supertypes in {src}", + ) newline() write_form( sexp( @@ -283,41 +304,19 @@ def make_alist(rules_symbol_extra): ) ) - write_form( - sexp( - [ - Symbol("defconst"), - Symbol("combobulate-rules-alist"), - "\n", - make_alist(""), - ] - ), - header="Auto-generated alist of all languages and their production rules", - ) - newline() - write_form( - sexp( - [ - Symbol("defconst"), - Symbol("combobulate-rules-inverse-alist"), - "\n", - make_alist("-inverse"), - ] - ), - ) - newline() - write_form( - sexp( - [ - Symbol("defconst"), - Symbol("combobulate-rules-types-alist"), - "\n", - make_alist("-types"), - ] - ), - footer="Auto-generated alist of all languages and their production rules", - ) - newline() + for rules_symbol_extra in ["", "-inverse", "-types", "-supertypes"]: + write_form( + sexp( + [ + Symbol("defconst"), + Symbol(f"combobulate-rules{rules_symbol_extra}-alist"), + "\n", + make_alist(rules_symbol_extra), + ] + ), + ) + + newline() write_form( sexp( [ @@ -328,11 +327,18 @@ def make_alist(rules_symbol_extra): ) -def parse_source(language, source): - log.info("Parsing language %s with node file %s", language, source) - data = load_node_types(source) - rules, inv_rules, all_node_types = process_rules(data) - return generate_sexp(rules, inv_rules, all_node_types, language, source) +def parse_source(language, nodes_fn, grammar_fn): + log.info( + "Parsing language %s with node file %s and grammar file %s", + language, + nodes_fn, + grammar_fn, + ) + node_data = load_json(nodes_fn) + grammar_data = load_json(grammar_fn) + supertypes = process_grammar(grammar_data) + rules, inv_rules, all_node_types = process_nodes(node_data) + return generate_sexp(rules, inv_rules, all_node_types, supertypes, language) def read_sources(sources_file: str) -> dict: @@ -360,7 +366,14 @@ def main(): download_all_sources(sources) for src, files in sources.items(): - forms.append((src, parse_source(src, Path(f"{src}-nodes.json")))) + forms.append( + ( + src, + parse_source( + src, Path(f"{src}-nodes.json"), Path(f"{src}-grammar.json") + ), + ) + ) write_elisp_file(forms) diff --git a/build/tsx-grammar.json b/build/tsx-grammar.json index 3013c1f..bb72378 100644 --- a/build/tsx-grammar.json +++ b/build/tsx-grammar.json @@ -11429,3 +11429,4 @@ ] } + diff --git a/combobulate-css.el b/combobulate-css.el index 7639f0f..15ed836 100644 --- a/combobulate-css.el +++ b/combobulate-css.el @@ -91,7 +91,24 @@ '((:activation-nodes ((:nodes (all))) :selector (:choose node :match-children t)))) (setq combobulate-navigation-sibling-procedures - '((:activation-nodes + '(;; declarations' own property values should be siblings, but + ;; not property_name as it's a child of declaration also, + ;; and that'd mean the LHS and RHS are siblings of another, + ;; which would be weird. + (:activation-nodes + ((:nodes + ((rule "feature_query") + (rule "arguments")) + :has-parent ("feature_query" "arguments"))) + :selector (:choose parent + :match-children t)) + (:activation-nodes + ((:nodes + ((exclude (rule "declaration") "property_name")) + :has-parent ("declaration"))) + :selector (:choose parent + :match-children (:discard-rules ("comment" "property_name")))) + (:activation-nodes ((:nodes ((rule "block") (rule "stylesheet")) @@ -102,22 +119,7 @@ ((:nodes ("declaration") :has-parent ("block"))) - :selector (:match-children (:discard-rules ("comment" "property_name")))) - ;; declarations' own property values should be siblings, but - ;; not property_name as it's a child of declaration also, - ;; and that'd mean the LHS and RHS are siblings of another, - ;; which would be weird. - (:activation-nodes - ((:nodes - ((exclude ((rule "declaration")) "property_name")) - :has-parent ("declaration"))) - :selector (:match-children (:discard-rules ("comment" "property_name")))) - (:activation-nodes - ((:nodes - ((rule "feature_query") - (rule "arguments")) - :has-parent ("feature_query" "arguments"))) - :selector (:match-children (:discard-rules ("comment")))))) + :selector (:match-children (:discard-rules ("comment" "property_name")))))) (setq combobulate-navigation-defun-procedures '((:activation-nodes ((:nodes (exclude (all) "declaration"))))))) diff --git a/combobulate-display.el b/combobulate-display.el index 3b3b90e..b4fe93e 100644 --- a/combobulate-display.el +++ b/combobulate-display.el @@ -163,11 +163,13 @@ (with-navigation-nodes (:nodes (seq-difference combobulate-navigation-default-nodes combobulate-display-ignored-node-types)) - (when (member (combobulate-node-type node) combobulate-display-ignored-node-types) - (setq node (combobulate--get-nearest-navigable-node))) - (when node - (save-excursion - (combobulate-display-draw-tree-1 (combobulate-display-create-locus node) node))))) + (cond + ((member (combobulate-node-type node) combobulate-display-ignored-node-types) + (setq node (combobulate--get-nearest-navigable-node) + hl-node nil)) + ((not node) (setq node (combobulate--get-nearest-navigable-node) + hl-node (combobulate--get-nearest-navigable-node)))) + (combobulate-display-draw-tree-1 (combobulate-display-create-locus node) hl-node))) (defun combobulate-display-create-locus (start-node) diff --git a/combobulate-envelope.el b/combobulate-envelope.el index e4b0eac..a5d18ae 100644 --- a/combobulate-envelope.el +++ b/combobulate-envelope.el @@ -387,44 +387,45 @@ If the register does not exist, return DEFAULT or nil." :end end :user-actions user-actions)))) -(defun combobulate-envelope-render-choice-preview (_index current-node proxy-nodes refactor-id) +(defun combobulate-envelope-render-choice-preview (action) "Render a preview of the envelope at INDEX. Unlike most proffer preview functions, this one assumes that `accept-action' passed to `combobulate-proffer-choices' is `commit' and not its usual value of `rollback'." - (combobulate-refactor (:id refactor-id) - (let ((pt) - (combobulate-envelope-static t) - (combobulate-envelope--undo-on-quit nil)) - (dolist (node proxy-nodes) - (let ((expand-envelope) (is-current-node)) - (pcase-let ((`(,missing . ,rest-envelope) (combobulate-proxy-node-extra node))) - (combobulate-move-to-node node) - (cond ((equal node current-node) - (setq expand-envelope rest-envelope - is-current-node t - pt (point))) - (t (setq expand-envelope missing))) - (pcase-let (((cl-struct combobulate-envelope-context - (start start) - (end end) - (user-actions user-actions)) - (combobulate-refactor (:id refactor-id) - (combobulate-envelope-expand-instructions-1 - ;; Normally we'd just use `(b ...)' but we - ;; want the points calculated also, if - ;; there are any in the envelope, so we - ;; can pull out the `selected-point' and - ;; use it to set `pt' later. - `((b* (repeat choice prompt point) ,@expand-envelope)))))) - (mark-range-deleted start end) - (when is-current-node - (pcase user-actions - (`((selected-point . ,selected-pt)) - (setq pt selected-pt))) - (mark-range-highlighted start end)))))) - (when pt (goto-char pt))))) + (with-slots (index current-node proxy-nodes refactor-id) action + (combobulate-refactor (:id refactor-id) + (let ((pt) + (combobulate-envelope-static t) + (combobulate-envelope--undo-on-quit nil)) + (dolist (node proxy-nodes) + (let ((expand-envelope) (is-current-node)) + (pcase-let ((`(,missing . ,rest-envelope) (combobulate-proxy-node-extra node))) + (combobulate-move-to-node node) + (cond ((equal node current-node) + (setq expand-envelope rest-envelope + is-current-node t + pt (point))) + (t (setq expand-envelope missing))) + (pcase-let (((cl-struct combobulate-envelope-context + (start start) + (end end) + (user-actions user-actions)) + (combobulate-refactor (:id refactor-id) + (combobulate-envelope-expand-instructions-1 + ;; Normally we'd just use `(b ...)' but we + ;; want the points calculated also, if + ;; there are any in the envelope, so we + ;; can pull out the `selected-point' and + ;; use it to set `pt' later. + `((b* (repeat choice prompt point) ,@expand-envelope)))))) + (mark-range-deleted start end) + (when is-current-node + (pcase user-actions + (`((selected-point . ,selected-pt)) + (setq pt selected-pt))) + (mark-range-highlighted start end)))))) + (when pt (goto-char pt)))))) (cl-defun combobulate-envelope-expand-post-run-instructions (ctx categories) "Expand the user actions in CTX according to CATEGORIES. @@ -502,6 +503,7 @@ they are given in CATEGORIES." ;; interaction :first-choice combobulate-envelope-static :signal-on-abort t + :quiet t :reset-point-on-abort nil :reset-point-on-accept nil ;; `combobulate-envelope-render-choice-preview' @@ -573,13 +575,14 @@ they are given in CATEGORIES." (save-excursion (if-let (selected-node (combobulate-proffer-choices nodes - (lambda (_index current-node _proxy-nodes refactor-id) + (lambda-slots (current-node refactor-id) (combobulate-refactor (:id refactor-id) (combobulate-move-to-node current-node))) ;; as above, if we're in static mode, we do not ;; prompt the user to pick a cursor :first-choice combobulate-envelope-static :signal-on-abort t + :quiet t :reset-point-on-abort t :reset-point-on-accept nil)) (setq selected-point (combobulate-node-start selected-node)) @@ -916,6 +919,37 @@ If REGION is non-nil, envelop the region instead of NODE." (error "Cannot apply envelope `%s'. Point must be in one of \ these nodes: `%s'." name nodes)))))) +(defun combobulate-envelope-get-shorthand-procedure (shorthand) + "Get the procedure given a SHORTHAND. + +Raise an error if the SHORTHAND is not valid." + (let ((procedure (alist-get shorthand combobulate-envelope-procedure-shorthand-alist))) + (unless procedure + (error "Shorthand `%s' is not valid." shorthand)) + procedure)) + +(defun combobulate-envelope-get-applicable-nodes (envelope &optional force) + "Given an ENVELOPE, return a list of valid nodes to apply it to. + +The NODES are the nodes that the envelope can be applied to. The +NODES must be a list of strings or procedures. If a string, it is +the name of a node type. If a procedure, then it follows the +procedural rules laid out in `combobulate-procedure-apply'." + (map-let (:nodes :shorthand) envelope + ;; only nodes or shorthand can be used in the same envelope, never both. + (if (and nodes shorthand) + (error "Envelope `%s' has both `:nodes' and `:shorthand' defined. \ +Only one can be used." envelope)) + (let* ((string-elements (seq-filter #'stringp nodes)) + (procedure-elements + (append (seq-filter #'listp nodes) + (and shorthand (combobulate-envelope-get-shorthand-procedure shorthand))))) + (mapcar #'combobulate-procedure-result-action-node + (append + (and procedure-elements (combobulate-procedure-start (point) procedure-elements t)) + ;; As we have no selectors nor a parent discriminator, we just use the action node. + (combobulate-procedure-start (point) `((:activation-nodes ((:nodes ,string-elements)))) t)))))) + (defun combobulate-execute-envelope (envelope-name &optional node force) "Executes any envelope with a `:name' equal to ENVELOPE-NAME. @@ -934,7 +968,14 @@ See `combobulate-apply-envelope' for more information." (when-let (target-pt (cdr (combobulate-apply-envelope envelope node))) (goto-char target-pt)) (let ((combobulate-envelope-static t) - (envelope-nodes (plist-get envelope :nodes))) + (envelope-nodes + (if (or (plist-member envelope :nodes) (plist-member envelope :shorthand)) + (combobulate-envelope-get-applicable-nodes envelope force) + ;; if we don't have any assigned envelope nodes, + ;; create a proxy node at point; that node (and + ;; thus `point') will instead be where the + ;; envelope is inserted. + (list (combobulate-make-proxy-point-node))))) (progn (setq chosen-node (combobulate-proffer-choices @@ -949,19 +990,8 @@ See `combobulate-apply-envelope' for more information." (combobulate-node-larger-than-node-p a b) (> (- (combobulate-node-start a) (point)) (- (combobulate-node-start b) (point))))) - ;; if we don't have any assigned envelope nodes, - ;; create a proxy node at point; that node (and - ;; thus `point') will instead be where the - ;; envelope is inserted. - (if envelope-nodes - (seq-filter (lambda (n) - (and (or force (combobulate-point-near-node n)) - (member (combobulate-node-type n) - envelope-nodes))) - (cons (combobulate-node-at-point) - (combobulate-get-parents (combobulate-node-at-point)))) - (list (combobulate-make-proxy-point-node)))) - (lambda (_index current-node _proxy-nodes refactor-id) + (reverse envelope-nodes)) + (lambda-slots (current-node refactor-id) (combobulate-refactor (:id refactor-id) (let ((ov (mark-node-highlighted current-node)) (combobulate-envelope--undo-on-quit nil)) diff --git a/combobulate-interface.el b/combobulate-interface.el index e5ecff4..c2a9ca5 100644 --- a/combobulate-interface.el +++ b/combobulate-interface.el @@ -178,7 +178,7 @@ kept." proxies (car-safe proxies)))) -(defun combobulate-make-proxy-from-region (beg end) +(defun combobulate-make-proxy-from-range (beg end) "Factory that creates a facsimile proxy node of the region BEG END." (make-combobulate-proxy-node :start (set-marker (make-marker) beg) diff --git a/combobulate-js-ts.el b/combobulate-js-ts.el index 9e33a07..33112fe 100644 --- a/combobulate-js-ts.el +++ b/combobulate-js-ts.el @@ -143,6 +143,14 @@ from `combobulate-manipulation-envelopes') to insert." "string_fragment" "number")) ;; NOTE This is subject to change + (setq combobulate-envelope-procedure-shorthand-alist + '((valid-jsx-expression + . ((:activation-nodes + ((:nodes + (exclude ("jsx_element" "jsx_text" "jsx_self_closing_element" + "jsx_fragment" "jsx_attribute" (rule "jsx_attribute")) + "jsx_expression") + :has-parent (irule "jsx_expression")))))))) (setq combobulate-manipulation-envelopes `((:description "const [...] = useState(...)" @@ -219,14 +227,14 @@ from `combobulate-manipulation-envelopes') to insert." (:description "{ ... }" :key "e" - :nodes ("jsx_element" "jsx_text" "jsx_self_closing_element" "jsx_fragment" "string") + :shorthand valid-jsx-expression :name "expression" :mark-node t :template ("{" r "}")) (:description "{/* ... */}" :key ";" - :nodes ("jsx_element" "jsx_self_closing_element" "jsx_fragment") + :shorthand valid-jsx-expression :name "comment" :mark-node t :template ("{/*" r "*/}")) @@ -234,7 +242,7 @@ from `combobulate-manipulation-envelopes') to insert." "{... ? ... : ...}" :key "?" :mark-node t - :nodes ("jsx_element" "jsx_text" "jsx_self_closing_element" "jsx_fragment") + :shorthand valid-jsx-expression :name "ternary" :template ("{" @ "null" > n> " ? " @ > (choice* :name "consequence" :missing ("null" >) :rest (r>)) @@ -414,12 +422,14 @@ from `combobulate-manipulation-envelopes') to insert." ;; for jsx (:activation-nodes ((:nodes - ;; attributes can only appear in particular JSX elements, - ;; so we need a distinct rule for them. - ("jsx_attribute") + ;; attributes can only appear in particular JSX elements + ;; (namely opening and self-closing elements), so we need + ;; a distinct rule for them. + (rule "jsx_opening_element") :has-parent ("jsx_opening_element" "jsx_self_closing_element"))) - :selector (:match-children (:match-rules ("jsx_attribute")))) + ;; but do exclude identifier as that'd match the tag name! + :selector (:match-children (:match-rules (exclude (rule "jsx_opening_element") "identifier")))) (:activation-nodes ((:nodes ((exclude ((rule "jsx_element")) ("jsx_closing_element" "jsx_opening_element"))) @@ -443,17 +453,33 @@ from `combobulate-manipulation-envelopes') to insert." (setq combobulate-display-ignored-node-types '("jsx_opening_element")) (setq combobulate-navigation-parent-child-procedures - `((:activation-nodes + `(;; general navigation into and out of blocks. + (:activation-nodes ((:nodes - ((exclude - (all) - ;; disallow navigating to jsx element production rules from - ;; this procedure, as it is handled below. - (rule "jsx_element"))) - ;; Any parent but opening/closing elements as there's a - ;; more specific rule below for that. - :has-parent ((exclude (all) "jsx_opening_element" "jsx_self_closing_element")))) + ("arrow_function" "function_declaration" "class_declaration") :position at)) + :selector (:choose node :match-children + (:match-rules (rule "arrow_function" :body)))) + ;; this is here to general statements, like if, while, + ;; etc. including one-armed if statements and those without + ;; blocks. + (:activation-nodes + ((:nodes + ("statement_block") + :position at)) :selector (:choose node :match-children t)) + ;; this handles the case where point is at the { ... } block + ;; and it ensures it navigates into the first child. + (:activation-nodes + ((:nodes + ((rule "statement")) + :position at)) + ;; prefer statement_blocks to expressions + :selector (:choose node :match-children (:match-rules ("statement_block")))) + (:activation-nodes + ((:nodes + ((rule "statement")) + :position at)) + :selector (:choose node :match-children (:match-rules (rule "expression")))) ;; allow seamless navigation between jsx elements (:activation-nodes ((:nodes ("jsx_fragment" "jsx_element" "jsx_expression") @@ -480,7 +506,19 @@ from `combobulate-manipulation-envelopes') to insert." ;; jsx element navigation. :position in)) :selector - (:choose node :match-children t)))) + (:choose node :match-children t)) + (:activation-nodes + ((:nodes + ((exclude + (all) + ;; disallow navigating to jsx element production rules from + ;; this procedure, as it is handled below. + (rule "jsx_element") + "formal_parameters")) + ;; Any parent but opening/closing elements as there's a + ;; more specific rule below for that. + :has-parent ((exclude (all) "jsx_opening_element" "jsx_self_closing_element")))) + :selector (:choose node :match-children t)))) (setq combobulate-navigation-logical-procedures '((:activation-nodes ((:nodes (all))))))) diff --git a/combobulate-manipulation.el b/combobulate-manipulation.el index 808f388..ee4dd5c 100644 --- a/combobulate-manipulation.el +++ b/combobulate-manipulation.el @@ -173,7 +173,7 @@ (update-field (tag text) (seq-filter (lambda (ov) (let ((actions (overlay-get ov 'combobulate-refactor-action))) - (combobulate--refactor-update-field ov tag text))) + (combobulate--refactor-update-field ov tag text))) (alist-get ,--session combobulate-refactor--active-sessions))) (mark-point (&optional pt) (add-marker (combobulate--refactor-mark-position (or pt (point))))) @@ -213,9 +213,9 @@ first; followed by the node type of each grouped label." (if (and (consp nodes) (consp (car nodes))) (mapconcat (lambda (g) (pcase-let ((`(,label . ,rest) g)) - (let ((string-label (symbol-name label))) - (concat (if skip-label "" (concat (capitalize (string-trim-left string-label "@")) " ")) - (combobulate-tally-nodes (mapcar 'cdr rest)))))) + (let ((string-label (symbol-name label))) + (concat (if skip-label "" (concat (capitalize (string-trim-left string-label "@")) " ")) + (combobulate-tally-nodes (mapcar 'cdr rest)))))) (combobulate-group-nodes nodes #'car) ". ") (string-join (mapcar (lambda (group) (concat @@ -341,7 +341,7 @@ a match." (let* ((chosen-node (combobulate-proxy-to-tree-node (combobulate-proffer-choices (reverse (mapcar 'car grouped-matches)) - (lambda (_index current-node _proxy-nodes refactor-id) + (lambda-slots (current-node refactor-id) (combobulate-refactor (:id refactor-id) (rollback) (mark-node-highlighted current-node) @@ -398,7 +398,7 @@ The action can be one of the following: (pcase-let (((cl-struct combobulate-procedure-result (selected-nodes selected-nodes) (parent-node parent-node)) - (or (combobulate-procedure-start node) + (or (car-safe (combobulate-procedure-start node)) (error "No cluster to edit.")))) (combobulate--mc-edit-nodes ;; Remove `@discard' matches. @@ -407,7 +407,7 @@ The action can be one of the following: ;; return tags with `@', but Combobulate query ;; search does. (lambda (m) (or (equal (car m) '@discard) - (equal (car m) 'discard))) + (equal (car m) 'discard))) selected-nodes)) action parent-node))) @@ -873,19 +873,47 @@ the current choice and exit." "C-l" 'recenter "M-c" 'recursive-edit) -(cl-defun combobulate-proffer-action-highlighter (_index current-node _proxy-nodes refactor-id) - "Helper for `combobulate-proffer-choices' that highlights NODE." - (combobulate-refactor (:id refactor-id) - (mark-node-highlighted current-node))) - -(cl-defun combobulate-proffer-choices (nodes action-fn &key (first-choice nil) +(cl-defun combobulate-proffer-action-highlighter (slots) + "Helper for `combobulate-proffer-choices' that highlights the current node." + (with-slots (index current-node proxy-nodes refactor-id) slots + (combobulate-refactor (:id refactor-id) + (mark-node-highlighted current-node)))) + +;; cl-defstruct to hold all the various prompt display values +(cl-defstruct (combobulate-proffer-action + (:constructor combobulate-proffer-action-create) + (:copier nil)) + index + display-indicator + current-node + proxy-nodes + refactor-id + prompt-description + extra-map) + +(defmacro lambda-slots (slots &rest body) + "Construct a macro that expands to a lambda with the given SLOTS and BODY. + +The SLOTS are bound to the action object using `with-slots'." + (declare (indent defun) + (debug (&define [&or symbolp (symbolp &optional sexp &rest sexp)] + def-body))) + `(lambda (action) + (with-slots ,slots action + ,@body))) + +(cl-defun combobulate-proffer-choices (nodes action-fn &key + (first-choice nil) (reset-point-on-abort t) (reset-point-on-accept nil) (prompt-description nil) (extra-map nil) (flash-node nil) + (quiet nil) (accept-action 'rollback) (cancel-action 'commit) (switch-action 'rollback) + (execute-action-on-accept nil) + (recenter t) (allow-numeric-selection nil) (signal-on-abort nil) (start-index 0) @@ -963,7 +991,18 @@ the user aborts the choice. The following symbols are supported: `:start-index' is an integer that determines the starting index of the node in the list of nodes. This is useful when you want to -skip over the first few nodes in the list." +skip over the first few nodes in the list. + +`:recenter' is a boolean that determines whether to recenter the +buffer when the user switches to a different node. + +`:quiet' is a boolean that determines whether to suppress the +status message when the user switches to a different node, +accepts or cancels the proffer. + +`:execute-action-on-accept' is a boolean that determines whether +to execute the action function on the node when the user accepts +the choice." (setq allow-numeric-selection ;; numeric selection uses `C-1' through to `C-9' which cannot ;; always be typed on a terminal. @@ -988,127 +1027,144 @@ skip over the first few nodes in the list." (index start-index) (pt (point)) (raw-event) (refactor-id (combobulate-refactor-setup)) (change-group) + (prompt) (map (let ((map (make-sparse-keymap))) (set-keymap-parent map combobulate-proffer-map) + ;; do ont bind the same key twice; this could override + ;; important keys like RET. + (unless (lookup-key map (this-command-keys)) + (define-key map (this-command-keys) 'next)) (when extra-map - (define-key map (this-command-keys) 'next) (mapc (lambda (k) (define-key map (car k) (cdr k))) extra-map)) (when allow-numeric-selection (dotimes (i 9) (define-key map (kbd (format "C-%d" (1+ i))) (1+ i)))) map))) - (if proxy-nodes - (progn - (cl-assert (< start-index (length proxy-nodes)) nil - "Start index %d is greater than the number of nodes %d" - start-index (length proxy-nodes)) - (condition-case err - (with-undo-amalgamate - (catch 'exit - (while (eq state 'continue) - (unless change-group - (setq change-group (prepare-change-group))) - (catch 'next - (setq current-node (nth index proxy-nodes)) - (combobulate-refactor (:id refactor-id) - (cl-flet ((refactor-action (action) - (cond ((eq action 'commit) - (commit)) - ((eq action 'rollback) - (rollback)) - (t (error "Unknown action: %s" action))))) - (and before-switch-fn (funcall before-switch-fn)) - (funcall action-fn index current-node proxy-nodes refactor-id) - ;; if we have just one item, or if - ;; `:first-choice' is non-nil, we pick the first - ;; item in `proxy-nodes' - (if (or (= (length proxy-nodes) 1) first-choice) - (progn (refactor-action accept-action) - (setq state 'accept)) - (setq result - (condition-case nil - (lookup-key - map - ;; we need to preserve the raw - ;; event so we can put it back on - ;; the unread event loop later if - ;; the key is not recognised. - (setq raw-event - (read-key-sequence-vector - (substitute-command-keys - (format "%s %s`%s': `%s' or \\`S-TAB' to cycle%s; \\`C-g' quits; rest accepts.%s" - (combobulate-display-indicator index (length proxy-nodes)) - (concat (or prompt-description "") - (and prompt-description (propertize " → " 'face 'shadow))) - (propertize (combobulate-pretty-print-node current-node) 'face - 'combobulate-tree-highlighted-node-face) - (mapconcat (lambda (k) - (propertize (key-description k) 'face 'help-key-binding)) - ;; messy; is this really the best way? - (where-is-internal 'next map) - ", ") - (if allow-numeric-selection (concat "; \\`C-1' to \\`C-9' to select") "") - (if (and flash-node combobulate-flash-node) - (concat "\n" - (or (combobulate-display-draw-node-tree - (combobulate-proxy-to-tree-node current-node)) - "")) - "")))))) - ;; if `condition-case' traps a quit - ;; error, then map it into the symbol - ;; `cancel', which corresponds to the - ;; equivalent event in the state - ;; machine below. - (quit 'cancel) - (t (rollback) 'cancel))) - (and after-switch-fn (funcall after-switch-fn)) - (pcase result - ('prev - (refactor-action switch-action) - (setq index (mod (1- index) (length proxy-nodes))) - (throw 'next nil)) - ('next - (refactor-action switch-action) - (setq index (mod (1+ index) (length proxy-nodes))) - (throw 'next nil)) - ('done - (refactor-action accept-action) - (combobulate-message "Committing" current-node) - (setq state 'accept)) - ((pred functionp) - (funcall result) - (refactor-action accept-action) - (throw 'next nil)) - ('cancel - (combobulate-message "Cancelling...") - (setq state 'abort) - (refactor-action cancel-action) - (keyboard-quit)) - ;; handle numeric selection `1' to `9' - ((and (pred (numberp)) (pred (lambda (n) (and (>= n 1) - (<= n 9) - (<= n (length proxy-nodes))))) - n) - (refactor-action switch-action) - (setq index (1- n)) - (throw 'next nil)) - (_ - (combobulate-message "Committing...") - ;; pushing `raw-event' to - ;; `unread-command-events' allows for a - ;; seamless exit out of the proffer - ;; prompt by preserving the the last, - ;; unhandled event the user inputted. - (when (length> raw-event 0) - (push (aref raw-event 0) unread-command-events)) - (refactor-action accept-action) - (setq state 'accept))))))) - (when change-group - (cancel-change-group change-group)) - (activate-change-group change-group)))) - (quit (when signal-on-abort - (signal (car err) (cdr err)))))) - (error "There are no choices to make")) + (unless proxy-nodes (error "There are no choices to make")) + (cl-assert (< start-index (length proxy-nodes)) nil + "Start index %d is greater than the number of nodes %d" + start-index (length proxy-nodes)) + (condition-case err + (with-undo-amalgamate + (catch 'exit + (while (eq state 'continue) + (unless change-group + (setq change-group (prepare-change-group))) + (catch 'next + (setq current-node (nth index proxy-nodes)) + (combobulate-refactor (:id refactor-id) + (let ((proffer-action + (combobulate-proffer-action-create + :index index + :current-node current-node + :proxy-nodes proxy-nodes + :refactor-id refactor-id + :prompt-description + (or prompt-description "") + :extra-map extra-map + :display-indicator (combobulate-display-indicator index (length proxy-nodes))))) + (funcall action-fn proffer-action) + (with-slots (display-indicator prompt-description) proffer-action + (setq prompt + (substitute-command-keys + (format "%s %s`%s': `%s' or \\`S-TAB' to cycle%s; \\`C-g' quits; rest accepts.%s" + display-indicator + (concat prompt-description " ") + ;; (propertize " → " 'face 'shadow) + (propertize (combobulate-pretty-print-node current-node) 'face + 'combobulate-tree-highlighted-node-face) + (mapconcat (lambda (k) + (propertize (key-description k) 'face 'help-key-binding)) + ;; messy; is this really the best way? + (where-is-internal 'next map) + ", ") + (if allow-numeric-selection (concat "; \\`C-1' to \\`C-9' to select") "") + (if (and flash-node combobulate-flash-node) + (concat "\n" + (or (combobulate-display-draw-node-tree + (combobulate-proxy-to-tree-node current-node)) + "")) + ""))))) + (cl-flet ((refactor-action (action) + (cond ((eq action 'commit) + (when execute-action-on-accept + (funcall action-fn proffer-action)) + (commit)) + ((eq action 'rollback) + (rollback)) + (t (error "Unknown action: %s" action))))) + (and before-switch-fn (funcall before-switch-fn)) + (recenter) + ;; if we have just one item, or if + ;; `:first-choice' is non-nil, we pick the first + ;; item in `proxy-nodes' + (if (or (= (length proxy-nodes) 1) first-choice) + (progn (refactor-action accept-action) + (setq state 'accept)) + (setq result + (condition-case nil + (lookup-key + map + ;; we need to preserve the raw + ;; event so we can put it back on + ;; the unread event loop later if + ;; the key is not recognised. + (setq raw-event + (read-key-sequence-vector prompt))) + ;; if `condition-case' traps a quit + ;; error, then map it into the symbol + ;; `cancel', which corresponds to the + ;; equivalent event in the state + ;; machine below. + (quit 'cancel) + (t (rollback) 'cancel))) + (and after-switch-fn (funcall after-switch-fn)) + (pcase result + ('prev + (refactor-action switch-action) + (setq index (mod (1- index) (length proxy-nodes))) + (throw 'next nil)) + ('next + (refactor-action switch-action) + (setq index (mod (1+ index) (length proxy-nodes))) + (throw 'next nil)) + ('done + (refactor-action accept-action) + (unless quiet (combobulate-message "Committing" current-node)) + (setq state 'accept)) + ((pred functionp) + (funcall result) + (refactor-action accept-action) + (throw 'next nil)) + ('cancel + (unless quiet (combobulate-message "Cancelling...")) + (setq state 'abort) + (refactor-action cancel-action) + (keyboard-quit)) + ;; handle numeric selection `1' to `9' + ((and (pred (numberp)) (pred (lambda (n) (and (>= n 1) + (<= n 9) + (<= n (length proxy-nodes))))) + n) + (refactor-action switch-action) + (setq index (1- n)) + (throw 'next nil)) + (_ + (unless quiet (combobulate-message "Committing...")) + ;; pushing `raw-event' to + ;; `unread-command-events' allows for a + ;; seamless exit out of the proffer + ;; prompt by preserving the the last, + ;; unhandled event the user inputted. + (when (length> raw-event 0) + (push (aref raw-event 0) unread-command-events)) + (refactor-action accept-action) + (setq state 'accept))))))) + (when change-group + (cancel-change-group change-group))) + (activate-change-group change-group)))) + (quit (when signal-on-abort + (signal (car err) (cdr err))))) ;; Determine where point is placed on exit and whether we return ;; the current node or not. (cond @@ -1127,8 +1183,9 @@ skip over the first few nodes in the list." (with-argument-repetition arg (with-navigation-nodes (:procedures combobulate-navigation-sibling-procedures) (when-let ((node (combobulate-proffer-choices - (seq-sort #'combobulate-node-larger-than-node-p (combobulate--get-all-navigable-nodes-at-point)) - (lambda (_index current-node _proxy-nodes refactor-id) + (seq-sort #'combobulate-node-larger-than-node-p + (combobulate--get-all-navigable-nodes-at-point)) + (lambda-slots (current-node refactor-id) (combobulate-refactor (:id refactor-id) (mark-node-deleted current-node) (mark-node-highlighted current-node) @@ -1207,7 +1264,7 @@ more than one." nodes)))) (combobulate-proffer-choices (seq-drop-while #'combobulate-node-in-region-p nodes) - (lambda (index current-node proxy-nodes refactor-id) + (lambda-slots (index current-node proxy-nodes refactor-id) (combobulate-refactor (:id refactor-id) ;; highlight the current node so the user can see the ;; extent of the region. @@ -1224,7 +1281,7 @@ more than one." (mark-range-label (combobulate-node-start idx-node) (1+ (combobulate-node-start idx-node)) - (int-to-string (1+ i)))))))) + (int-to-string (1+ i)) nil t)))))) ;; this feature only works properly on displays that support ;; ctrl- keys. :allow-numeric-selection (display-graphic-p) @@ -1260,7 +1317,7 @@ defun is. Repeat calls expands the scope." (exchange-point-and-mark)) (combobulate-navigate-end-of-defun)))))) -(defun combobulate--partition-by-position (self-node query-nodes) +(defun combobulate--partition-by-position (self-node query-nodes ) "Given QUERY-NODES group them relative to SELF-NODE" (mapcar (lambda (query-node) (let ((node query-node)) @@ -1279,13 +1336,13 @@ defun is. Repeat calls expands the scope." (defun combobulate-splice-up (&optional arg) (interactive "^p") (with-argument-repetition arg - (with-navigation-nodes (:procedures combobulate-manipulation-splicing-procedures) + (with-navigation-nodes (:procedures combobulate-navigation-sibling-procedures) (combobulate-splice (combobulate--get-nearest-navigable-node) '(self after around))))) (defun combobulate-splice-down (&optional arg) (interactive "^p") (with-argument-repetition arg - (with-navigation-nodes (:procedures combobulate-manipulation-splicing-procedures) + (with-navigation-nodes (:procedures combobulate-navigation-sibling-procedures) (combobulate-splice (combobulate--get-nearest-navigable-node) '(self before around))))) (defvar combobulate-refactor--copied-values nil) @@ -1302,33 +1359,109 @@ Each member of PARTITIONS must be one of: `after', to preserve things after the POINT-NODE; `around' to preserve nodes larger than POINT-NODE; `self' to preserve POINT-NODE." - (let* ((procedure (combobulate-procedure-result-selected-nodes - (combobulate-procedure-start point-node))) + (let* ((combobulate-procedure-include-anonymous-nodes t) + (combobulate-procedure-discard-rules) + (procedure (or (car-safe (combobulate-procedure-start point-node)) + (error "No procedure found for %s" point-node))) (baseline-target nil) (tally) - (matches (or matches (cdr procedure)))) - (combobulate-refactor () - (pcase-dolist (`(,action . ,node) matches) - (pcase action - ('@discard - (mark-node-deleted node) - (setq baseline-target (combobulate-baseline-indentation node)) - (push (cons action node) tally)) - ('@keep - (pcase-dolist (`(,position . ,part-node) - (combobulate--partition-by-position point-node (list node))) - (when (member position partitions) - (push (cons action node) tally) - (pcase-let ((`(,start ,end) (combobulate-extend-region-to-whole-lines - (combobulate-node-start part-node) - (combobulate-node-end part-node)))) - (mark-copy start end) - (mark-range-indent start end - baseline-target - (combobulate-baseline-indentation part-node)))))))) - (combobulate-message "Spliced." (combobulate-tally-nodes tally nil)) - (commit)) - (combobulate--refactor-insert-copied-values combobulate-refactor--copied-values))) + (action-node (combobulate-procedure-result-action-node procedure)) + (pt-type) + (pt-marker) + (disable-check nil) + (matches (or matches (combobulate-procedure-result-selected-nodes procedure))) + (source-node) + (all-parents) (valid-parents)) + (unless (combobulate-point-at-node-p action-node) + (setq action-node + (car (reverse (save-excursion + (combobulate-move-to-node point-node) + (combobulate-all-nodes-at-point)))) + disable-check t) + (setq matches (list (cons '@match action-node)) + point-node action-node)) + (setq pt-type (combobulate-node-type action-node)) + (setq all-parents (combobulate-get-parents point-node)) + (setq valid-parents (seq-filter (lambda (node) + (member pt-type + (combobulate-production-rules-get + (combobulate-node-type node)))) + all-parents)) + (unless (and matches valid-parents) + (error "Cannot splice from `%s'." point-node)) + (seq-let [start &rest end] + ;; Get the node range extent of the filtered, partitioned + ;; nodes. This does mean that we cannot pick things that are + ;; disjoint, however. + (combobulate-node-range-extent + (seq-keep + ;; the only partitions we keep are the ones that are in + ;; PARTITIONS + (pcase-lambda (`(,partition ., node)) + (and (member partition partitions) node)) + (combobulate--partition-by-position + action-node + (seq-keep + ;; Only match nodes that are named are kept. + (pcase-lambda (`(,mark . ,node)) + (and (eq mark '@match) + (combobulate-node-named-p node) + ;; return node if it's a match and named + node)) + matches)))) + (setq source-node (combobulate-make-proxy-from-range start end)) + (setf (combobulate-proxy-node-text source-node) + (combobulate-indent-string-first-line + (combobulate-node-text source-node) + (current-column))) + (setq tally (seq-filter + (lambda (n) (or disable-check + (and (combobulate-node-parent n) + (member (combobulate-node-parent n) + valid-parents) + (not (equal (combobulate-node-parent n) + (car valid-parents))) + (combobulate-node-before-node-p n source-node)))) + all-parents)) + (setq pt-marker (combobulate-node-start action-node)) + (cl-flet ((action-function + (action) + (with-slots (current-node refactor-id index proxy-nodes) action + (combobulate-refactor (:id refactor-id) + (combobulate-move-to-node current-node) + (mark-node-deleted current-node) + (commit) + ;; use an envelope to ensure indentation is handled + ;; properly. quicker and easier than reinventing it + ;; again here. + (seq-let [[start &rest end] &rest _] + (combobulate-envelope-expand-instructions + '((r> text)) `((text . ,(combobulate-proxy-node-text source-node)))) + (goto-char start) + (mark-range-highlighted start end)) + ;; Test if there's an error node as a result of + ;; our changes. + (when-let (err (combobulate-get-error-nodes)) + (setf (combobulate-proffer-action-display-indicator action) + (combobulate-display-indicator + index (length proxy-nodes) + 'combobulate-error-indicator-face nil "E") + (combobulate-proffer-action-prompt-description action) + (propertize "Invalid" 'face 'combobulate-error-indicator-face))) + ;; if we merge stuff into a line that is not blank, + ;; then elide all but one space and, if there weren't + ;; any, add one. + (unless (combobulate-before-point-blank-p (point)) + (just-one-space)))))) + (when-let (target-node (combobulate-proffer-choices + tally + (lambda (action) + (action-function action)) + :flash-node t + :quiet t)) + (combobulate-refactor (:id 'splice) + (action-function target-node 'splice) + (rollback))))))) (defun combobulate-move-past-close-and-reindent (&optional arg) (interactive "^p") @@ -1582,11 +1715,12 @@ beginning of the line." If BEFORE is non-nil, then the label is placed (using the special `before' overlay property) before the region." + (setq face (or face 'combobulate-refactor-label-face)) (let ((ov (make-overlay beg end nil nil nil))) (overlay-put ov 'combobulate-refactor-actions '((labelled))) - (overlay-put ov 'face (or face 'combobulate-refactor-label-face)) (if before - (overlay-put ov 'before-string label) + (overlay-put ov 'before-string (propertize label 'face face)) + (overlay-put ov 'face face) (overlay-put ov 'display label)) ov)) diff --git a/combobulate-misc.el b/combobulate-misc.el index 3eb7c9d..9bd9374 100644 --- a/combobulate-misc.el +++ b/combobulate-misc.el @@ -103,7 +103,7 @@ No effort is made to account for, or exclude, overlaps." (defsubst combobulate-debug (s &rest args) (princ (apply #'format (concat s "\n") args))) -(defun combobulate-display-indicator (current-level total) +(defun combobulate-display-indicator (current-level total &optional active-face dimmed-face active-indicator dimmed-indicator) "Indicate CURRENT-LEVEL within a TOTAL number of pips." (concat "(" @@ -111,11 +111,12 @@ No effort is made to account for, or exclude, overlaps." (lambda (level) (let ((current (= level current-level))) (propertize (if current - (substring combobulate-proffer-indicators 1 2) - (substring combobulate-proffer-indicators 0 1)) - 'face (if current - 'combobulate-active-indicator-face - 'combobulate-dimmed-indicator-face)))) + (or active-indicator (substring combobulate-proffer-indicators 1 2)) + (or dimmed-indicator (substring combobulate-proffer-indicators 0 1))) + 'face + (cond + (current (or active-face 'combobulate-active-indicator-face)) + (t (or dimmed-face 'combobulate-dimmed-indicator-face)))))) (number-sequence 0 (1- total)) " ") ")")) diff --git a/combobulate-navigation.el b/combobulate-navigation.el index 579916d..3dfca5c 100644 --- a/combobulate-navigation.el +++ b/combobulate-navigation.el @@ -203,7 +203,7 @@ Uses `point' and `mark' to infer the boundaries." If NODE-ONLY is non-nil then only the node texts are returned" (mapcar (lambda (node) (if node-only (combobulate-node-text node) - (combobulate-node-text (cdr node)))) + (combobulate-node-text (cdr node)))) (combobulate-query-search node query t t))) (defun combobulate-linear-siblings (node &optional anonymous) @@ -473,14 +473,19 @@ extent." (let ((smallest most-positive-fixnum) (largest most-negative-fixnum)) (mapc (lambda (c) - (pcase-let ((`(,start . ,end) (combobulate-node-range c))) - (when (< start smallest) - (setq smallest start)) - (when (> end largest) - (setq largest end)))) + (and c (pcase-let ((`(,start . ,end) (combobulate-node-range c))) + (when (< start smallest) + (setq smallest start)) + (when (> end largest) + (setq largest end))))) nodes) (cons smallest largest))) + +(defun combobulate-get-error-nodes (&optional node) + "Return all nodes in NODES that are of type 'error." + (combobulate-query-capture (or node (combobulate-root-node)) '((ERROR) @node) nil nil t)) + (defun combobulate-filter-nodes-by-type (nodes unwanted-node-types) "Filter NODES of UNWANTED-NODE-TYPES." (while (and unwanted-node-types nodes) @@ -697,8 +702,7 @@ of the node." (defun combobulate-nav-get-siblings (node) "Return all navigable siblings of NODE." - (combobulate-procedure-result-matched-nodes - (combobulate-procedure-start node))) + (combobulate-procedure-start-matches node)) (defun combobulate--get-sibling (node direction) "Returns the sibling node of NODE in the specified DIRECTION. @@ -1091,14 +1095,13 @@ DIRECTION must be `forward' or `backward'." (combobulate-visual-move-to-node (combobulate--navigate-up)))) (defun combobulate--navigate-down () - (with-navigation-nodes (:skip-prefix t :procedures combobulate-navigation-parent-child-procedures) + (with-navigation-nodes (:skip-prefix nil :procedures combobulate-navigation-parent-child-procedures) (or ;; try to find a procedure that can take us to a valid child node ;; (that starts after point) (car (seq-filter #'combobulate-node-after-point-p - (when-let ((proc (combobulate-procedure-start (combobulate--get-nearest-navigable-node)))) - (combobulate-procedure-result-matched-nodes proc)))) + (combobulate-procedure-start-matches (combobulate--get-nearest-navigable-node)))) ;; ... and if that fails, jump into the first list-like structure ;; ahead of point. ;; diff --git a/combobulate-procedure.el b/combobulate-procedure.el index 7a6e313..fdb5a8c 100644 --- a/combobulate-procedure.el +++ b/combobulate-procedure.el @@ -151,49 +151,85 @@ name and the cdr is the node. The tagged name should be (t (error "Unknown tagged name `%s'" tagged-name)))) (reverse matches))) -(defun combobulate-procedure-start (pt-or-node &optional procedures) - "Attempt to find a procedure at PT-OR-NODE." - (catch 'done - (dolist (node (append - ;; start by getting all the nodes *at* point: - ;; meaning, nodes beginning at point. They should - ;; be our first port of call in terms of matching, - ;; as they are the most specific. - (save-excursion - (goto-char (if (numberp pt-or-node) - pt-or-node - (combobulate-node-start pt-or-node))) - (combobulate-all-nodes-at-point)) - ;; then, get all the nodes point is in. - (combobulate-get-parents (combobulate-node-at-point)))) - (when-let (procedure-result - (combobulate-procedure-try - ;; if we haven't been given any procedures, use the default - ;; procedures. - (or procedures - combobulate-default-procedures - (error "No procedures given and no default procedures found")) - node)) - (throw 'done procedure-result))))) - -(defun combobulate-procedure-try (procedures node) - "Try to apply PROCEDURES, in order, to NODE. - -Return the first matching procedure, or nil if none match." - (catch 'done - (let ((matching-procedure)) - (dolist (procedure procedures) - (setq matching-procedure (combobulate-procedure-apply procedure node)) - (pcase matching-procedure - ('nil nil) - ((cl-struct combobulate-procedure-result - matched-selection - selected-nodes) - (when (or (eq matched-selection 'n/a) - (and (eq matched-selection t) - selected-nodes)) - (throw 'done matching-procedure))) - (_ (error "Unknown procedure result `%s'" matching-procedure))))))) +(defun combobulate-procedure-start-matches (pt-or-node &optional procedures) + "Return nodes that match a procedure at PT-OR-NODE. + +If PROCEDURES is not given, use `combobulate-default-procedures' +instead. + +Unlike `combobulate-procedure-start', this function returns the +the struct entry `matched-nodes' of the matching procedure, if it +exists, and nil if not." + (when-let (procedure (car-safe (combobulate-procedure-start pt-or-node procedures))) + (cl-assert (combobulate-procedure-result-p procedure) t + "Expected a `combobulate-procedure-result' object, but got `%s'" + procedure) + (combobulate-procedure-result-matched-nodes procedure))) + +(defun combobulate-procedure-start (pt-or-node &optional procedures exhaustive) + "Attempt to find a procedure at PT-OR-NODE. + +If PROCEDURES is not given, use `combobulate-default-procedures'. +If EXHAUSTIVE is non-nil, then collect all possible procedures +that may apply." + (let ((matches) + (nodes + (seq-uniq + (append + ;; start by getting all the nodes *at* point: + ;; meaning, nodes beginning at point. They should + ;; be our first port of call in terms of matching, + ;; as they are the most specific. + (save-excursion + (goto-char (if (numberp pt-or-node) + pt-or-node + (combobulate-node-start pt-or-node))) + (cons (if (combobulate-node-p pt-or-node) + pt-or-node + (combobulate-node-at-point)) + (combobulate-all-nodes-at-point))) + ;; then, get all the nodes point is in. + (combobulate-get-parents (combobulate-node-at-point)))))) + (catch 'done + (dolist (procedure + (or procedures + ;; if we haven't been given any procedures, use the default + ;; procedures. + combobulate-default-procedures + (error "No procedures given and no default procedures found"))) + (dolist (node nodes) + (when-let (procedure-result + (combobulate-procedure-try + procedure + node)) + (push procedure-result matches) + (unless exhaustive (throw 'done procedure-result)))))) + matches)) + +(defun combobulate-procedure-try (procedure node) + "Apply PROCEDURE to NODE and return the result, if any." + (let ((procedure-result)) + (setq procedure-result (combobulate-procedure-apply procedure node)) + (pcase procedure-result + ('nil nil) + ((cl-struct combobulate-procedure-result + matched-selection + selected-nodes) + ;; We define a successful result as one of the following: + ;; + ;; Either the matched selection is `n/a', indicating that there + ;; were no `:selector' properties to further refine the + ;; activated nodes. + ;; + ;; Or the matched selection is `t' *and* that there is at least + ;; one selected node with a `@match' or `match' tag. + (when (or (eq matched-selection 'n/a) + (and (eq matched-selection t) + (seq-find (pcase-lambda (`(,mark . ,_)) + (or (eq mark '@match) (eq mark 'match))) + selected-nodes))) + procedure-result)) + (_ (error "Unknown procedure result `%s'" procedure-result))))) (defun combobulate-procedure-validate (procedure) "Validate PROCEDURE." @@ -311,6 +347,9 @@ If keep-mark is non-nil, keep the mark in the result." :overwrite t :keep-anonymous t)))) +(defvar combobulate-procedure-include-anonymous-nodes nil + "Whether to include anonymous nodes in the result of a procedure.") + (defun combobulate-procedure--filter-nodes-by-relationship (selector node fn) "Filter NODES by the relationship defined by FN against NODE. @@ -329,7 +368,7 @@ anonymous nodes and return the nodes that match the relationship." (error "Cannot have both `:match-rules' and `:discard-rules' without explicitly setting `:default-mark'")) (if match-rules '@discard '@match))) - (anonymous anonymous) + (anonymous (or anonymous combobulate-procedure-include-anonymous-nodes)) (nodes (funcall fn node anonymous))) (combobulate-procedure--mark-nodes nodes @@ -338,6 +377,35 @@ without explicitly setting `:default-mark'")) :keep-anonymous anonymous :default-mark default-mark)))) +(defun combobulate-procedure-debug-print-result (procedure-result) + "Print PROCEDURE-RESULT in a human-readable format." + ;; pretty-print the cldefstruct + ;; (cl-defstruct combobulate-procedure-result + ;; "The result of a procedure." + ;; activation-node + ;; action-node + ;; parent-node + ;; selected-nodes + ;; matched-nodes + ;; (matched-activation nil) + ;; (matched-selection nil)) + (pcase procedure-result + ((cl-struct combobulate-procedure-result + (activation-node activation-node) + (action-node action-node) + (parent-node parent-node) + (selected-nodes selected-nodes) + (matched-nodes matched-nodes) + (matched-activation matched-activation) + (matched-selection matched-selection)) + (message "Activation node: %s" activation-node) + (message "Action node: %s" action-node) + (message "Parent node: %s" parent-node) + (message "Selected nodes: %s" selected-nodes) + (message "Matched nodes: %s" matched-nodes) + (message "Matched activation: %s" matched-activation) + (message "Matched selection: %s" matched-selection)))) + (defun combobulate-procedure-apply (procedure node) "Apply PROCEDURE to NODE. @@ -454,7 +522,8 @@ defaults to `combobulate'. `:discard-rules' is a list of rules :overwrite t :keep-anonymous t) ;; acknowledge that the selector filter was used - (combobulate-procedure-result-matched-selection procedure-result) t))) + (combobulate-procedure-result-matched-selection procedure-result) t)) + (message (combobulate-procedure-debug-print-result procedure-result))) ;; if there is no selector, then the action node is the selected node (setf (combobulate-procedure-result-matched-selection procedure-result) 'n/a)) ;; do a final bit of clean-up: get all the nodes marked `@match' @@ -473,19 +542,31 @@ defaults to `combobulate'. `:discard-rules' is a list of rules "Get production rules for NODE-TYPE and possibly FIELDS." (setq fields (or fields '(:all t))) (let* ((rules (cadr (assoc-string node-type (combobulate-production-rules-get-rules)))) + (supertypes (combobulate-production-rules-get-supertypes)) (all-keys (map-keys rules))) (if rules - (apply - #'append - (mapcar (lambda (prop) - (if (plist-member rules prop) - (plist-get rules prop) - (error "Rule `%s' has no field named `%s'. Known fields: `%s'" - node-type prop all-keys))) - (cond - ((null fields) '(:*unnamed*)) - ((plist-get fields :all) all-keys) - (t fields)))) + ;; some node types are supertypes, meaning they exist outside + ;; the actual parse tree TS can generate. However, the rules + ;; for these supertypes are defined in the same way as for the + ;; actual parse tree. So, we need to expand the supertypes + ;; here. + (mapcan + (lambda (n) + ;; check if n is a supertype; if it is, expand it. + (if (member n supertypes) + (combobulate-production-rules-get n) + (list n))) + (apply + #'append + (mapcar (lambda (prop) + (if (plist-member rules prop) + (plist-get rules prop) + (error "Rule `%s' has no field named `%s'. Known fields: `%s'" + node-type prop all-keys))) + (cond + ((null fields) '(:*unnamed*)) + ((plist-get fields :all) all-keys) + (t fields))))) (error "Cannot find any rules named `%s'" node-type)))) (defun combobulate-production-rules-get-inverted (rule-name &optional language) @@ -505,6 +586,10 @@ defaults to `combobulate'. `:discard-rules' is a list of rules "Return a list of the production rules in LANGUAGE." (combobulate-production-rules--get combobulate-rules-alist language)) +(defun combobulate-production-rules-get-supertypes (&optional language) + "Return a list of the supertypes in LANGUAGE." + (combobulate-production-rules--get combobulate-rules-supertypes-alist language)) + (defun combobulate-production-rules-get-inverse-rules (&optional language) "Return a list of the inverted production rules in LANGUAGE." (combobulate-production-rules--get combobulate-rules-inverse-alist language)) @@ -539,7 +624,7 @@ defaults to `combobulate'. `:discard-rules' is a list of rules (and `(rule ,rule-name) (let fields nil))) (setq collected-node-types (append collected-node-types - (apply #'combobulate-production-rules-get rule-name fields)))) + (apply #'combobulate-production-rules-get rule-name (list (ensure-list fields)))))) ;; An inverted production rule that uses the inverse ;; production rule table instead. (`(irule ,inverted-rule-name) diff --git a/combobulate-python.el b/combobulate-python.el index a7e1323..db59b96 100644 --- a/combobulate-python.el +++ b/combobulate-python.el @@ -138,12 +138,6 @@ line when you press (combobulate-move-to-node node) (back-to-indentation)) -(defun combobulate-python-proffer-indent-action (_index current-node _proxy-nodes refactor-id) - "Proffer action function that highlights the node and indents it." - (combobulate-refactor (:id refactor-id) - (mark-node-highlighted current-node) - (combobulate-proffer-indentation-1 current-node))) - (defun combobulate-proffer-indentation (node) "Intelligently indent the region or NODE at point." (interactive) @@ -162,7 +156,7 @@ line when you press ;; special proxy node that will be used to ;; indent the region. (if (use-region-p) - (combobulate-make-proxy-from-region (region-beginning) (region-end)) + (combobulate-make-proxy-from-range (region-beginning) (region-end)) ;; if we're not dealing with a region, we ;; make a proxy node for the closest node. (combobulate-make-proxy node)))) @@ -175,7 +169,10 @@ line when you press (at-last-level (= number-of-levels current-position))) (when-let (selected-node (combobulate-proffer-choices (if at-last-level (reverse indent-nodes) indent-nodes) - #'combobulate-python-proffer-indent-action + (lambda-slots (refactor-id current-node) + (combobulate-refactor (:id refactor-id) + (mark-node-highlighted current-node) + (combobulate-proffer-indentation-1 current-node))) ;; Try to pick a sensible starting index ;; based on whether we're at the end, ;; taking into account of the fact that @@ -447,7 +444,7 @@ line when you press ((rule "dictionary")) :has-parent ("dictionary")) (:nodes - ((rule "primary_expression") (rule "expression")) + ((rule "set") (rule "tuple") (rule "list")) :has-parent ("set" "tuple" "list")) (:nodes ((rule "parameter") @@ -455,7 +452,7 @@ line when you press (rule "expression") (rule "expression_list") (rule "primary_expression")) - :has-parent ("parameters" "argument_list" "expression_list"))) + :has-parent ("parameters" "lambda_parameters" "argument_list" "expression_list"))) :selector (:match-children t)) (:activation-nodes ((:nodes @@ -469,10 +466,17 @@ line when you press (setq combobulate-navigation-parent-child-procedures '(;; statements are treated with `at' so you can descend into sub-statements. (:activation-nodes - ((:nodes ((rule "_compound_statement")) + ((:nodes ((rule "_compound_statement") + ;; not in compound statement + "case_clause") :position at)) :selector (:choose node :match-children (:match-rules ("block")))) + (:activation-nodes + ((:nodes ((rule "lambda")) + :position at)) + :selector (:choose node + :match-children (:match-rules (rule "lambda" :body)))) (:activation-nodes ((:nodes ((all)) :has-parent ((all)))) :selector (:choose node diff --git a/combobulate-rules.el b/combobulate-rules.el index de84c7f..6e9ba2b 100644 --- a/combobulate-rules.el +++ b/combobulate-rules.el @@ -1,2371 +1,2511 @@ ;; START Production rules for yaml -(defconst combobulate-rules-yaml - '(("alias" (:*unnamed* ("alias_name"))) - ("anchor" (:*unnamed* ("anchor_name"))) - ("block_mapping" (:*unnamed* ("block_mapping_pair"))) - ("block_mapping_pair" (:key ("block_node" "flow_node") :value ("block_node" "flow_node"))) - ("block_node" (:*unnamed* ("anchor" "block_mapping" "block_sequence" "block_scalar" "tag"))) - ("block_sequence" (:*unnamed* ("block_sequence_item"))) - ("block_sequence_item" (:*unnamed* ("block_node" "flow_node"))) - ("document" (:*unnamed* ("block_node" "flow_node" "tag_directive" "reserved_directive" "yaml_directive"))) - ("double_quote_scalar" (:*unnamed* ("escape_sequence"))) - ("flow_mapping" (:*unnamed* ("flow_pair" "flow_node"))) - ("flow_node" (:*unnamed* ("plain_scalar" "single_quote_scalar" "flow_sequence" "flow_mapping" "tag" "anchor" "double_quote_scalar" "alias"))) - ("flow_pair" (:key ("flow_node") :value ("flow_node"))) - ("flow_sequence" (:*unnamed* ("flow_pair" "flow_node"))) - ("plain_scalar" (:*unnamed* ("float_scalar" "null_scalar" "integer_scalar" "boolean_scalar" "string_scalar"))) - ("reserved_directive" (:*unnamed* ("directive_name" "directive_parameter"))) - ("single_quote_scalar" (:*unnamed* ("escape_sequence"))) - ("stream" (:*unnamed* ("document"))) - ("tag_directive" (:*unnamed* ("tag_prefix" "tag_handle"))) - ("yaml_directive" (:*unnamed* ("yaml_version"))) - ("alias_name" (:*unnamed* nil)) - ("anchor_name" (:*unnamed* nil)) - ("boolean_scalar" (:*unnamed* nil)) - ("comment" (:*unnamed* nil)) - ("directive_name" (:*unnamed* nil)) - ("directive_parameter" (:*unnamed* nil)) - ("escape_sequence" (:*unnamed* nil)) - ("float_scalar" (:*unnamed* nil)) - ("integer_scalar" (:*unnamed* nil)) - ("null_scalar" (:*unnamed* nil)) - ("string_scalar" (:*unnamed* nil)) - ("tag" (:*unnamed* nil)) - ("tag_handle" (:*unnamed* nil)) - ("tag_prefix" (:*unnamed* nil)) - ("yaml_version" (:*unnamed* nil)) - )) +(defconst combobulate-rules-yaml + '(("alias" (:*unnamed* ("alias_name"))) + ("anchor" (:*unnamed* ("anchor_name"))) + ("block_mapping" (:*unnamed* ("block_mapping_pair"))) + ("block_mapping_pair" (:*unnamed* nil :key ("block_node" "flow_node") :value ("block_node" "flow_node"))) + ("block_node" (:*unnamed* ("block_scalar" "block_mapping" "tag" "block_sequence" "anchor"))) + ("block_scalar" (:*unnamed* nil)) + ("block_sequence" (:*unnamed* ("block_sequence_item"))) + ("block_sequence_item" (:*unnamed* ("block_node" "flow_node"))) + ("document" (:*unnamed* ("block_node" "yaml_directive" "flow_node" "tag_directive" "reserved_directive"))) + ("double_quote_scalar" (:*unnamed* ("escape_sequence"))) + ("flow_mapping" (:*unnamed* ("flow_node" "flow_pair"))) + ("flow_node" (:*unnamed* ("double_quote_scalar" "single_quote_scalar" "tag" "plain_scalar" "anchor" "flow_mapping" "alias" "flow_sequence"))) + ("flow_pair" (:*unnamed* nil :key ("flow_node") :value ("flow_node"))) + ("flow_sequence" (:*unnamed* ("flow_node" "flow_pair"))) + ("plain_scalar" (:*unnamed* ("string_scalar" "float_scalar" "null_scalar" "boolean_scalar" "integer_scalar"))) + ("reserved_directive" (:*unnamed* ("directive_parameter" "directive_name"))) + ("single_quote_scalar" (:*unnamed* ("escape_sequence"))) + ("stream" (:*unnamed* ("document"))) + ("tag_directive" (:*unnamed* ("tag_prefix" "tag_handle"))) + ("yaml_directive" (:*unnamed* ("yaml_version"))) + ("alias_name" (:*unnamed* nil)) + ("anchor_name" (:*unnamed* nil)) + ("boolean_scalar" (:*unnamed* nil)) + ("comment" (:*unnamed* nil)) + ("directive_name" (:*unnamed* nil)) + ("directive_parameter" (:*unnamed* nil)) + ("escape_sequence" (:*unnamed* nil)) + ("float_scalar" (:*unnamed* nil)) + ("integer_scalar" (:*unnamed* nil)) + ("null_scalar" (:*unnamed* nil)) + ("string_scalar" (:*unnamed* nil)) + ("tag" (:*unnamed* nil)) + ("tag_handle" (:*unnamed* nil)) + ("tag_prefix" (:*unnamed* nil)) + ("yaml_version" (:*unnamed* nil)) +)) ;; END Production rules for yaml ;; START Inverse production rules for yaml -(defconst combobulate-rules-yaml-inverse - '(("alias" ("flow_node")) - ("alias_name" ("alias")) - ("anchor" ("block_node" "flow_node")) - ("anchor_name" ("anchor")) - ("block_mapping" ("block_node")) - ("block_mapping_pair" ("block_mapping")) - ("block_node" ("block_sequence_item" "document" "block_mapping_pair")) - ("block_scalar" ("block_node")) - ("block_sequence" ("block_node")) - ("block_sequence_item" ("block_sequence")) - ("boolean_scalar" ("plain_scalar")) - ("directive_name" ("reserved_directive")) - ("directive_parameter" ("reserved_directive")) - ("document" ("stream")) - ("double_quote_scalar" ("flow_node")) - ("escape_sequence" ("double_quote_scalar" "single_quote_scalar")) - ("float_scalar" ("plain_scalar")) - ("flow_mapping" ("flow_node")) - ("flow_node" ("block_sequence_item" "document" "flow_sequence" "flow_mapping" "flow_pair" "block_mapping_pair")) - ("flow_pair" ("flow_sequence" "flow_mapping")) - ("flow_sequence" ("flow_node")) - ("integer_scalar" ("plain_scalar")) - ("null_scalar" ("plain_scalar")) - ("plain_scalar" ("flow_node")) - ("reserved_directive" ("document")) - ("single_quote_scalar" ("flow_node")) - ("string_scalar" ("plain_scalar")) - ("tag" ("block_node" "flow_node")) - ("tag_directive" ("document")) - ("tag_handle" ("tag_directive")) - ("tag_prefix" ("tag_directive")) - ("yaml_directive" ("document")) - ("yaml_version" ("yaml_directive")) - ) - ) +(defconst combobulate-rules-yaml-inverse + '(("alias" ("flow_node")) + ("alias_name" ("alias")) + ("anchor" ("block_node" "flow_node")) + ("anchor_name" ("anchor")) + ("block_mapping" ("block_node")) + ("block_mapping_pair" ("block_mapping")) + ("block_node" ("document" "block_mapping_pair" "block_sequence_item")) + ("block_scalar" ("block_node")) + ("block_sequence" ("block_node")) + ("block_sequence_item" ("block_sequence")) + ("boolean_scalar" ("plain_scalar")) + ("directive_name" ("reserved_directive")) + ("directive_parameter" ("reserved_directive")) + ("document" ("stream")) + ("double_quote_scalar" ("flow_node")) + ("escape_sequence" ("double_quote_scalar" "single_quote_scalar")) + ("float_scalar" ("plain_scalar")) + ("flow_mapping" ("flow_node")) + ("flow_node" ("flow_pair" "block_mapping_pair" "flow_mapping" "block_sequence_item" "document" "flow_sequence")) + ("flow_pair" ("flow_mapping" "flow_sequence")) + ("flow_sequence" ("flow_node")) + ("integer_scalar" ("plain_scalar")) + ("null_scalar" ("plain_scalar")) + ("plain_scalar" ("flow_node")) + ("reserved_directive" ("document")) + ("single_quote_scalar" ("flow_node")) + ("string_scalar" ("plain_scalar")) + ("tag" ("block_node" "flow_node")) + ("tag_directive" ("document")) + ("tag_handle" ("tag_directive")) + ("tag_prefix" ("tag_directive")) + ("yaml_directive" ("document")) + ("yaml_version" ("yaml_directive")) + ) +) ;; END Inverse production rules for yaml ;; START All node types in yaml -(defconst combobulate-rules-yaml-types - '("alias" "alias_name" "anchor" "anchor_name" "block_mapping" "block_mapping_pair" "block_node" "block_scalar" "block_sequence" "block_sequence_item" "boolean_scalar" "comment" "directive_name" "directive_parameter" "document" "double_quote_scalar" "escape_sequence" "float_scalar" "flow_mapping" "flow_node" "flow_pair" "flow_sequence" "integer_scalar" "null_scalar" "plain_scalar" "reserved_directive" "single_quote_scalar" "stream" "string_scalar" "tag" "tag_directive" "tag_handle" "tag_prefix" "yaml_directive" "yaml_version") - ) +(defconst combobulate-rules-yaml-types + '("alias" "alias_name" "anchor" "anchor_name" "block_mapping" "block_mapping_pair" "block_node" "block_scalar" "block_sequence" "block_sequence_item" "boolean_scalar" "comment" "directive_name" "directive_parameter" "document" "double_quote_scalar" "escape_sequence" "float_scalar" "flow_mapping" "flow_node" "flow_pair" "flow_sequence" "integer_scalar" "null_scalar" "plain_scalar" "reserved_directive" "single_quote_scalar" "stream" "string_scalar" "tag" "tag_directive" "tag_handle" "tag_prefix" "yaml_directive" "yaml_version") +) ;; END All node types in yaml +;; START All supertypes in yaml +(defconst combobulate-rules-yaml-supertypes + nil +) +;; END All supertypes in yaml ;; START Production rules for tsx -(defconst combobulate-rules-tsx - '(("_primary_type" (:*unnamed* ("parenthesized_type" "type_query" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "conditional_type" "nested_type_identifier" "predefined_type" "existential_type" "union_type"))) - ("declaration" (:*unnamed* ("ambient_declaration" "interface_declaration" "internal_module" "module" "variable_declaration" "lexical_declaration" "function_signature" "generator_function_declaration" "abstract_class_declaration" "function_declaration" "class_declaration" "import_alias" "enum_declaration" "type_alias_declaration"))) - ("expression" (:*unnamed* ("yield_expression" "as_expression" "binary_expression" "satisfies_expression" "augmented_assignment_expression" "new_expression" "internal_module" "assignment_expression" "primary_expression" "jsx_element" "jsx_self_closing_element" "instantiation_expression" "update_expression" "await_expression" "glimmer_template" "ternary_expression" "unary_expression"))) - ("pattern" (:*unnamed* ("member_expression" "identifier" "undefined" "object_pattern" "array_pattern" "rest_pattern" "non_null_expression" "subscript_expression"))) - ("primary_expression" (:*unnamed* ("member_expression" "array" "identifier" "string" "undefined" "parenthesized_expression" "arrow_function" "generator_function" "template_string" "call_expression" "class" "function" "subscript_expression" "false" "number" "regex" "super" "import" "object" "true" "this" "null" "meta_property" "non_null_expression"))) - ("statement" (:*unnamed* ("continue_statement" "for_statement" "with_statement" "export_statement" "import_statement" "if_statement" "do_statement" "declaration" "return_statement" "throw_statement" "for_in_statement" "while_statement" "empty_statement" "switch_statement" "expression_statement" "break_statement" "debugger_statement" "try_statement" "statement_block" "labeled_statement"))) - ("abstract_class_declaration" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("type_identifier") :type_parameters ("type_parameters"))) - ("abstract_method_signature" (:*unnamed* ("accessibility_modifier") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("ambient_declaration" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "declaration" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "statement_block" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type" "property_identifier"))) - ("arguments" (:*unnamed* ("spread_element" "expression"))) - ("array" (:*unnamed* ("spread_element" "expression"))) - ("array_pattern" (:*unnamed* ("pattern" "assignment_pattern"))) - ("array_type" (:*unnamed* ("parenthesized_type" "type_query" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "conditional_type" "nested_type_identifier" "predefined_type" "existential_type" "union_type"))) - ("arrow_function" (:body ("statement_block" "expression") :parameter ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("as_expression" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "expression" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("asserts" (:*unnamed* ("this" "identifier" "type_predicate"))) - ("asserts_annotation" (:*unnamed* ("asserts"))) - ("assignment_expression" (:left ("member_expression" "identifier" "undefined" "object_pattern" "array_pattern" "parenthesized_expression" "non_null_expression" "subscript_expression") :right ("expression"))) - ("assignment_pattern" (:left ("pattern") :right ("expression"))) - ("augmented_assignment_expression" (:left ("member_expression" "identifier" "parenthesized_expression" "non_null_expression" "subscript_expression") :operator nil :right ("expression"))) - ("await_expression" (:*unnamed* ("expression"))) - ("binary_expression" (:left ("expression") :operator nil :right ("expression"))) - ("break_statement" (:label ("statement_identifier"))) - ("call_expression" (:arguments ("arguments" "template_string") :function ("expression") :type_arguments ("type_arguments"))) - ("call_signature" (:parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("catch_clause" (:body ("statement_block") :parameter ("object_pattern" "identifier" "array_pattern") :type ("type_annotation"))) - ("class" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("type_identifier") :type_parameters ("type_parameters"))) - ("class_body" (:*unnamed* ("method_signature" "class_static_block" "abstract_method_signature" "public_field_definition" "method_definition" "decorator" "index_signature"))) - ("class_declaration" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("type_identifier") :type_parameters ("type_parameters"))) - ("class_heritage" (:*unnamed* ("extends_clause" "implements_clause"))) - ("class_static_block" (:body ("statement_block"))) - ("computed_property_name" (:*unnamed* ("expression"))) - ("conditional_type" (:alternative ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :consequence ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :left ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :right ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("constraint" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("construct_signature" (:parameters ("formal_parameters") :type ("type_annotation") :type_parameters ("type_parameters"))) - ("constructor_type" (:parameters ("formal_parameters") :type ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :type_parameters ("type_parameters"))) - ("continue_statement" (:label ("statement_identifier"))) - ("decorator" (:*unnamed* ("member_expression" "identifier" "call_expression"))) - ("default_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("do_statement" (:body ("statement") :condition ("parenthesized_expression"))) - ("else_clause" (:*unnamed* ("statement"))) - ("enum_assignment" (:name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :value ("expression"))) - ("enum_body" (:*unnamed* ("enum_assignment") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier"))) - ("enum_declaration" (:body ("enum_body") :name ("identifier"))) - ("export_clause" (:*unnamed* ("export_specifier"))) - ("export_specifier" (:alias ("string" "identifier") :name ("string" "identifier"))) - ("export_statement" (:*unnamed* ("namespace_export" "export_clause" "identifier" "expression") :declaration ("declaration") :decorator ("decorator") :source ("string") :value ("expression"))) - ("expression_statement" (:*unnamed* ("sequence_expression" "expression"))) - ("extends_clause" (:type_arguments ("type_arguments") :value ("expression"))) - ("extends_type_clause" (:type ("type_identifier" "generic_type" "nested_type_identifier"))) - ("finally_clause" (:body ("statement_block"))) - ("flow_maybe_type" (:*unnamed* ("parenthesized_type" "type_query" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "conditional_type" "nested_type_identifier" "predefined_type" "existential_type" "union_type"))) - ("for_in_statement" (:body ("statement") :kind nil :left ("member_expression" "identifier" "undefined" "object_pattern" "array_pattern" "parenthesized_expression" "non_null_expression" "subscript_expression") :operator nil :right ("sequence_expression" "expression") :value ("expression"))) - ("for_statement" (:body ("statement") :condition ("expression_statement" "empty_statement") :increment ("sequence_expression" "expression") :initializer ("lexical_declaration" "expression_statement" "variable_declaration" "empty_statement"))) - ("formal_parameters" (:*unnamed* ("required_parameter" "optional_parameter"))) - ("function" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("function_declaration" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("function_signature" (:name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("function_type" (:parameters ("formal_parameters") :return_type ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "type_predicate" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "asserts" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :type_parameters ("type_parameters"))) - ("generator_function" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("generator_function_declaration" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("generic_type" (:name ("type_identifier" "nested_type_identifier") :type_arguments ("type_arguments"))) - ("glimmer_template" (:close_tag ("glimmer_closing_tag") :open_tag ("glimmer_opening_tag"))) - ("if_statement" (:alternative ("else_clause") :condition ("parenthesized_expression") :consequence ("statement"))) - ("implements_clause" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("import_alias" (:*unnamed* ("identifier" "nested_identifier"))) - ("import_clause" (:*unnamed* ("namespace_import" "identifier" "named_imports"))) - ("import_require_clause" (:*unnamed* ("identifier") :source ("string"))) - ("import_specifier" (:alias ("identifier") :name ("string" "identifier"))) - ("import_statement" (:*unnamed* ("import_clause" "import_require_clause") :source ("string"))) - ("index_signature" (:*unnamed* ("mapped_type_clause") :index_type ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :name ("identifier") :sign nil :type ("type_annotation" "opting_type_annotation" "omitting_type_annotation"))) - ("index_type_query" (:*unnamed* ("parenthesized_type" "type_query" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "conditional_type" "nested_type_identifier" "predefined_type" "existential_type" "union_type"))) - ("infer_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("instantiation_expression" (:*unnamed* ("expression") :function ("member_expression" "import" "identifier" "subscript_expression") :type_arguments ("type_arguments"))) - ("interface_declaration" (:*unnamed* ("extends_type_clause") :body ("object_type") :name ("type_identifier") :type_parameters ("type_parameters"))) - ("internal_module" (:body ("statement_block") :name ("string" "identifier" "nested_identifier"))) - ("intersection_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("jsx_attribute" (:*unnamed* ("jsx_expression" "jsx_namespace_name" "jsx_element" "string" "jsx_self_closing_element" "property_identifier"))) - ("jsx_closing_element" (:name ("member_expression" "jsx_namespace_name" "identifier"))) - ("jsx_element" (:*unnamed* ("jsx_expression" "jsx_element" "jsx_text" "jsx_self_closing_element") :close_tag ("jsx_closing_element") :open_tag ("jsx_opening_element"))) - ("jsx_expression" (:*unnamed* ("sequence_expression" "spread_element" "expression"))) - ("jsx_namespace_name" (:*unnamed* ("identifier"))) - ("jsx_opening_element" (:attribute ("jsx_expression" "jsx_attribute") :name ("member_expression" "jsx_namespace_name" "identifier") :type_arguments ("type_arguments"))) - ("jsx_self_closing_element" (:attribute ("jsx_expression" "jsx_attribute") :name ("member_expression" "jsx_namespace_name" "identifier") :type_arguments ("type_arguments"))) - ("labeled_statement" (:body ("statement") :label ("statement_identifier"))) - ("lexical_declaration" (:*unnamed* ("variable_declarator") :kind nil)) - ("literal_type" (:*unnamed* ("false" "string" "undefined" "null" "number" "true" "unary_expression"))) - ("lookup_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("mapped_type_clause" (:alias ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :name ("type_identifier") :type ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("member_expression" (:*unnamed* ("member_expression" "identifier" "property_identifier") :object ("expression") :optional_chain ("optional_chain") :property ("private_property_identifier" "property_identifier"))) - ("method_definition" (:*unnamed* ("accessibility_modifier" "override_modifier") :body ("statement_block") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("method_signature" (:*unnamed* ("accessibility_modifier" "override_modifier") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("module" (:body ("statement_block") :name ("string" "identifier" "nested_identifier"))) - ("named_imports" (:*unnamed* ("import_specifier"))) - ("namespace_export" (:*unnamed* ("string" "identifier"))) - ("namespace_import" (:*unnamed* ("identifier"))) - ("nested_identifier" (:*unnamed* ("member_expression" "identifier" "property_identifier"))) - ("nested_type_identifier" (:module ("identifier" "nested_identifier") :name ("type_identifier"))) - ("new_expression" (:arguments ("arguments") :constructor ("primary_expression") :type_arguments ("type_arguments"))) - ("non_null_expression" (:*unnamed* ("expression"))) - ("object" (:*unnamed* ("method_definition" "pair" "spread_element" "shorthand_property_identifier"))) - ("object_assignment_pattern" (:left ("shorthand_property_identifier_pattern" "object_pattern" "array_pattern") :right ("expression"))) - ("object_pattern" (:*unnamed* ("shorthand_property_identifier_pattern" "object_assignment_pattern" "rest_pattern" "pair_pattern"))) - ("object_type" (:*unnamed* ("call_signature" "property_signature" "construct_signature" "export_statement" "method_signature" "index_signature"))) - ("omitting_type_annotation" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("opting_type_annotation" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("optional_parameter" (:*unnamed* ("accessibility_modifier" "override_modifier") :decorator ("decorator") :name ("identifier") :pattern ("this" "pattern") :type ("type_annotation") :value ("expression"))) - ("optional_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("pair" (:key ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :value ("expression"))) - ("pair_pattern" (:key ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :value ("pattern" "assignment_pattern"))) - ("parenthesized_expression" (:*unnamed* ("sequence_expression" "expression") :type ("type_annotation"))) - ("parenthesized_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("program" (:*unnamed* ("hash_bang_line" "statement"))) - ("property_signature" (:*unnamed* ("accessibility_modifier" "override_modifier") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :type ("type_annotation"))) - ("public_field_definition" (:*unnamed* ("accessibility_modifier" "override_modifier") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :type ("type_annotation") :value ("expression"))) - ("readonly_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("regex" (:flags ("regex_flags") :pattern ("regex_pattern"))) - ("required_parameter" (:*unnamed* ("accessibility_modifier" "override_modifier") :decorator ("decorator") :name ("identifier" "rest_pattern") :pattern ("this" "pattern") :type ("type_annotation") :value ("expression"))) - ("rest_pattern" (:*unnamed* ("member_expression" "identifier" "undefined" "object_pattern" "array_pattern" "non_null_expression" "subscript_expression"))) - ("rest_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("return_statement" (:*unnamed* ("sequence_expression" "expression"))) - ("satisfies_expression" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "expression" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("sequence_expression" (:left ("expression") :right ("sequence_expression" "expression"))) - ("spread_element" (:*unnamed* ("expression"))) - ("statement_block" (:*unnamed* ("statement"))) - ("string" (:*unnamed* ("string_fragment" "escape_sequence"))) - ("subscript_expression" (:index ("sequence_expression" "predefined_type" "string" "expression" "number") :object ("expression") :optional_chain ("optional_chain"))) - ("switch_body" (:*unnamed* ("switch_case" "switch_default"))) - ("switch_case" (:body ("statement") :value ("sequence_expression" "expression"))) - ("switch_default" (:body ("statement"))) - ("switch_statement" (:body ("switch_body") :value ("parenthesized_expression"))) - ("template_literal_type" (:*unnamed* ("template_type"))) - ("template_string" (:*unnamed* ("template_substitution" "escape_sequence"))) - ("template_substitution" (:*unnamed* ("sequence_expression" "expression"))) - ("template_type" (:*unnamed* ("parenthesized_type" "type_query" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "conditional_type" "nested_type_identifier" "predefined_type" "existential_type" "union_type"))) - ("ternary_expression" (:alternative ("expression") :condition ("expression") :consequence ("expression"))) - ("throw_statement" (:*unnamed* ("sequence_expression" "expression"))) - ("try_statement" (:body ("statement_block") :finalizer ("finally_clause") :handler ("catch_clause"))) - ("tuple_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "optional_type" "tuple_type" "flow_maybe_type" "intersection_type" "rest_type" "generic_type" "lookup_type" "infer_type" "optional_parameter" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "required_parameter" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("type_alias_declaration" (:name ("type_identifier") :type_parameters ("type_parameters") :value ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("type_annotation" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("type_arguments" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("type_parameter" (:constraint ("constraint") :name ("type_identifier") :value ("default_type"))) - ("type_parameters" (:*unnamed* ("type_parameter"))) - ("type_predicate" (:name ("this" "identifier") :type ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("type_predicate_annotation" (:*unnamed* ("type_predicate"))) - ("type_query" (:*unnamed* ("member_expression" "identifier" "call_expression" "instantiation_expression" "subscript_expression"))) - ("unary_expression" (:argument ("number" "expression") :operator nil)) - ("union_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("update_expression" (:argument ("expression") :operator nil)) - ("variable_declaration" (:*unnamed* ("variable_declarator"))) - ("variable_declarator" (:name ("object_pattern" "identifier" "array_pattern") :type ("type_annotation") :value ("expression"))) - ("while_statement" (:body ("statement") :condition ("parenthesized_expression"))) - ("with_statement" (:body ("statement") :object ("parenthesized_expression"))) - ("yield_expression" (:*unnamed* ("expression"))) - ("comment" (:*unnamed* nil)) - ("escape_sequence" (:*unnamed* nil)) - ("false" (:*unnamed* nil)) - ("hash_bang_line" (:*unnamed* nil)) - ("null" (:*unnamed* nil)) - ("number" (:*unnamed* nil)) - ("private_property_identifier" (:*unnamed* nil)) - ("property_identifier" (:*unnamed* nil)) - ("regex_flags" (:*unnamed* nil)) - ("regex_pattern" (:*unnamed* nil)) - ("shorthand_property_identifier" (:*unnamed* nil)) - ("shorthand_property_identifier_pattern" (:*unnamed* nil)) - ("statement_identifier" (:*unnamed* nil)) - ("string_fragment" (:*unnamed* nil)) - ("super" (:*unnamed* nil)) - ("this" (:*unnamed* nil)) - ("this_type" (:*unnamed* nil)) - ("true" (:*unnamed* nil)) - ("type_identifier" (:*unnamed* nil)) - ("undefined" (:*unnamed* nil)) - )) +(defconst combobulate-rules-tsx + '(("_primary_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "predefined_type" "tuple_type" "nested_type_identifier" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("declaration" (:*unnamed* ("ambient_declaration" "import_alias" "class_declaration" "type_alias_declaration" "interface_declaration" "function_signature" "variable_declaration" "generator_function_declaration" "internal_module" "enum_declaration" "module" "lexical_declaration" "abstract_class_declaration" "function_declaration"))) + ("expression" (:*unnamed* ("jsx_self_closing_element" "update_expression" "ternary_expression" "satisfies_expression" "jsx_element" "assignment_expression" "glimmer_template" "binary_expression" "new_expression" "instantiation_expression" "as_expression" "primary_expression" "unary_expression" "internal_module" "augmented_assignment_expression" "yield_expression" "await_expression"))) + ("pattern" (:*unnamed* ("non_null_expression" "undefined" "array_pattern" "object_pattern" "identifier" "member_expression" "rest_pattern" "subscript_expression"))) + ("primary_expression" (:*unnamed* ("arrow_function" "false" "object" "template_string" "undefined" "meta_property" "function" "number" "class" "subscript_expression" "parenthesized_expression" "call_expression" "non_null_expression" "import" "true" "string" "member_expression" "identifier" "null" "regex" "array" "super" "this" "generator_function"))) + ("statement" (:*unnamed* ("break_statement" "import_statement" "expression_statement" "do_statement" "with_statement" "if_statement" "continue_statement" "switch_statement" "try_statement" "declaration" "empty_statement" "for_statement" "debugger_statement" "export_statement" "statement_block" "throw_statement" "while_statement" "return_statement" "labeled_statement" "for_in_statement"))) + ("abstract_class_declaration" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("type_identifier") :type_parameters ("type_parameters"))) + ("abstract_method_signature" (:*unnamed* ("accessibility_modifier") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("accessibility_modifier" (:*unnamed* nil)) + ("ambient_declaration" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "property_identifier" "union_type" "conditional_type" "index_type_query" "declaration" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "statement_block" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("arguments" (:*unnamed* ("expression" "spread_element"))) + ("array" (:*unnamed* ("expression" "spread_element"))) + ("array_pattern" (:*unnamed* ("assignment_pattern" "pattern"))) + ("array_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "predefined_type" "tuple_type" "nested_type_identifier" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("arrow_function" (:*unnamed* nil :body ("expression" "statement_block") :parameter ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("as_expression" (:*unnamed* ("expression" "object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("asserts" (:*unnamed* ("identifier" "type_predicate" "this"))) + ("asserts_annotation" (:*unnamed* ("asserts"))) + ("assignment_expression" (:*unnamed* nil :left ("parenthesized_expression" "non_null_expression" "undefined" "array_pattern" "object_pattern" "identifier" "member_expression" "subscript_expression") :right ("expression"))) + ("assignment_pattern" (:*unnamed* nil :left ("pattern") :right ("expression"))) + ("augmented_assignment_expression" (:*unnamed* nil :left ("parenthesized_expression" "identifier" "non_null_expression" "subscript_expression" "member_expression") :operator nil :right ("expression"))) + ("await_expression" (:*unnamed* ("expression"))) + ("binary_expression" (:*unnamed* nil :left ("expression") :operator nil :right ("expression"))) + ("break_statement" (:*unnamed* nil :label ("statement_identifier"))) + ("call_expression" (:*unnamed* nil :arguments ("arguments" "template_string") :function ("expression") :type_arguments ("type_arguments"))) + ("call_signature" (:*unnamed* nil :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("catch_clause" (:*unnamed* nil :body ("statement_block") :parameter ("identifier" "array_pattern" "object_pattern") :type ("type_annotation"))) + ("class" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("type_identifier") :type_parameters ("type_parameters"))) + ("class_body" (:*unnamed* ("index_signature" "decorator" "method_definition" "public_field_definition" "method_signature" "abstract_method_signature" "class_static_block"))) + ("class_declaration" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("type_identifier") :type_parameters ("type_parameters"))) + ("class_heritage" (:*unnamed* ("extends_clause" "implements_clause"))) + ("class_static_block" (:*unnamed* nil :body ("statement_block"))) + ("computed_property_name" (:*unnamed* ("expression"))) + ("conditional_type" (:*unnamed* nil :alternative ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :consequence ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :left ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :right ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("constraint" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("construct_signature" (:*unnamed* nil :parameters ("formal_parameters") :type ("type_annotation") :type_parameters ("type_parameters"))) + ("constructor_type" (:*unnamed* nil :parameters ("formal_parameters") :type ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :type_parameters ("type_parameters"))) + ("continue_statement" (:*unnamed* nil :label ("statement_identifier"))) + ("debugger_statement" (:*unnamed* nil)) + ("decorator" (:*unnamed* ("identifier" "call_expression" "member_expression"))) + ("default_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("do_statement" (:*unnamed* nil :body ("statement") :condition ("parenthesized_expression"))) + ("else_clause" (:*unnamed* ("statement"))) + ("empty_statement" (:*unnamed* nil)) + ("enum_assignment" (:*unnamed* nil :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :value ("expression"))) + ("enum_body" (:*unnamed* ("enum_assignment") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier"))) + ("enum_declaration" (:*unnamed* nil :body ("enum_body") :name ("identifier"))) + ("existential_type" (:*unnamed* nil)) + ("export_clause" (:*unnamed* ("export_specifier"))) + ("export_specifier" (:*unnamed* nil :alias ("identifier" "string") :name ("identifier" "string"))) + ("export_statement" (:*unnamed* ("identifier" "expression" "export_clause" "namespace_export") :declaration ("declaration") :decorator ("decorator") :source ("string") :value ("expression"))) + ("expression_statement" (:*unnamed* ("expression" "sequence_expression"))) + ("extends_clause" (:*unnamed* nil :type_arguments ("type_arguments") :value ("expression"))) + ("extends_type_clause" (:*unnamed* nil :type ("type_identifier" "nested_type_identifier" "generic_type"))) + ("finally_clause" (:*unnamed* nil :body ("statement_block"))) + ("flow_maybe_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "predefined_type" "tuple_type" "nested_type_identifier" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("for_in_statement" (:*unnamed* nil :body ("statement") :kind nil :left ("parenthesized_expression" "non_null_expression" "undefined" "array_pattern" "object_pattern" "identifier" "member_expression" "subscript_expression") :operator nil :right ("expression" "sequence_expression") :value ("expression"))) + ("for_statement" (:*unnamed* nil :body ("statement") :condition ("empty_statement" "expression_statement") :increment ("expression" "sequence_expression") :initializer ("empty_statement" "lexical_declaration" "expression_statement" "variable_declaration"))) + ("formal_parameters" (:*unnamed* ("required_parameter" "optional_parameter"))) + ("function" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("function_declaration" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("function_signature" (:*unnamed* nil :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("function_type" (:*unnamed* nil :parameters ("formal_parameters") :return_type ("object_type" "intersection_type" "asserts" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "type_predicate" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :type_parameters ("type_parameters"))) + ("generator_function" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("generator_function_declaration" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("generic_type" (:*unnamed* nil :name ("type_identifier" "nested_type_identifier") :type_arguments ("type_arguments"))) + ("glimmer_closing_tag" (:*unnamed* nil)) + ("glimmer_opening_tag" (:*unnamed* nil)) + ("glimmer_template" (:*unnamed* nil :close_tag ("glimmer_closing_tag") :open_tag ("glimmer_opening_tag"))) + ("identifier" (:*unnamed* nil)) + ("if_statement" (:*unnamed* nil :alternative ("else_clause") :condition ("parenthesized_expression") :consequence ("statement"))) + ("implements_clause" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("import" (:*unnamed* nil)) + ("import_alias" (:*unnamed* ("identifier" "nested_identifier"))) + ("import_clause" (:*unnamed* ("identifier" "named_imports" "namespace_import"))) + ("import_require_clause" (:*unnamed* ("identifier") :source ("string"))) + ("import_specifier" (:*unnamed* nil :alias ("identifier") :name ("identifier" "string"))) + ("import_statement" (:*unnamed* ("import_require_clause" "import_clause") :source ("string"))) + ("index_signature" (:*unnamed* ("mapped_type_clause") :index_type ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :name ("identifier") :sign nil :type ("type_annotation" "omitting_type_annotation" "opting_type_annotation"))) + ("index_type_query" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "predefined_type" "tuple_type" "nested_type_identifier" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("infer_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("instantiation_expression" (:*unnamed* ("expression") :function ("identifier" "subscript_expression" "member_expression" "import") :type_arguments ("type_arguments"))) + ("interface_declaration" (:*unnamed* ("extends_type_clause") :body ("object_type") :name ("type_identifier") :type_parameters ("type_parameters"))) + ("internal_module" (:*unnamed* nil :body ("statement_block") :name ("identifier" "string" "nested_identifier"))) + ("intersection_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("jsx_attribute" (:*unnamed* ("jsx_expression" "jsx_self_closing_element" "property_identifier" "jsx_namespace_name" "jsx_element" "string"))) + ("jsx_closing_element" (:*unnamed* nil :name ("identifier" "jsx_namespace_name" "member_expression"))) + ("jsx_element" (:*unnamed* ("jsx_self_closing_element" "jsx_text" "jsx_expression" "jsx_element") :close_tag ("jsx_closing_element") :open_tag ("jsx_opening_element"))) + ("jsx_expression" (:*unnamed* ("expression" "sequence_expression" "spread_element"))) + ("jsx_namespace_name" (:*unnamed* ("identifier"))) + ("jsx_opening_element" (:*unnamed* nil :attribute ("jsx_expression" "jsx_attribute") :name ("identifier" "jsx_namespace_name" "member_expression") :type_arguments ("type_arguments"))) + ("jsx_self_closing_element" (:*unnamed* nil :attribute ("jsx_expression" "jsx_attribute") :name ("identifier" "jsx_namespace_name" "member_expression") :type_arguments ("type_arguments"))) + ("jsx_text" (:*unnamed* nil)) + ("labeled_statement" (:*unnamed* nil :body ("statement") :label ("statement_identifier"))) + ("lexical_declaration" (:*unnamed* ("variable_declarator") :kind nil)) + ("literal_type" (:*unnamed* ("false" "unary_expression" "null" "undefined" "true" "string" "number"))) + ("lookup_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("mapped_type_clause" (:*unnamed* nil :alias ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :name ("type_identifier") :type ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("member_expression" (:*unnamed* ("identifier" "property_identifier" "member_expression") :object ("expression") :optional_chain ("optional_chain") :property ("property_identifier" "private_property_identifier"))) + ("meta_property" (:*unnamed* nil)) + ("method_definition" (:*unnamed* ("override_modifier" "accessibility_modifier") :body ("statement_block") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("method_signature" (:*unnamed* ("override_modifier" "accessibility_modifier") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("module" (:*unnamed* nil :body ("statement_block") :name ("identifier" "string" "nested_identifier"))) + ("named_imports" (:*unnamed* ("import_specifier"))) + ("namespace_export" (:*unnamed* ("identifier" "string"))) + ("namespace_import" (:*unnamed* ("identifier"))) + ("nested_identifier" (:*unnamed* ("identifier" "property_identifier" "member_expression"))) + ("nested_type_identifier" (:*unnamed* nil :module ("identifier" "nested_identifier") :name ("type_identifier"))) + ("new_expression" (:*unnamed* nil :arguments ("arguments") :constructor ("primary_expression") :type_arguments ("type_arguments"))) + ("non_null_expression" (:*unnamed* ("expression"))) + ("object" (:*unnamed* ("pair" "method_definition" "shorthand_property_identifier" "spread_element"))) + ("object_assignment_pattern" (:*unnamed* nil :left ("shorthand_property_identifier_pattern" "array_pattern" "object_pattern") :right ("expression"))) + ("object_pattern" (:*unnamed* ("object_assignment_pattern" "shorthand_property_identifier_pattern" "rest_pattern" "pair_pattern"))) + ("object_type" (:*unnamed* ("index_signature" "call_signature" "export_statement" "method_signature" "construct_signature" "property_signature"))) + ("omitting_type_annotation" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("opting_type_annotation" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("optional_chain" (:*unnamed* nil)) + ("optional_parameter" (:*unnamed* ("override_modifier" "accessibility_modifier") :decorator ("decorator") :name ("identifier") :pattern ("pattern" "this") :type ("type_annotation") :value ("expression"))) + ("optional_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("override_modifier" (:*unnamed* nil)) + ("pair" (:*unnamed* nil :key ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :value ("expression"))) + ("pair_pattern" (:*unnamed* nil :key ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :value ("assignment_pattern" "pattern"))) + ("parenthesized_expression" (:*unnamed* ("expression" "sequence_expression") :type ("type_annotation"))) + ("parenthesized_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("predefined_type" (:*unnamed* nil)) + ("program" (:*unnamed* ("statement" "hash_bang_line"))) + ("property_signature" (:*unnamed* ("override_modifier" "accessibility_modifier") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :type ("type_annotation"))) + ("public_field_definition" (:*unnamed* ("override_modifier" "accessibility_modifier") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :type ("type_annotation") :value ("expression"))) + ("readonly_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("regex" (:*unnamed* nil :flags ("regex_flags") :pattern ("regex_pattern"))) + ("required_parameter" (:*unnamed* ("override_modifier" "accessibility_modifier") :decorator ("decorator") :name ("identifier" "rest_pattern") :pattern ("pattern" "this") :type ("type_annotation") :value ("expression"))) + ("rest_pattern" (:*unnamed* ("identifier" "non_null_expression" "member_expression" "undefined" "subscript_expression" "array_pattern" "object_pattern"))) + ("rest_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("return_statement" (:*unnamed* ("expression" "sequence_expression"))) + ("satisfies_expression" (:*unnamed* ("expression" "object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("sequence_expression" (:*unnamed* nil :left ("expression") :right ("expression" "sequence_expression"))) + ("spread_element" (:*unnamed* ("expression"))) + ("statement_block" (:*unnamed* ("statement"))) + ("string" (:*unnamed* ("string_fragment" "escape_sequence"))) + ("subscript_expression" (:*unnamed* nil :index ("expression" "predefined_type" "sequence_expression" "string" "number") :object ("expression") :optional_chain ("optional_chain"))) + ("switch_body" (:*unnamed* ("switch_case" "switch_default"))) + ("switch_case" (:*unnamed* nil :body ("statement") :value ("expression" "sequence_expression"))) + ("switch_default" (:*unnamed* nil :body ("statement"))) + ("switch_statement" (:*unnamed* nil :body ("switch_body") :value ("parenthesized_expression"))) + ("template_literal_type" (:*unnamed* ("template_type"))) + ("template_string" (:*unnamed* ("template_substitution" "escape_sequence"))) + ("template_substitution" (:*unnamed* ("expression" "sequence_expression"))) + ("template_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "nested_type_identifier" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("ternary_expression" (:*unnamed* nil :alternative ("expression") :condition ("expression") :consequence ("expression"))) + ("throw_statement" (:*unnamed* ("expression" "sequence_expression"))) + ("try_statement" (:*unnamed* nil :body ("statement_block") :finalizer ("finally_clause") :handler ("catch_clause"))) + ("tuple_type" (:*unnamed* ("object_type" "optional_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "optional_parameter" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "required_parameter" "rest_type" "lookup_type"))) + ("type_alias_declaration" (:*unnamed* nil :name ("type_identifier") :type_parameters ("type_parameters") :value ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("type_annotation" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("type_arguments" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("type_parameter" (:*unnamed* nil :constraint ("constraint") :name ("type_identifier") :value ("default_type"))) + ("type_parameters" (:*unnamed* ("type_parameter"))) + ("type_predicate" (:*unnamed* nil :name ("identifier" "this") :type ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("type_predicate_annotation" (:*unnamed* ("type_predicate"))) + ("type_query" (:*unnamed* ("identifier" "call_expression" "instantiation_expression" "subscript_expression" "member_expression"))) + ("unary_expression" (:*unnamed* nil :argument ("expression" "number") :operator nil)) + ("union_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("update_expression" (:*unnamed* nil :argument ("expression") :operator nil)) + ("variable_declaration" (:*unnamed* ("variable_declarator"))) + ("variable_declarator" (:*unnamed* nil :name ("identifier" "array_pattern" "object_pattern") :type ("type_annotation") :value ("expression"))) + ("while_statement" (:*unnamed* nil :body ("statement") :condition ("parenthesized_expression"))) + ("with_statement" (:*unnamed* nil :body ("statement") :object ("parenthesized_expression"))) + ("yield_expression" (:*unnamed* ("expression"))) + ("comment" (:*unnamed* nil)) + ("escape_sequence" (:*unnamed* nil)) + ("false" (:*unnamed* nil)) + ("hash_bang_line" (:*unnamed* nil)) + ("null" (:*unnamed* nil)) + ("number" (:*unnamed* nil)) + ("private_property_identifier" (:*unnamed* nil)) + ("property_identifier" (:*unnamed* nil)) + ("regex_flags" (:*unnamed* nil)) + ("regex_pattern" (:*unnamed* nil)) + ("shorthand_property_identifier" (:*unnamed* nil)) + ("shorthand_property_identifier_pattern" (:*unnamed* nil)) + ("statement_identifier" (:*unnamed* nil)) + ("string_fragment" (:*unnamed* nil)) + ("super" (:*unnamed* nil)) + ("this" (:*unnamed* nil)) + ("this_type" (:*unnamed* nil)) + ("true" (:*unnamed* nil)) + ("type_identifier" (:*unnamed* nil)) + ("undefined" (:*unnamed* nil)) +)) ;; END Production rules for tsx ;; START Inverse production rules for tsx -(defconst combobulate-rules-tsx-inverse - '(("abstract_class_declaration" ("declaration")) - ("abstract_method_signature" ("class_body")) - ("accessibility_modifier" ("abstract_method_signature" "public_field_definition" "method_definition" "required_parameter" "method_signature" "property_signature" "optional_parameter")) - ("ambient_declaration" ("declaration")) - ("arguments" ("new_expression" "call_expression")) - ("array" ("primary_expression")) - ("array_pattern" ("for_in_statement" "pattern" "assignment_expression" "rest_pattern" "object_assignment_pattern" "variable_declarator" "catch_clause")) - ("array_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("arrow_function" ("primary_expression")) - ("as_expression" ("expression")) - ("asserts" ("asserts_annotation" "function_type")) - ("asserts_annotation" ("abstract_method_signature" "method_definition" "arrow_function" "function_signature" "generator_function" "generator_function_declaration" "function_declaration" "method_signature" "call_signature" "function")) - ("assignment_expression" ("expression")) - ("assignment_pattern" ("pair_pattern" "array_pattern")) - ("augmented_assignment_expression" ("expression")) - ("await_expression" ("expression")) - ("binary_expression" ("expression")) - ("break_statement" ("statement")) - ("call_expression" ("primary_expression" "decorator" "type_query")) - ("call_signature" ("object_type")) - ("catch_clause" ("try_statement")) - ("class" ("primary_expression")) - ("class_body" ("abstract_class_declaration" "class_declaration" "class")) - ("class_declaration" ("declaration")) - ("class_heritage" ("abstract_class_declaration" "class_declaration" "class")) - ("class_static_block" ("class_body")) - ("computed_property_name" ("abstract_method_signature" "enum_body" "public_field_definition" "method_definition" "method_signature" "pair" "enum_assignment" "pair_pattern" "property_signature")) - ("conditional_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("constraint" ("type_parameter")) - ("construct_signature" ("object_type")) - ("constructor_type" ("function_type" "implements_clause" "rest_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("continue_statement" ("statement")) - ("debugger_statement" ("statement")) - ("declaration" ("ambient_declaration" "export_statement" "statement")) - ("decorator" ("optional_parameter" "required_parameter" "export_statement" "abstract_class_declaration" "class_declaration" "class_body" "class")) - ("default_type" ("type_parameter")) - ("do_statement" ("statement")) - ("else_clause" ("if_statement")) - ("empty_statement" ("for_statement" "statement")) - ("enum_assignment" ("enum_body")) - ("enum_body" ("enum_declaration")) - ("enum_declaration" ("declaration")) - ("escape_sequence" ("template_string" "string")) - ("existential_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("export_clause" ("export_statement")) - ("export_specifier" ("export_clause")) - ("export_statement" ("object_type" "statement")) - ("expression" ("jsx_expression" "member_expression" "sequence_expression" "parenthesized_expression" "spread_element" "binary_expression" "return_statement" "computed_property_name" "switch_case" "required_parameter" "instantiation_expression" "await_expression" "ternary_expression" "pair" "enum_assignment" "object_assignment_pattern" "non_null_expression" "variable_declarator" "template_substitution" "array" "public_field_definition" "for_statement" "yield_expression" "export_statement" "arrow_function" "as_expression" "satisfies_expression" "call_expression" "augmented_assignment_expression" "extends_clause" "for_in_statement" "throw_statement" "optional_parameter" "subscript_expression" "assignment_expression" "arguments" "expression_statement" "update_expression" "assignment_pattern" "unary_expression")) - ("expression_statement" ("for_statement" "statement")) - ("extends_clause" ("class_heritage")) - ("extends_type_clause" ("interface_declaration")) - ("false" ("primary_expression" "literal_type")) - ("finally_clause" ("try_statement")) - ("flow_maybe_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("for_in_statement" ("statement")) - ("for_statement" ("statement")) - ("formal_parameters" ("abstract_method_signature" "function_type" "method_definition" "construct_signature" "arrow_function" "function_signature" "generator_function" "constructor_type" "function_declaration" "generator_function_declaration" "method_signature" "call_signature" "function")) - ("function" ("primary_expression")) - ("function_declaration" ("declaration")) - ("function_signature" ("declaration")) - ("function_type" ("function_type" "implements_clause" "rest_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("generator_function" ("primary_expression")) - ("generator_function_declaration" ("declaration")) - ("generic_type" ("function_type" "extends_type_clause" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("glimmer_closing_tag" ("glimmer_template")) - ("glimmer_opening_tag" ("glimmer_template")) - ("glimmer_template" ("expression")) - ("hash_bang_line" ("program")) - ("identifier" ("member_expression" "type_query" "jsx_closing_element" "rest_pattern" "enum_declaration" "internal_module" "type_predicate" "namespace_import" "export_specifier" "module" "jsx_self_closing_element" "instantiation_expression" "required_parameter" "function_signature" "generator_function_declaration" "function_declaration" "variable_declarator" "import_clause" "catch_clause" "import_require_clause" "export_statement" "arrow_function" "generator_function" "namespace_export" "augmented_assignment_expression" "import_alias" "import_specifier" "for_in_statement" "function" "optional_parameter" "assignment_expression" "primary_expression" "jsx_namespace_name" "pattern" "decorator" "nested_identifier" "index_signature" "asserts" "nested_type_identifier" "jsx_opening_element")) - ("if_statement" ("statement")) - ("implements_clause" ("class_heritage")) - ("import" ("primary_expression" "instantiation_expression")) - ("import_alias" ("declaration")) - ("import_clause" ("import_statement")) - ("import_require_clause" ("import_statement")) - ("import_specifier" ("named_imports")) - ("import_statement" ("statement")) - ("index_signature" ("object_type" "class_body")) - ("index_type_query" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("infer_type" ("function_type" "implements_clause" "rest_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("instantiation_expression" ("expression" "type_query")) - ("interface_declaration" ("declaration")) - ("internal_module" ("declaration" "expression")) - ("intersection_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("jsx_attribute" ("jsx_self_closing_element" "jsx_opening_element")) - ("jsx_closing_element" ("jsx_element")) - ("jsx_element" ("jsx_attribute" "jsx_element" "expression")) - ("jsx_expression" ("jsx_self_closing_element" "jsx_attribute" "jsx_element" "jsx_opening_element")) - ("jsx_namespace_name" ("jsx_self_closing_element" "jsx_attribute" "jsx_closing_element" "jsx_opening_element")) - ("jsx_opening_element" ("jsx_element")) - ("jsx_self_closing_element" ("jsx_attribute" "jsx_element" "expression")) - ("jsx_text" ("jsx_element")) - ("labeled_statement" ("statement")) - ("lexical_declaration" ("for_statement" "declaration")) - ("literal_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("lookup_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("mapped_type_clause" ("index_signature")) - ("member_expression" ("member_expression" "primary_expression" "pattern" "type_query" "jsx_self_closing_element" "instantiation_expression" "jsx_closing_element" "decorator" "nested_identifier" "rest_pattern" "augmented_assignment_expression" "jsx_opening_element" "for_in_statement" "assignment_expression")) - ("meta_property" ("primary_expression")) - ("method_definition" ("object" "class_body")) - ("method_signature" ("object_type" "class_body")) - ("module" ("declaration")) - ("named_imports" ("import_clause")) - ("namespace_export" ("export_statement")) - ("namespace_import" ("import_clause")) - ("nested_identifier" ("module" "internal_module" "nested_type_identifier" "import_alias")) - ("nested_type_identifier" ("function_type" "extends_type_clause" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "generic_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("new_expression" ("expression")) - ("non_null_expression" ("primary_expression" "pattern" "rest_pattern" "augmented_assignment_expression" "for_in_statement" "assignment_expression")) - ("null" ("primary_expression" "literal_type")) - ("number" ("primary_expression" "literal_type" "abstract_method_signature" "enum_body" "public_field_definition" "method_definition" "method_signature" "pair" "enum_assignment" "pair_pattern" "property_signature" "subscript_expression" "unary_expression")) - ("object" ("primary_expression")) - ("object_assignment_pattern" ("object_pattern")) - ("object_pattern" ("for_in_statement" "pattern" "assignment_expression" "rest_pattern" "object_assignment_pattern" "variable_declarator" "catch_clause")) - ("object_type" ("interface_declaration" "function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("omitting_type_annotation" ("index_signature")) - ("opting_type_annotation" ("index_signature")) - ("optional_chain" ("member_expression" "subscript_expression")) - ("optional_parameter" ("formal_parameters" "tuple_type")) - ("optional_type" ("tuple_type")) - ("override_modifier" ("public_field_definition" "method_definition" "required_parameter" "method_signature" "property_signature" "optional_parameter")) - ("pair" ("object")) - ("pair_pattern" ("object_pattern")) - ("parenthesized_expression" ("primary_expression" "while_statement" "switch_statement" "with_statement" "if_statement" "do_statement" "augmented_assignment_expression" "for_in_statement" "assignment_expression")) - ("parenthesized_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("pattern" ("array_pattern" "required_parameter" "assignment_pattern" "pair_pattern" "optional_parameter")) - ("predefined_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "subscript_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("primary_expression" ("new_expression" "expression")) - ("private_property_identifier" ("member_expression" "abstract_method_signature" "enum_body" "public_field_definition" "method_definition" "method_signature" "pair" "enum_assignment" "pair_pattern" "property_signature")) - ("property_identifier" ("ambient_declaration" "jsx_attribute" "member_expression" "abstract_method_signature" "enum_body" "public_field_definition" "method_definition" "method_signature" "nested_identifier" "pair" "enum_assignment" "pair_pattern" "property_signature")) - ("property_signature" ("object_type")) - ("public_field_definition" ("class_body")) - ("readonly_type" ("function_type" "implements_clause" "rest_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("regex" ("primary_expression")) - ("regex_flags" ("regex")) - ("regex_pattern" ("regex")) - ("required_parameter" ("formal_parameters" "tuple_type")) - ("rest_pattern" ("required_parameter" "pattern" "object_pattern")) - ("rest_type" ("tuple_type")) - ("return_statement" ("statement")) - ("satisfies_expression" ("expression")) - ("sequence_expression" ("jsx_expression" "sequence_expression" "parenthesized_expression" "for_statement" "throw_statement" "expression_statement" "return_statement" "switch_case" "for_in_statement" "template_substitution" "subscript_expression")) - ("shorthand_property_identifier" ("object")) - ("shorthand_property_identifier_pattern" ("object_assignment_pattern" "object_pattern")) - ("spread_element" ("array" "arguments" "jsx_expression" "object")) - ("statement" ("switch_default" "while_statement" "for_statement" "statement_block" "with_statement" "if_statement" "do_statement" "else_clause" "labeled_statement" "program" "switch_case" "for_in_statement")) - ("statement_block" ("ambient_declaration" "finally_clause" "method_definition" "module" "statement" "arrow_function" "generator_function" "generator_function_declaration" "try_statement" "function_declaration" "class_static_block" "internal_module" "function" "catch_clause")) - ("statement_identifier" ("labeled_statement" "continue_statement" "break_statement")) - ("string" ("enum_body" "method_signature" "internal_module" "export_specifier" "module" "method_definition" "pair" "enum_assignment" "property_signature" "jsx_attribute" "import_require_clause" "public_field_definition" "export_statement" "import_statement" "namespace_export" "import_specifier" "subscript_expression" "primary_expression" "literal_type" "abstract_method_signature" "pair_pattern")) - ("string_fragment" ("string")) - ("subscript_expression" ("primary_expression" "pattern" "type_query" "instantiation_expression" "rest_pattern" "augmented_assignment_expression" "for_in_statement" "assignment_expression")) - ("super" ("primary_expression")) - ("switch_body" ("switch_statement")) - ("switch_case" ("switch_body")) - ("switch_default" ("switch_body")) - ("switch_statement" ("statement")) - ("template_literal_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("template_string" ("primary_expression" "call_expression")) - ("template_substitution" ("template_string")) - ("template_type" ("template_literal_type")) - ("ternary_expression" ("expression")) - ("this" ("primary_expression" "required_parameter" "type_predicate" "asserts" "optional_parameter")) - ("this_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("throw_statement" ("statement")) - ("true" ("primary_expression" "literal_type")) - ("try_statement" ("statement")) - ("tuple_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("type_alias_declaration" ("declaration")) - ("type_annotation" ("parenthesized_expression" "method_signature" "call_signature" "method_definition" "required_parameter" "function_signature" "generator_function_declaration" "function_declaration" "property_signature" "variable_declarator" "catch_clause" "public_field_definition" "arrow_function" "generator_function" "optional_parameter" "function" "abstract_method_signature" "construct_signature" "index_signature")) - ("type_arguments" ("jsx_self_closing_element" "instantiation_expression" "generic_type" "call_expression" "jsx_opening_element" "extends_clause" "new_expression")) - ("type_identifier" ("interface_declaration" "function_type" "extends_type_clause" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "generic_type" "class_declaration" "tuple_type" "lookup_type" "default_type" "infer_type" "class" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "abstract_class_declaration" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "nested_type_identifier" "readonly_type" "type_parameter")) - ("type_parameter" ("type_parameters")) - ("type_parameters" ("interface_declaration" "method_signature" "abstract_method_signature" "function_type" "method_definition" "construct_signature" "arrow_function" "function_signature" "generator_function" "abstract_class_declaration" "constructor_type" "function_declaration" "class_declaration" "function" "generator_function_declaration" "call_signature" "class" "type_alias_declaration")) - ("type_predicate" ("type_predicate_annotation" "asserts" "function_type")) - ("type_predicate_annotation" ("abstract_method_signature" "method_definition" "arrow_function" "function_signature" "generator_function" "generator_function_declaration" "function_declaration" "method_signature" "call_signature" "function")) - ("type_query" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("unary_expression" ("literal_type" "expression")) - ("undefined" ("primary_expression" "literal_type" "pattern" "rest_pattern" "for_in_statement" "assignment_expression")) - ("union_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("update_expression" ("expression")) - ("variable_declaration" ("for_statement" "declaration")) - ("variable_declarator" ("variable_declaration" "lexical_declaration")) - ("while_statement" ("statement")) - ("with_statement" ("statement")) - ("yield_expression" ("expression")) - ) - ) +(defconst combobulate-rules-tsx-inverse + '(("abstract_class_declaration" ("declaration")) + ("abstract_method_signature" ("class_body")) + ("accessibility_modifier" ("method_definition" "method_signature" "optional_parameter" "required_parameter" "public_field_definition" "abstract_method_signature" "property_signature")) + ("ambient_declaration" ("declaration")) + ("arguments" ("new_expression" "call_expression")) + ("array" ("primary_expression")) + ("array_pattern" ("object_assignment_pattern" "variable_declarator" "assignment_expression" "rest_pattern" "pattern" "for_in_statement" "catch_clause")) + ("array_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("arrow_function" ("primary_expression")) + ("as_expression" ("expression")) + ("asserts" ("function_type" "asserts_annotation")) + ("asserts_annotation" ("arrow_function" "method_definition" "function_signature" "method_signature" "generator_function_declaration" "call_signature" "function" "abstract_method_signature" "generator_function" "function_declaration")) + ("assignment_expression" ("expression")) + ("assignment_pattern" ("pair_pattern" "array_pattern")) + ("augmented_assignment_expression" ("expression")) + ("await_expression" ("expression")) + ("binary_expression" ("expression")) + ("break_statement" ("statement")) + ("call_expression" ("primary_expression" "type_query" "decorator")) + ("call_signature" ("object_type")) + ("catch_clause" ("try_statement")) + ("class" ("primary_expression")) + ("class_body" ("class_declaration" "class" "abstract_class_declaration")) + ("class_declaration" ("declaration")) + ("class_heritage" ("class_declaration" "class" "abstract_class_declaration")) + ("class_static_block" ("class_body")) + ("computed_property_name" ("enum_assignment" "enum_body" "method_definition" "method_signature" "pair_pattern" "pair" "public_field_definition" "abstract_method_signature" "property_signature")) + ("conditional_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("constraint" ("type_parameter")) + ("construct_signature" ("object_type")) + ("constructor_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "constructor_type" "parenthesized_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "opting_type_annotation" "constraint" "lookup_type")) + ("continue_statement" ("statement")) + ("debugger_statement" ("statement")) + ("declaration" ("ambient_declaration" "statement" "export_statement")) + ("decorator" ("class_declaration" "export_statement" "class_body" "optional_parameter" "required_parameter" "class" "abstract_class_declaration")) + ("default_type" ("type_parameter")) + ("do_statement" ("statement")) + ("else_clause" ("if_statement")) + ("empty_statement" ("statement" "for_statement")) + ("enum_assignment" ("enum_body")) + ("enum_body" ("enum_declaration")) + ("enum_declaration" ("declaration")) + ("escape_sequence" ("string" "template_string")) + ("existential_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("export_clause" ("export_statement")) + ("export_specifier" ("export_clause")) + ("export_statement" ("statement" "object_type")) + ("expression" ("arrow_function" "extends_clause" "update_expression" "satisfies_expression" "jsx_expression" "binary_expression" "computed_property_name" "parenthesized_expression" "enum_assignment" "call_expression" "for_statement" "instantiation_expression" "spread_element" "as_expression" "member_expression" "optional_parameter" "return_statement" "for_in_statement" "public_field_definition" "yield_expression" "await_expression" "object_assignment_pattern" "ternary_expression" "expression_statement" "assignment_expression" "pair" "switch_case" "subscript_expression" "variable_declarator" "export_statement" "non_null_expression" "assignment_pattern" "throw_statement" "unary_expression" "required_parameter" "arguments" "augmented_assignment_expression" "template_substitution" "array" "sequence_expression")) + ("expression_statement" ("statement" "for_statement")) + ("extends_clause" ("class_heritage")) + ("extends_type_clause" ("interface_declaration")) + ("false" ("primary_expression" "literal_type")) + ("finally_clause" ("try_statement")) + ("flow_maybe_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("for_in_statement" ("statement")) + ("for_statement" ("statement")) + ("formal_parameters" ("arrow_function" "function_declaration" "method_definition" "function_signature" "method_signature" "construct_signature" "function_type" "generator_function_declaration" "constructor_type" "function" "abstract_method_signature" "generator_function" "call_signature")) + ("function" ("primary_expression")) + ("function_declaration" ("declaration")) + ("function_signature" ("declaration")) + ("function_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "constructor_type" "parenthesized_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "opting_type_annotation" "constraint" "lookup_type")) + ("generator_function" ("primary_expression")) + ("generator_function_declaration" ("declaration")) + ("generic_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "extends_type_clause" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("glimmer_closing_tag" ("glimmer_template")) + ("glimmer_opening_tag" ("glimmer_template")) + ("glimmer_template" ("expression")) + ("hash_bang_line" ("program")) + ("identifier" ("import_require_clause" "arrow_function" "jsx_self_closing_element" "jsx_namespace_name" "namespace_import" "nested_identifier" "type_query" "jsx_opening_element" "import_clause" "function_declaration" "instantiation_expression" "nested_type_identifier" "member_expression" "optional_parameter" "enum_declaration" "namespace_export" "pattern" "decorator" "for_in_statement" "catch_clause" "generator_function_declaration" "generator_function" "import_alias" "function_signature" "assignment_expression" "export_specifier" "asserts" "function" "index_signature" "variable_declarator" "type_predicate" "export_statement" "primary_expression" "internal_module" "required_parameter" "jsx_closing_element" "rest_pattern" "augmented_assignment_expression" "import_specifier" "module")) + ("if_statement" ("statement")) + ("implements_clause" ("class_heritage")) + ("import" ("primary_expression" "instantiation_expression")) + ("import_alias" ("declaration")) + ("import_clause" ("import_statement")) + ("import_require_clause" ("import_statement")) + ("import_specifier" ("named_imports")) + ("import_statement" ("statement")) + ("index_signature" ("object_type" "class_body")) + ("index_type_query" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("infer_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "opting_type_annotation" "constraint" "lookup_type")) + ("instantiation_expression" ("expression" "type_query")) + ("interface_declaration" ("declaration")) + ("internal_module" ("expression" "declaration")) + ("intersection_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("jsx_attribute" ("jsx_self_closing_element" "jsx_opening_element")) + ("jsx_closing_element" ("jsx_element")) + ("jsx_element" ("expression" "jsx_element" "jsx_attribute")) + ("jsx_expression" ("jsx_self_closing_element" "jsx_element" "jsx_attribute" "jsx_opening_element")) + ("jsx_namespace_name" ("jsx_closing_element" "jsx_self_closing_element" "jsx_attribute" "jsx_opening_element")) + ("jsx_opening_element" ("jsx_element")) + ("jsx_self_closing_element" ("expression" "jsx_element" "jsx_attribute")) + ("jsx_text" ("jsx_element")) + ("labeled_statement" ("statement")) + ("lexical_declaration" ("for_statement" "declaration")) + ("literal_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("lookup_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("mapped_type_clause" ("index_signature")) + ("member_expression" ("jsx_self_closing_element" "instantiation_expression" "primary_expression" "assignment_expression" "member_expression" "nested_identifier" "jsx_closing_element" "rest_pattern" "augmented_assignment_expression" "pattern" "decorator" "for_in_statement" "jsx_opening_element" "type_query")) + ("meta_property" ("primary_expression")) + ("method_definition" ("object" "class_body")) + ("method_signature" ("object_type" "class_body")) + ("module" ("declaration")) + ("named_imports" ("import_clause")) + ("namespace_export" ("export_statement")) + ("namespace_import" ("import_clause")) + ("nested_identifier" ("import_alias" "module" "nested_type_identifier" "internal_module")) + ("nested_type_identifier" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "generic_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "extends_type_clause" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("new_expression" ("expression")) + ("non_null_expression" ("primary_expression" "assignment_expression" "rest_pattern" "augmented_assignment_expression" "pattern" "for_in_statement")) + ("null" ("primary_expression" "literal_type")) + ("number" ("enum_assignment" "enum_body" "method_definition" "method_signature" "primary_expression" "unary_expression" "pair_pattern" "literal_type" "pair" "public_field_definition" "abstract_method_signature" "subscript_expression" "property_signature")) + ("object" ("primary_expression")) + ("object_assignment_pattern" ("object_pattern")) + ("object_pattern" ("object_assignment_pattern" "variable_declarator" "assignment_expression" "rest_pattern" "pattern" "for_in_statement" "catch_clause")) + ("object_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "interface_declaration" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("omitting_type_annotation" ("index_signature")) + ("opting_type_annotation" ("index_signature")) + ("optional_chain" ("subscript_expression" "member_expression")) + ("optional_parameter" ("formal_parameters" "tuple_type")) + ("optional_type" ("tuple_type")) + ("override_modifier" ("method_definition" "method_signature" "optional_parameter" "required_parameter" "public_field_definition" "property_signature")) + ("pair" ("object")) + ("pair_pattern" ("object_pattern")) + ("parenthesized_expression" ("primary_expression" "assignment_expression" "do_statement" "if_statement" "while_statement" "with_statement" "switch_statement" "augmented_assignment_expression" "for_in_statement")) + ("parenthesized_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("pattern" ("assignment_pattern" "array_pattern" "optional_parameter" "pair_pattern" "required_parameter")) + ("predefined_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "subscript_expression" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("primary_expression" ("expression" "new_expression")) + ("private_property_identifier" ("enum_assignment" "enum_body" "method_definition" "method_signature" "member_expression" "pair_pattern" "pair" "public_field_definition" "abstract_method_signature" "property_signature")) + ("property_identifier" ("ambient_declaration" "enum_assignment" "enum_body" "method_definition" "method_signature" "member_expression" "nested_identifier" "pair_pattern" "pair" "jsx_attribute" "public_field_definition" "abstract_method_signature" "property_signature")) + ("property_signature" ("object_type")) + ("public_field_definition" ("class_body")) + ("readonly_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "constructor_type" "parenthesized_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "opting_type_annotation" "constraint" "lookup_type")) + ("regex" ("primary_expression")) + ("regex_flags" ("regex")) + ("regex_pattern" ("regex")) + ("required_parameter" ("formal_parameters" "tuple_type")) + ("rest_pattern" ("required_parameter" "pattern" "object_pattern")) + ("rest_type" ("tuple_type")) + ("return_statement" ("statement")) + ("satisfies_expression" ("expression")) + ("sequence_expression" ("parenthesized_expression" "for_statement" "throw_statement" "expression_statement" "return_statement" "jsx_expression" "template_substitution" "for_in_statement" "switch_case" "subscript_expression" "sequence_expression")) + ("shorthand_property_identifier" ("object")) + ("shorthand_property_identifier_pattern" ("object_assignment_pattern" "object_pattern")) + ("spread_element" ("array" "jsx_expression" "arguments" "object")) + ("statement" ("for_statement" "statement_block" "do_statement" "if_statement" "while_statement" "with_statement" "labeled_statement" "program" "for_in_statement" "switch_case" "switch_default" "else_clause")) + ("statement_block" ("ambient_declaration" "arrow_function" "method_definition" "statement" "class_static_block" "generator_function_declaration" "internal_module" "function" "finally_clause" "module" "catch_clause" "generator_function" "try_statement" "function_declaration")) + ("statement_identifier" ("continue_statement" "break_statement" "labeled_statement")) + ("string" ("import_require_clause" "import_statement" "method_signature" "pair_pattern" "literal_type" "enum_assignment" "method_definition" "namespace_export" "public_field_definition" "abstract_method_signature" "export_specifier" "pair" "jsx_attribute" "subscript_expression" "property_signature" "enum_body" "export_statement" "primary_expression" "internal_module" "import_specifier" "module")) + ("string_fragment" ("string")) + ("subscript_expression" ("instantiation_expression" "primary_expression" "assignment_expression" "rest_pattern" "type_query" "augmented_assignment_expression" "pattern" "for_in_statement")) + ("super" ("primary_expression")) + ("switch_body" ("switch_statement")) + ("switch_case" ("switch_body")) + ("switch_default" ("switch_body")) + ("switch_statement" ("statement")) + ("template_literal_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("template_string" ("primary_expression" "call_expression")) + ("template_substitution" ("template_string")) + ("template_type" ("template_literal_type")) + ("ternary_expression" ("expression")) + ("this" ("type_predicate" "primary_expression" "optional_parameter" "asserts" "required_parameter")) + ("this_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("throw_statement" ("statement")) + ("true" ("primary_expression" "literal_type")) + ("try_statement" ("statement")) + ("tuple_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("type_alias_declaration" ("declaration")) + ("type_annotation" ("arrow_function" "method_signature" "function_declaration" "parenthesized_expression" "method_definition" "optional_parameter" "public_field_definition" "abstract_method_signature" "catch_clause" "generator_function_declaration" "generator_function" "function_signature" "construct_signature" "function" "property_signature" "index_signature" "call_signature" "variable_declarator" "required_parameter")) + ("type_arguments" ("new_expression" "extends_clause" "call_expression" "jsx_self_closing_element" "instantiation_expression" "jsx_opening_element" "generic_type")) + ("type_identifier" ("ambient_declaration" "class_declaration" "intersection_type" "satisfies_expression" "type_arguments" "class" "index_type_query" "abstract_class_declaration" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "nested_type_identifier" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "generic_type" "default_type" "rest_type" "interface_declaration" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "extends_type_clause" "flow_maybe_type" "opting_type_annotation" "type_parameter" "lookup_type")) + ("type_parameter" ("type_parameters")) + ("type_parameters" ("arrow_function" "class_declaration" "type_alias_declaration" "function_declaration" "interface_declaration" "function_signature" "method_definition" "method_signature" "construct_signature" "function_type" "generator_function_declaration" "constructor_type" "function" "abstract_method_signature" "class" "generator_function" "abstract_class_declaration" "call_signature")) + ("type_predicate" ("asserts" "function_type" "type_predicate_annotation")) + ("type_predicate_annotation" ("arrow_function" "method_definition" "function_signature" "method_signature" "generator_function_declaration" "call_signature" "function" "abstract_method_signature" "generator_function" "function_declaration")) + ("type_query" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("unary_expression" ("expression" "literal_type")) + ("undefined" ("primary_expression" "assignment_expression" "rest_pattern" "literal_type" "pattern" "for_in_statement")) + ("union_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("update_expression" ("expression")) + ("variable_declaration" ("for_statement" "declaration")) + ("variable_declarator" ("lexical_declaration" "variable_declaration")) + ("while_statement" ("statement")) + ("with_statement" ("statement")) + ("yield_expression" ("expression")) + ) +) ;; END Inverse production rules for tsx ;; START All node types in tsx -(defconst combobulate-rules-tsx-types - '("_primary_type" "abstract_class_declaration" "abstract_method_signature" "accessibility_modifier" "ambient_declaration" "arguments" "array" "array_pattern" "array_type" "arrow_function" "as_expression" "asserts" "asserts_annotation" "assignment_expression" "assignment_pattern" "augmented_assignment_expression" "await_expression" "binary_expression" "break_statement" "call_expression" "call_signature" "catch_clause" "class" "class_body" "class_declaration" "class_heritage" "class_static_block" "comment" "computed_property_name" "conditional_type" "constraint" "construct_signature" "constructor_type" "continue_statement" "debugger_statement" "declaration" "decorator" "default_type" "do_statement" "else_clause" "empty_statement" "enum_assignment" "enum_body" "enum_declaration" "escape_sequence" "existential_type" "export_clause" "export_specifier" "export_statement" "expression" "expression_statement" "extends_clause" "extends_type_clause" "false" "finally_clause" "flow_maybe_type" "for_in_statement" "for_statement" "formal_parameters" "function" "function_declaration" "function_signature" "function_type" "generator_function" "generator_function_declaration" "generic_type" "glimmer_closing_tag" "glimmer_opening_tag" "glimmer_template" "hash_bang_line" "identifier" "if_statement" "implements_clause" "import" "import_alias" "import_clause" "import_require_clause" "import_specifier" "import_statement" "index_signature" "index_type_query" "infer_type" "instantiation_expression" "interface_declaration" "internal_module" "intersection_type" "jsx_attribute" "jsx_closing_element" "jsx_element" "jsx_expression" "jsx_namespace_name" "jsx_opening_element" "jsx_self_closing_element" "jsx_text" "labeled_statement" "lexical_declaration" "literal_type" "lookup_type" "mapped_type_clause" "member_expression" "meta_property" "method_definition" "method_signature" "module" "named_imports" "namespace_export" "namespace_import" "nested_identifier" "nested_type_identifier" "new_expression" "non_null_expression" "null" "number" "object" "object_assignment_pattern" "object_pattern" "object_type" "omitting_type_annotation" "opting_type_annotation" "optional_chain" "optional_parameter" "optional_type" "override_modifier" "pair" "pair_pattern" "parenthesized_expression" "parenthesized_type" "pattern" "predefined_type" "primary_expression" "private_property_identifier" "program" "property_identifier" "property_signature" "public_field_definition" "readonly_type" "regex" "regex_flags" "regex_pattern" "required_parameter" "rest_pattern" "rest_type" "return_statement" "satisfies_expression" "sequence_expression" "shorthand_property_identifier" "shorthand_property_identifier_pattern" "spread_element" "statement" "statement_block" "statement_identifier" "string" "string_fragment" "subscript_expression" "super" "switch_body" "switch_case" "switch_default" "switch_statement" "template_literal_type" "template_string" "template_substitution" "template_type" "ternary_expression" "this" "this_type" "throw_statement" "true" "try_statement" "tuple_type" "type_alias_declaration" "type_annotation" "type_arguments" "type_identifier" "type_parameter" "type_parameters" "type_predicate" "type_predicate_annotation" "type_query" "unary_expression" "undefined" "union_type" "update_expression" "variable_declaration" "variable_declarator" "while_statement" "with_statement" "yield_expression") - ) +(defconst combobulate-rules-tsx-types + '("_primary_type" "abstract_class_declaration" "abstract_method_signature" "accessibility_modifier" "ambient_declaration" "arguments" "array" "array_pattern" "array_type" "arrow_function" "as_expression" "asserts" "asserts_annotation" "assignment_expression" "assignment_pattern" "augmented_assignment_expression" "await_expression" "binary_expression" "break_statement" "call_expression" "call_signature" "catch_clause" "class" "class_body" "class_declaration" "class_heritage" "class_static_block" "comment" "computed_property_name" "conditional_type" "constraint" "construct_signature" "constructor_type" "continue_statement" "debugger_statement" "declaration" "decorator" "default_type" "do_statement" "else_clause" "empty_statement" "enum_assignment" "enum_body" "enum_declaration" "escape_sequence" "existential_type" "export_clause" "export_specifier" "export_statement" "expression" "expression_statement" "extends_clause" "extends_type_clause" "false" "finally_clause" "flow_maybe_type" "for_in_statement" "for_statement" "formal_parameters" "function" "function_declaration" "function_signature" "function_type" "generator_function" "generator_function_declaration" "generic_type" "glimmer_closing_tag" "glimmer_opening_tag" "glimmer_template" "hash_bang_line" "identifier" "if_statement" "implements_clause" "import" "import_alias" "import_clause" "import_require_clause" "import_specifier" "import_statement" "index_signature" "index_type_query" "infer_type" "instantiation_expression" "interface_declaration" "internal_module" "intersection_type" "jsx_attribute" "jsx_closing_element" "jsx_element" "jsx_expression" "jsx_namespace_name" "jsx_opening_element" "jsx_self_closing_element" "jsx_text" "labeled_statement" "lexical_declaration" "literal_type" "lookup_type" "mapped_type_clause" "member_expression" "meta_property" "method_definition" "method_signature" "module" "named_imports" "namespace_export" "namespace_import" "nested_identifier" "nested_type_identifier" "new_expression" "non_null_expression" "null" "number" "object" "object_assignment_pattern" "object_pattern" "object_type" "omitting_type_annotation" "opting_type_annotation" "optional_chain" "optional_parameter" "optional_type" "override_modifier" "pair" "pair_pattern" "parenthesized_expression" "parenthesized_type" "pattern" "predefined_type" "primary_expression" "private_property_identifier" "program" "property_identifier" "property_signature" "public_field_definition" "readonly_type" "regex" "regex_flags" "regex_pattern" "required_parameter" "rest_pattern" "rest_type" "return_statement" "satisfies_expression" "sequence_expression" "shorthand_property_identifier" "shorthand_property_identifier_pattern" "spread_element" "statement" "statement_block" "statement_identifier" "string" "string_fragment" "subscript_expression" "super" "switch_body" "switch_case" "switch_default" "switch_statement" "template_literal_type" "template_string" "template_substitution" "template_type" "ternary_expression" "this" "this_type" "throw_statement" "true" "try_statement" "tuple_type" "type_alias_declaration" "type_annotation" "type_arguments" "type_identifier" "type_parameter" "type_parameters" "type_predicate" "type_predicate_annotation" "type_query" "unary_expression" "undefined" "union_type" "update_expression" "variable_declaration" "variable_declarator" "while_statement" "with_statement" "yield_expression") +) ;; END All node types in tsx +;; START All supertypes in tsx +(defconst combobulate-rules-tsx-supertypes + '("_primary_type" "declaration" "expression" "pattern" "primary_expression" "statement") +) +;; END All supertypes in tsx ;; START Production rules for css -(defconst combobulate-rules-css - '(("adjacent_sibling_selector" (:*unnamed* ("child_selector" "tag_name" "pseudo_element_selector" "nesting_selector" "universal_selector" "id_selector" "attribute_selector" "namespace_selector" "descendant_selector" "adjacent_sibling_selector" "string_value" "sibling_selector" "class_selector" "pseudo_class_selector"))) - ("arguments" (:*unnamed* ("plain_value" "nesting_selector" "id_selector" "attribute_selector" "important" "namespace_selector" "binary_expression" "call_expression" "descendant_selector" "sibling_selector" "string_value" "color_value" "class_selector" "pseudo_class_selector" "child_selector" "pseudo_element_selector" "grid_value" "universal_selector" "float_value" "integer_value" "adjacent_sibling_selector" "parenthesized_value" "tag_name"))) - ("at_rule" (:*unnamed* ("feature_query" "keyword_query" "parenthesized_query" "selector_query" "at_keyword" "binary_query" "unary_query" "block"))) - ("attribute_name" (:*unnamed* ("child_selector" "tag_name" "pseudo_element_selector" "nesting_selector" "universal_selector" "id_selector" "attribute_selector" "namespace_selector" "descendant_selector" "adjacent_sibling_selector" "string_value" "sibling_selector" "class_selector" "pseudo_class_selector"))) - ("attribute_selector" (:*unnamed* ("plain_value" "nesting_selector" "id_selector" "attribute_selector" "important" "namespace_selector" "binary_expression" "call_expression" "descendant_selector" "sibling_selector" "string_value" "color_value" "class_selector" "pseudo_class_selector" "child_selector" "pseudo_element_selector" "grid_value" "universal_selector" "attribute_name" "float_value" "integer_value" "adjacent_sibling_selector" "parenthesized_value" "tag_name"))) - ("binary_expression" (:*unnamed* ("string_value" "plain_value" "grid_value" "important" "float_value" "integer_value" "binary_expression" "call_expression" "parenthesized_value" "color_value"))) - ("binary_query" (:*unnamed* ("selector_query" "feature_query" "binary_query" "unary_query" "keyword_query" "parenthesized_query"))) - ("block" (:*unnamed* ("rule_set" "media_statement" "supports_statement" "charset_statement" "import_statement" "at_rule" "postcss_statement" "declaration" "namespace_statement" "keyframes_statement"))) - ("call_expression" (:*unnamed* ("arguments" "function_name"))) - ("charset_statement" (:*unnamed* ("string_value" "plain_value" "grid_value" "important" "float_value" "integer_value" "binary_expression" "call_expression" "parenthesized_value" "color_value"))) - ("child_selector" (:*unnamed* ("child_selector" "tag_name" "pseudo_element_selector" "nesting_selector" "universal_selector" "id_selector" "attribute_selector" "namespace_selector" "descendant_selector" "adjacent_sibling_selector" "string_value" "sibling_selector" "class_selector" "pseudo_class_selector"))) - ("class_selector" (:*unnamed* ("child_selector" "tag_name" "class_name" "pseudo_element_selector" "nesting_selector" "universal_selector" "id_selector" "attribute_selector" "namespace_selector" "descendant_selector" "adjacent_sibling_selector" "string_value" "sibling_selector" "class_selector" "pseudo_class_selector"))) - ("declaration" (:*unnamed* ("string_value" "plain_value" "grid_value" "important" "float_value" "integer_value" "binary_expression" "call_expression" "property_name" "parenthesized_value" "color_value"))) - ("descendant_selector" (:*unnamed* ("child_selector" "tag_name" "pseudo_element_selector" "nesting_selector" "universal_selector" "id_selector" "attribute_selector" "namespace_selector" "descendant_selector" "adjacent_sibling_selector" "string_value" "sibling_selector" "class_selector" "pseudo_class_selector"))) - ("feature_query" (:*unnamed* ("string_value" "plain_value" "grid_value" "important" "float_value" "feature_name" "binary_expression" "call_expression" "integer_value" "parenthesized_value" "color_value"))) - ("float_value" (:*unnamed* ("unit"))) - ("grid_value" (:*unnamed* ("string_value" "plain_value" "grid_value" "important" "float_value" "integer_value" "binary_expression" "call_expression" "parenthesized_value" "color_value"))) - ("id_selector" (:*unnamed* ("child_selector" "id_name" "tag_name" "pseudo_element_selector" "nesting_selector" "universal_selector" "id_selector" "attribute_selector" "namespace_selector" "descendant_selector" "adjacent_sibling_selector" "string_value" "sibling_selector" "class_selector" "pseudo_class_selector"))) - ("import_statement" (:*unnamed* ("feature_query" "plain_value" "important" "binary_expression" "call_expression" "string_value" "color_value" "keyword_query" "grid_value" "parenthesized_query" "selector_query" "float_value" "integer_value" "unary_query" "binary_query" "parenthesized_value"))) - ("integer_value" (:*unnamed* ("unit"))) - ("keyframe_block" (:*unnamed* ("integer_value" "to" "from" "block"))) - ("keyframe_block_list" (:*unnamed* ("keyframe_block"))) - ("keyframes_statement" (:*unnamed* ("at_keyword" "keyframe_block_list" "keyframes_name"))) - ("media_statement" (:*unnamed* ("selector_query" "feature_query" "binary_query" "unary_query" "keyword_query" "block" "parenthesized_query"))) - ("namespace_selector" (:*unnamed* ("child_selector" "tag_name" "pseudo_element_selector" "nesting_selector" "universal_selector" "id_selector" "attribute_selector" "namespace_selector" "descendant_selector" "adjacent_sibling_selector" "string_value" "sibling_selector" "class_selector" "pseudo_class_selector"))) - ("namespace_statement" (:*unnamed* ("namespace_name" "string_value" "call_expression"))) - ("parenthesized_query" (:*unnamed* ("selector_query" "feature_query" "binary_query" "unary_query" "keyword_query" "parenthesized_query"))) - ("parenthesized_value" (:*unnamed* ("string_value" "plain_value" "grid_value" "important" "float_value" "integer_value" "binary_expression" "call_expression" "parenthesized_value" "color_value"))) - ("postcss_statement" (:*unnamed* ("string_value" "plain_value" "grid_value" "important" "float_value" "at_keyword" "binary_expression" "call_expression" "integer_value" "parenthesized_value" "color_value"))) - ("pseudo_class_selector" (:*unnamed* ("nesting_selector" "id_selector" "attribute_selector" "namespace_selector" "descendant_selector" "sibling_selector" "string_value" "class_selector" "pseudo_class_selector" "child_selector" "arguments" "class_name" "pseudo_element_selector" "universal_selector" "adjacent_sibling_selector" "tag_name"))) - ("pseudo_element_selector" (:*unnamed* ("child_selector" "arguments" "tag_name" "pseudo_element_selector" "nesting_selector" "universal_selector" "id_selector" "attribute_selector" "namespace_selector" "descendant_selector" "adjacent_sibling_selector" "string_value" "sibling_selector" "class_selector" "pseudo_class_selector"))) - ("rule_set" (:*unnamed* ("selectors" "block"))) - ("selector_query" (:*unnamed* ("child_selector" "tag_name" "pseudo_element_selector" "nesting_selector" "universal_selector" "id_selector" "attribute_selector" "namespace_selector" "descendant_selector" "adjacent_sibling_selector" "string_value" "sibling_selector" "class_selector" "pseudo_class_selector"))) - ("selectors" (:*unnamed* ("child_selector" "tag_name" "pseudo_element_selector" "nesting_selector" "universal_selector" "id_selector" "attribute_selector" "namespace_selector" "descendant_selector" "adjacent_sibling_selector" "string_value" "sibling_selector" "class_selector" "pseudo_class_selector"))) - ("sibling_selector" (:*unnamed* ("child_selector" "tag_name" "pseudo_element_selector" "nesting_selector" "universal_selector" "id_selector" "attribute_selector" "namespace_selector" "descendant_selector" "adjacent_sibling_selector" "string_value" "sibling_selector" "class_selector" "pseudo_class_selector"))) - ("stylesheet" (:*unnamed* ("rule_set" "media_statement" "supports_statement" "charset_statement" "import_statement" "at_rule" "declaration" "namespace_statement" "keyframes_statement"))) - ("supports_statement" (:*unnamed* ("selector_query" "feature_query" "binary_query" "unary_query" "keyword_query" "block" "parenthesized_query"))) - ("unary_query" (:*unnamed* ("selector_query" "feature_query" "binary_query" "unary_query" "keyword_query" "parenthesized_query"))) - ("at_keyword" (:*unnamed* nil)) - ("class_name" (:*unnamed* nil)) - ("comment" (:*unnamed* nil)) - ("feature_name" (:*unnamed* nil)) - ("from" (:*unnamed* nil)) - ("function_name" (:*unnamed* nil)) - ("id_name" (:*unnamed* nil)) - ("important" (:*unnamed* nil)) - ("js_comment" (:*unnamed* nil)) - ("keyframes_name" (:*unnamed* nil)) - ("keyword_query" (:*unnamed* nil)) - ("namespace_name" (:*unnamed* nil)) - ("nesting_selector" (:*unnamed* nil)) - ("plain_value" (:*unnamed* nil)) - ("property_name" (:*unnamed* nil)) - ("tag_name" (:*unnamed* nil)) - ("to" (:*unnamed* nil)) - ("unit" (:*unnamed* nil)) - )) +(defconst combobulate-rules-css + '(("adjacent_sibling_selector" (:*unnamed* ("descendant_selector" "child_selector" "id_selector" "nesting_selector" "pseudo_class_selector" "namespace_selector" "pseudo_element_selector" "sibling_selector" "universal_selector" "attribute_selector" "string_value" "adjacent_sibling_selector" "class_selector" "tag_name"))) + ("arguments" (:*unnamed* ("integer_value" "child_selector" "nesting_selector" "pseudo_class_selector" "float_value" "grid_value" "attribute_selector" "important" "string_value" "adjacent_sibling_selector" "class_selector" "binary_expression" "tag_name" "call_expression" "descendant_selector" "id_selector" "parenthesized_value" "pseudo_element_selector" "sibling_selector" "namespace_selector" "universal_selector" "plain_value" "color_value"))) + ("at_rule" (:*unnamed* ("keyword_query" "parenthesized_query" "selector_query" "block" "feature_query" "unary_query" "binary_query" "at_keyword"))) + ("attribute_name" (:*unnamed* ("descendant_selector" "child_selector" "id_selector" "nesting_selector" "pseudo_class_selector" "namespace_selector" "pseudo_element_selector" "sibling_selector" "universal_selector" "attribute_selector" "string_value" "adjacent_sibling_selector" "class_selector" "tag_name"))) + ("attribute_selector" (:*unnamed* ("integer_value" "child_selector" "nesting_selector" "pseudo_class_selector" "float_value" "grid_value" "attribute_selector" "important" "string_value" "adjacent_sibling_selector" "class_selector" "binary_expression" "tag_name" "call_expression" "descendant_selector" "id_selector" "parenthesized_value" "pseudo_element_selector" "sibling_selector" "namespace_selector" "universal_selector" "attribute_name" "plain_value" "color_value"))) + ("binary_expression" (:*unnamed* ("integer_value" "call_expression" "parenthesized_value" "float_value" "grid_value" "important" "string_value" "plain_value" "binary_expression" "color_value"))) + ("binary_query" (:*unnamed* ("feature_query" "unary_query" "keyword_query" "binary_query" "parenthesized_query" "selector_query"))) + ("block" (:*unnamed* ("keyframes_statement" "postcss_statement" "import_statement" "supports_statement" "at_rule" "charset_statement" "media_statement" "rule_set" "declaration" "namespace_statement"))) + ("call_expression" (:*unnamed* ("function_name" "arguments"))) + ("charset_statement" (:*unnamed* ("integer_value" "call_expression" "parenthesized_value" "float_value" "grid_value" "important" "string_value" "plain_value" "binary_expression" "color_value"))) + ("child_selector" (:*unnamed* ("descendant_selector" "child_selector" "id_selector" "nesting_selector" "pseudo_class_selector" "namespace_selector" "pseudo_element_selector" "sibling_selector" "universal_selector" "attribute_selector" "string_value" "adjacent_sibling_selector" "class_selector" "tag_name"))) + ("class_selector" (:*unnamed* ("descendant_selector" "child_selector" "id_selector" "nesting_selector" "pseudo_class_selector" "namespace_selector" "pseudo_element_selector" "sibling_selector" "universal_selector" "attribute_selector" "string_value" "adjacent_sibling_selector" "class_selector" "class_name" "tag_name"))) + ("color_value" (:*unnamed* nil)) + ("declaration" (:*unnamed* ("integer_value" "call_expression" "property_name" "parenthesized_value" "float_value" "grid_value" "important" "string_value" "plain_value" "binary_expression" "color_value"))) + ("descendant_selector" (:*unnamed* ("descendant_selector" "child_selector" "id_selector" "nesting_selector" "pseudo_class_selector" "namespace_selector" "pseudo_element_selector" "sibling_selector" "universal_selector" "attribute_selector" "string_value" "adjacent_sibling_selector" "class_selector" "tag_name"))) + ("feature_query" (:*unnamed* ("integer_value" "call_expression" "feature_name" "parenthesized_value" "float_value" "grid_value" "important" "string_value" "plain_value" "binary_expression" "color_value"))) + ("float_value" (:*unnamed* ("unit"))) + ("grid_value" (:*unnamed* ("integer_value" "call_expression" "parenthesized_value" "float_value" "grid_value" "important" "string_value" "plain_value" "binary_expression" "color_value"))) + ("id_selector" (:*unnamed* ("descendant_selector" "child_selector" "id_selector" "nesting_selector" "pseudo_class_selector" "namespace_selector" "pseudo_element_selector" "sibling_selector" "universal_selector" "attribute_selector" "string_value" "adjacent_sibling_selector" "class_selector" "id_name" "tag_name"))) + ("import_statement" (:*unnamed* ("integer_value" "float_value" "selector_query" "grid_value" "important" "string_value" "unary_query" "binary_expression" "call_expression" "keyword_query" "parenthesized_query" "parenthesized_value" "feature_query" "binary_query" "plain_value" "color_value"))) + ("integer_value" (:*unnamed* ("unit"))) + ("keyframe_block" (:*unnamed* ("from" "integer_value" "to" "block"))) + ("keyframe_block_list" (:*unnamed* ("keyframe_block"))) + ("keyframes_statement" (:*unnamed* ("keyframe_block_list" "at_keyword" "keyframes_name"))) + ("media_statement" (:*unnamed* ("feature_query" "unary_query" "keyword_query" "binary_query" "parenthesized_query" "selector_query" "block"))) + ("namespace_selector" (:*unnamed* ("descendant_selector" "child_selector" "id_selector" "nesting_selector" "pseudo_class_selector" "namespace_selector" "pseudo_element_selector" "sibling_selector" "universal_selector" "attribute_selector" "string_value" "adjacent_sibling_selector" "class_selector" "tag_name"))) + ("namespace_statement" (:*unnamed* ("string_value" "call_expression" "namespace_name"))) + ("parenthesized_query" (:*unnamed* ("feature_query" "unary_query" "keyword_query" "binary_query" "parenthesized_query" "selector_query"))) + ("parenthesized_value" (:*unnamed* ("integer_value" "call_expression" "parenthesized_value" "float_value" "grid_value" "important" "string_value" "plain_value" "binary_expression" "color_value"))) + ("postcss_statement" (:*unnamed* ("integer_value" "call_expression" "parenthesized_value" "float_value" "grid_value" "important" "string_value" "plain_value" "binary_expression" "color_value" "at_keyword"))) + ("pseudo_class_selector" (:*unnamed* ("child_selector" "nesting_selector" "pseudo_class_selector" "attribute_selector" "string_value" "adjacent_sibling_selector" "class_selector" "tag_name" "descendant_selector" "id_selector" "sibling_selector" "pseudo_element_selector" "namespace_selector" "universal_selector" "arguments" "class_name"))) + ("pseudo_element_selector" (:*unnamed* ("descendant_selector" "child_selector" "id_selector" "nesting_selector" "pseudo_class_selector" "namespace_selector" "pseudo_element_selector" "sibling_selector" "universal_selector" "attribute_selector" "string_value" "adjacent_sibling_selector" "arguments" "class_selector" "tag_name"))) + ("rule_set" (:*unnamed* ("selectors" "block"))) + ("selector_query" (:*unnamed* ("descendant_selector" "child_selector" "id_selector" "nesting_selector" "pseudo_class_selector" "namespace_selector" "pseudo_element_selector" "sibling_selector" "universal_selector" "attribute_selector" "string_value" "adjacent_sibling_selector" "class_selector" "tag_name"))) + ("selectors" (:*unnamed* ("descendant_selector" "child_selector" "id_selector" "nesting_selector" "pseudo_class_selector" "namespace_selector" "pseudo_element_selector" "sibling_selector" "universal_selector" "attribute_selector" "string_value" "adjacent_sibling_selector" "class_selector" "tag_name"))) + ("sibling_selector" (:*unnamed* ("descendant_selector" "child_selector" "id_selector" "nesting_selector" "pseudo_class_selector" "namespace_selector" "pseudo_element_selector" "sibling_selector" "universal_selector" "attribute_selector" "string_value" "adjacent_sibling_selector" "class_selector" "tag_name"))) + ("string_value" (:*unnamed* nil)) + ("stylesheet" (:*unnamed* ("keyframes_statement" "import_statement" "supports_statement" "at_rule" "charset_statement" "media_statement" "rule_set" "declaration" "namespace_statement"))) + ("supports_statement" (:*unnamed* ("feature_query" "unary_query" "keyword_query" "binary_query" "parenthesized_query" "selector_query" "block"))) + ("unary_query" (:*unnamed* ("feature_query" "unary_query" "keyword_query" "binary_query" "parenthesized_query" "selector_query"))) + ("universal_selector" (:*unnamed* nil)) + ("at_keyword" (:*unnamed* nil)) + ("class_name" (:*unnamed* nil)) + ("comment" (:*unnamed* nil)) + ("feature_name" (:*unnamed* nil)) + ("from" (:*unnamed* nil)) + ("function_name" (:*unnamed* nil)) + ("id_name" (:*unnamed* nil)) + ("important" (:*unnamed* nil)) + ("js_comment" (:*unnamed* nil)) + ("keyframes_name" (:*unnamed* nil)) + ("keyword_query" (:*unnamed* nil)) + ("namespace_name" (:*unnamed* nil)) + ("nesting_selector" (:*unnamed* nil)) + ("plain_value" (:*unnamed* nil)) + ("property_name" (:*unnamed* nil)) + ("tag_name" (:*unnamed* nil)) + ("to" (:*unnamed* nil)) + ("unit" (:*unnamed* nil)) +)) ;; END Production rules for css ;; START Inverse production rules for css -(defconst combobulate-rules-css-inverse - '(("adjacent_sibling_selector" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ("arguments" ("pseudo_element_selector" "call_expression" "pseudo_class_selector")) - ("at_keyword" ("postcss_statement" "at_rule" "keyframes_statement")) - ("at_rule" ("stylesheet" "block")) - ("attribute_name" ("attribute_selector")) - ("attribute_selector" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ("binary_expression" ("arguments" "feature_query" "grid_value" "charset_statement" "import_statement" "attribute_selector" "postcss_statement" "declaration" "binary_expression" "parenthesized_value")) - ("binary_query" ("media_statement" "supports_statement" "import_statement" "at_rule" "parenthesized_query" "unary_query" "binary_query")) - ("block" ("rule_set" "media_statement" "supports_statement" "keyframe_block" "at_rule")) - ("call_expression" ("arguments" "feature_query" "grid_value" "charset_statement" "import_statement" "attribute_selector" "postcss_statement" "declaration" "binary_expression" "parenthesized_value" "namespace_statement")) - ("charset_statement" ("stylesheet" "block")) - ("child_selector" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ("class_name" ("class_selector" "pseudo_class_selector")) - ("class_selector" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ("color_value" ("arguments" "feature_query" "grid_value" "charset_statement" "import_statement" "attribute_selector" "postcss_statement" "declaration" "binary_expression" "parenthesized_value")) - ("declaration" ("stylesheet" "block")) - ("descendant_selector" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ("feature_name" ("feature_query")) - ("feature_query" ("media_statement" "supports_statement" "import_statement" "at_rule" "parenthesized_query" "unary_query" "binary_query")) - ("float_value" ("arguments" "feature_query" "grid_value" "charset_statement" "import_statement" "attribute_selector" "postcss_statement" "declaration" "binary_expression" "parenthesized_value")) - ("from" ("keyframe_block")) - ("function_name" ("call_expression")) - ("grid_value" ("arguments" "feature_query" "grid_value" "charset_statement" "import_statement" "attribute_selector" "postcss_statement" "declaration" "binary_expression" "parenthesized_value")) - ("id_name" ("id_selector")) - ("id_selector" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ("import_statement" ("stylesheet" "block")) - ("important" ("arguments" "feature_query" "grid_value" "charset_statement" "import_statement" "attribute_selector" "postcss_statement" "declaration" "binary_expression" "parenthesized_value")) - ("integer_value" ("arguments" "feature_query" "grid_value" "charset_statement" "keyframe_block" "import_statement" "attribute_selector" "postcss_statement" "declaration" "binary_expression" "parenthesized_value")) - ("keyframe_block" ("keyframe_block_list")) - ("keyframe_block_list" ("keyframes_statement")) - ("keyframes_name" ("keyframes_statement")) - ("keyframes_statement" ("stylesheet" "block")) - ("keyword_query" ("media_statement" "supports_statement" "import_statement" "at_rule" "parenthesized_query" "unary_query" "binary_query")) - ("media_statement" ("stylesheet" "block")) - ("namespace_name" ("namespace_statement")) - ("namespace_selector" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ("namespace_statement" ("stylesheet" "block")) - ("nesting_selector" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ("parenthesized_query" ("media_statement" "supports_statement" "import_statement" "at_rule" "parenthesized_query" "unary_query" "binary_query")) - ("parenthesized_value" ("arguments" "feature_query" "grid_value" "charset_statement" "import_statement" "attribute_selector" "postcss_statement" "declaration" "binary_expression" "parenthesized_value")) - ("plain_value" ("arguments" "feature_query" "grid_value" "charset_statement" "import_statement" "attribute_selector" "postcss_statement" "declaration" "binary_expression" "parenthesized_value")) - ("postcss_statement" ("block")) - ("property_name" ("declaration")) - ("pseudo_class_selector" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ("pseudo_element_selector" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ("rule_set" ("stylesheet" "block")) - ("selector_query" ("media_statement" "supports_statement" "import_statement" "at_rule" "parenthesized_query" "unary_query" "binary_query")) - ("selectors" ("rule_set")) - ("sibling_selector" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ("string_value" ("attribute_selector" "binary_expression" "selectors" "class_selector" "child_selector" "grid_value" "selector_query" "feature_query" "charset_statement" "id_selector" "import_statement" "declaration" "namespace_selector" "descendant_selector" "namespace_statement" "pseudo_class_selector" "arguments" "pseudo_element_selector" "attribute_name" "postcss_statement" "adjacent_sibling_selector" "parenthesized_value" "sibling_selector")) - ("supports_statement" ("stylesheet" "block")) - ("tag_name" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ("to" ("keyframe_block")) - ("unary_query" ("media_statement" "supports_statement" "import_statement" "at_rule" "parenthesized_query" "unary_query" "binary_query")) - ("unit" ("float_value" "integer_value")) - ("universal_selector" ("child_selector" "arguments" "pseudo_element_selector" "attribute_name" "id_selector" "attribute_selector" "selector_query" "namespace_selector" "selectors" "descendant_selector" "adjacent_sibling_selector" "sibling_selector" "class_selector" "pseudo_class_selector")) - ) - ) +(defconst combobulate-rules-css-inverse + '(("adjacent_sibling_selector" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ("arguments" ("pseudo_element_selector" "call_expression" "pseudo_class_selector")) + ("at_keyword" ("at_rule" "keyframes_statement" "postcss_statement")) + ("at_rule" ("stylesheet" "block")) + ("attribute_name" ("attribute_selector")) + ("attribute_selector" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ("binary_expression" ("postcss_statement" "import_statement" "parenthesized_value" "grid_value" "attribute_selector" "feature_query" "arguments" "charset_statement" "binary_expression" "declaration")) + ("binary_query" ("import_statement" "parenthesized_query" "supports_statement" "at_rule" "unary_query" "binary_query" "media_statement")) + ("block" ("keyframe_block" "supports_statement" "at_rule" "media_statement" "rule_set")) + ("call_expression" ("postcss_statement" "import_statement" "parenthesized_value" "grid_value" "attribute_selector" "feature_query" "arguments" "charset_statement" "binary_expression" "declaration" "namespace_statement")) + ("charset_statement" ("stylesheet" "block")) + ("child_selector" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ("class_name" ("class_selector" "pseudo_class_selector")) + ("class_selector" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ("color_value" ("postcss_statement" "import_statement" "parenthesized_value" "grid_value" "attribute_selector" "feature_query" "arguments" "charset_statement" "binary_expression" "declaration")) + ("declaration" ("stylesheet" "block")) + ("descendant_selector" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ("feature_name" ("feature_query")) + ("feature_query" ("import_statement" "parenthesized_query" "supports_statement" "at_rule" "unary_query" "binary_query" "media_statement")) + ("float_value" ("postcss_statement" "import_statement" "parenthesized_value" "grid_value" "attribute_selector" "feature_query" "arguments" "charset_statement" "binary_expression" "declaration")) + ("from" ("keyframe_block")) + ("function_name" ("call_expression")) + ("grid_value" ("postcss_statement" "import_statement" "parenthesized_value" "grid_value" "attribute_selector" "feature_query" "arguments" "charset_statement" "binary_expression" "declaration")) + ("id_name" ("id_selector")) + ("id_selector" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ("import_statement" ("stylesheet" "block")) + ("important" ("postcss_statement" "import_statement" "parenthesized_value" "grid_value" "attribute_selector" "feature_query" "arguments" "charset_statement" "binary_expression" "declaration")) + ("integer_value" ("postcss_statement" "import_statement" "parenthesized_value" "keyframe_block" "grid_value" "attribute_selector" "feature_query" "arguments" "charset_statement" "binary_expression" "declaration")) + ("keyframe_block" ("keyframe_block_list")) + ("keyframe_block_list" ("keyframes_statement")) + ("keyframes_name" ("keyframes_statement")) + ("keyframes_statement" ("stylesheet" "block")) + ("keyword_query" ("import_statement" "parenthesized_query" "supports_statement" "at_rule" "unary_query" "binary_query" "media_statement")) + ("media_statement" ("stylesheet" "block")) + ("namespace_name" ("namespace_statement")) + ("namespace_selector" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ("namespace_statement" ("stylesheet" "block")) + ("nesting_selector" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ("parenthesized_query" ("import_statement" "parenthesized_query" "supports_statement" "at_rule" "unary_query" "binary_query" "media_statement")) + ("parenthesized_value" ("postcss_statement" "import_statement" "parenthesized_value" "grid_value" "attribute_selector" "feature_query" "arguments" "charset_statement" "binary_expression" "declaration")) + ("plain_value" ("postcss_statement" "import_statement" "parenthesized_value" "grid_value" "attribute_selector" "feature_query" "arguments" "charset_statement" "binary_expression" "declaration")) + ("postcss_statement" ("block")) + ("property_name" ("declaration")) + ("pseudo_class_selector" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ("pseudo_element_selector" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ("rule_set" ("stylesheet" "block")) + ("selector_query" ("import_statement" "parenthesized_query" "supports_statement" "at_rule" "unary_query" "binary_query" "media_statement")) + ("selectors" ("rule_set")) + ("sibling_selector" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ("string_value" ("import_statement" "pseudo_class_selector" "attribute_selector" "adjacent_sibling_selector" "binary_expression" "namespace_statement" "descendant_selector" "id_selector" "pseudo_element_selector" "attribute_name" "charset_statement" "selectors" "child_selector" "selector_query" "grid_value" "class_selector" "declaration" "postcss_statement" "parenthesized_value" "sibling_selector" "namespace_selector" "feature_query" "arguments")) + ("supports_statement" ("stylesheet" "block")) + ("tag_name" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ("to" ("keyframe_block")) + ("unary_query" ("import_statement" "parenthesized_query" "supports_statement" "at_rule" "unary_query" "binary_query" "media_statement")) + ("unit" ("float_value" "integer_value")) + ("universal_selector" ("descendant_selector" "child_selector" "id_selector" "pseudo_class_selector" "pseudo_element_selector" "namespace_selector" "sibling_selector" "selector_query" "attribute_name" "attribute_selector" "adjacent_sibling_selector" "arguments" "class_selector" "selectors")) + ) +) ;; END Inverse production rules for css ;; START All node types in css -(defconst combobulate-rules-css-types - '("adjacent_sibling_selector" "arguments" "at_keyword" "at_rule" "attribute_name" "attribute_selector" "binary_expression" "binary_query" "block" "call_expression" "charset_statement" "child_selector" "class_name" "class_selector" "color_value" "comment" "declaration" "descendant_selector" "feature_name" "feature_query" "float_value" "from" "function_name" "grid_value" "id_name" "id_selector" "import_statement" "important" "integer_value" "js_comment" "keyframe_block" "keyframe_block_list" "keyframes_name" "keyframes_statement" "keyword_query" "media_statement" "namespace_name" "namespace_selector" "namespace_statement" "nesting_selector" "parenthesized_query" "parenthesized_value" "plain_value" "postcss_statement" "property_name" "pseudo_class_selector" "pseudo_element_selector" "rule_set" "selector_query" "selectors" "sibling_selector" "string_value" "stylesheet" "supports_statement" "tag_name" "to" "unary_query" "unit" "universal_selector") - ) +(defconst combobulate-rules-css-types + '("adjacent_sibling_selector" "arguments" "at_keyword" "at_rule" "attribute_name" "attribute_selector" "binary_expression" "binary_query" "block" "call_expression" "charset_statement" "child_selector" "class_name" "class_selector" "color_value" "comment" "declaration" "descendant_selector" "feature_name" "feature_query" "float_value" "from" "function_name" "grid_value" "id_name" "id_selector" "import_statement" "important" "integer_value" "js_comment" "keyframe_block" "keyframe_block_list" "keyframes_name" "keyframes_statement" "keyword_query" "media_statement" "namespace_name" "namespace_selector" "namespace_statement" "nesting_selector" "parenthesized_query" "parenthesized_value" "plain_value" "postcss_statement" "property_name" "pseudo_class_selector" "pseudo_element_selector" "rule_set" "selector_query" "selectors" "sibling_selector" "string_value" "stylesheet" "supports_statement" "tag_name" "to" "unary_query" "unit" "universal_selector") +) ;; END All node types in css +;; START All supertypes in css +(defconst combobulate-rules-css-supertypes + nil +) +;; END All supertypes in css ;; START Production rules for typescript -(defconst combobulate-rules-typescript - '(("_primary_type" (:*unnamed* ("parenthesized_type" "type_query" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "conditional_type" "nested_type_identifier" "predefined_type" "existential_type" "union_type"))) - ("declaration" (:*unnamed* ("ambient_declaration" "interface_declaration" "internal_module" "module" "variable_declaration" "lexical_declaration" "function_signature" "generator_function_declaration" "abstract_class_declaration" "function_declaration" "class_declaration" "import_alias" "enum_declaration" "type_alias_declaration"))) - ("expression" (:*unnamed* ("type_assertion" "yield_expression" "as_expression" "binary_expression" "satisfies_expression" "augmented_assignment_expression" "new_expression" "internal_module" "assignment_expression" "primary_expression" "instantiation_expression" "update_expression" "await_expression" "glimmer_template" "ternary_expression" "unary_expression"))) - ("pattern" (:*unnamed* ("member_expression" "identifier" "undefined" "object_pattern" "array_pattern" "rest_pattern" "non_null_expression" "subscript_expression"))) - ("primary_expression" (:*unnamed* ("member_expression" "array" "identifier" "string" "undefined" "parenthesized_expression" "arrow_function" "generator_function" "template_string" "call_expression" "class" "function" "subscript_expression" "false" "number" "regex" "super" "import" "object" "true" "this" "null" "meta_property" "non_null_expression"))) - ("statement" (:*unnamed* ("continue_statement" "for_statement" "with_statement" "export_statement" "import_statement" "if_statement" "do_statement" "declaration" "return_statement" "throw_statement" "for_in_statement" "while_statement" "empty_statement" "switch_statement" "expression_statement" "break_statement" "debugger_statement" "try_statement" "statement_block" "labeled_statement"))) - ("abstract_class_declaration" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("type_identifier") :type_parameters ("type_parameters"))) - ("abstract_method_signature" (:*unnamed* ("accessibility_modifier") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("ambient_declaration" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "declaration" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "statement_block" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type" "property_identifier"))) - ("arguments" (:*unnamed* ("spread_element" "expression"))) - ("array" (:*unnamed* ("spread_element" "expression"))) - ("array_pattern" (:*unnamed* ("pattern" "assignment_pattern"))) - ("array_type" (:*unnamed* ("parenthesized_type" "type_query" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "conditional_type" "nested_type_identifier" "predefined_type" "existential_type" "union_type"))) - ("arrow_function" (:body ("statement_block" "expression") :parameter ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("as_expression" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "expression" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("asserts" (:*unnamed* ("this" "identifier" "type_predicate"))) - ("asserts_annotation" (:*unnamed* ("asserts"))) - ("assignment_expression" (:left ("member_expression" "identifier" "undefined" "object_pattern" "array_pattern" "parenthesized_expression" "non_null_expression" "subscript_expression") :right ("expression"))) - ("assignment_pattern" (:left ("pattern") :right ("expression"))) - ("augmented_assignment_expression" (:left ("member_expression" "identifier" "parenthesized_expression" "non_null_expression" "subscript_expression") :operator nil :right ("expression"))) - ("await_expression" (:*unnamed* ("expression"))) - ("binary_expression" (:left ("expression") :operator nil :right ("expression"))) - ("break_statement" (:label ("statement_identifier"))) - ("call_expression" (:arguments ("arguments" "template_string") :function ("expression") :type_arguments ("type_arguments"))) - ("call_signature" (:parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("catch_clause" (:body ("statement_block") :parameter ("object_pattern" "identifier" "array_pattern") :type ("type_annotation"))) - ("class" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("type_identifier") :type_parameters ("type_parameters"))) - ("class_body" (:*unnamed* ("method_signature" "class_static_block" "abstract_method_signature" "public_field_definition" "method_definition" "decorator" "index_signature"))) - ("class_declaration" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("type_identifier") :type_parameters ("type_parameters"))) - ("class_heritage" (:*unnamed* ("extends_clause" "implements_clause"))) - ("class_static_block" (:body ("statement_block"))) - ("computed_property_name" (:*unnamed* ("expression"))) - ("conditional_type" (:alternative ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :consequence ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :left ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :right ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("constraint" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("construct_signature" (:parameters ("formal_parameters") :type ("type_annotation") :type_parameters ("type_parameters"))) - ("constructor_type" (:parameters ("formal_parameters") :type ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :type_parameters ("type_parameters"))) - ("continue_statement" (:label ("statement_identifier"))) - ("decorator" (:*unnamed* ("member_expression" "identifier" "call_expression"))) - ("default_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("do_statement" (:body ("statement") :condition ("parenthesized_expression"))) - ("else_clause" (:*unnamed* ("statement"))) - ("enum_assignment" (:name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :value ("expression"))) - ("enum_body" (:*unnamed* ("enum_assignment") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier"))) - ("enum_declaration" (:body ("enum_body") :name ("identifier"))) - ("export_clause" (:*unnamed* ("export_specifier"))) - ("export_specifier" (:alias ("string" "identifier") :name ("string" "identifier"))) - ("export_statement" (:*unnamed* ("namespace_export" "export_clause" "identifier" "expression") :declaration ("declaration") :decorator ("decorator") :source ("string") :value ("expression"))) - ("expression_statement" (:*unnamed* ("sequence_expression" "expression"))) - ("extends_clause" (:type_arguments ("type_arguments") :value ("expression"))) - ("extends_type_clause" (:type ("type_identifier" "generic_type" "nested_type_identifier"))) - ("finally_clause" (:body ("statement_block"))) - ("flow_maybe_type" (:*unnamed* ("parenthesized_type" "type_query" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "conditional_type" "nested_type_identifier" "predefined_type" "existential_type" "union_type"))) - ("for_in_statement" (:body ("statement") :kind nil :left ("member_expression" "identifier" "undefined" "object_pattern" "array_pattern" "parenthesized_expression" "non_null_expression" "subscript_expression") :operator nil :right ("sequence_expression" "expression") :value ("expression"))) - ("for_statement" (:body ("statement") :condition ("expression_statement" "empty_statement") :increment ("sequence_expression" "expression") :initializer ("lexical_declaration" "expression_statement" "variable_declaration" "empty_statement"))) - ("formal_parameters" (:*unnamed* ("required_parameter" "optional_parameter"))) - ("function" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("function_declaration" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("function_signature" (:name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("function_type" (:parameters ("formal_parameters") :return_type ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "type_predicate" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "asserts" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :type_parameters ("type_parameters"))) - ("generator_function" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("generator_function_declaration" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("generic_type" (:name ("type_identifier" "nested_type_identifier") :type_arguments ("type_arguments"))) - ("glimmer_template" (:close_tag ("glimmer_closing_tag") :open_tag ("glimmer_opening_tag"))) - ("if_statement" (:alternative ("else_clause") :condition ("parenthesized_expression") :consequence ("statement"))) - ("implements_clause" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("import_alias" (:*unnamed* ("identifier" "nested_identifier"))) - ("import_clause" (:*unnamed* ("namespace_import" "identifier" "named_imports"))) - ("import_require_clause" (:*unnamed* ("identifier") :source ("string"))) - ("import_specifier" (:alias ("identifier") :name ("string" "identifier"))) - ("import_statement" (:*unnamed* ("import_clause" "import_require_clause") :source ("string"))) - ("index_signature" (:*unnamed* ("mapped_type_clause") :index_type ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :name ("identifier") :sign nil :type ("type_annotation" "opting_type_annotation" "omitting_type_annotation"))) - ("index_type_query" (:*unnamed* ("parenthesized_type" "type_query" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "conditional_type" "nested_type_identifier" "predefined_type" "existential_type" "union_type"))) - ("infer_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("instantiation_expression" (:*unnamed* ("expression") :function ("member_expression" "import" "identifier" "subscript_expression") :type_arguments ("type_arguments"))) - ("interface_declaration" (:*unnamed* ("extends_type_clause") :body ("object_type") :name ("type_identifier") :type_parameters ("type_parameters"))) - ("internal_module" (:body ("statement_block") :name ("string" "identifier" "nested_identifier"))) - ("intersection_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("jsx_attribute" (:*unnamed* ("jsx_expression" "jsx_namespace_name" "jsx_element" "string" "jsx_self_closing_element" "property_identifier"))) - ("jsx_closing_element" (:name ("member_expression" "jsx_namespace_name" "identifier"))) - ("jsx_element" (:*unnamed* ("jsx_expression" "jsx_element" "jsx_text" "jsx_self_closing_element") :close_tag ("jsx_closing_element") :open_tag ("jsx_opening_element"))) - ("jsx_expression" (:*unnamed* ("sequence_expression" "spread_element" "expression"))) - ("jsx_namespace_name" (:*unnamed* ("identifier"))) - ("jsx_opening_element" (:attribute ("jsx_expression" "jsx_attribute") :name ("member_expression" "jsx_namespace_name" "identifier") :type_arguments ("type_arguments"))) - ("jsx_self_closing_element" (:attribute ("jsx_expression" "jsx_attribute") :name ("member_expression" "jsx_namespace_name" "identifier") :type_arguments ("type_arguments"))) - ("labeled_statement" (:body ("statement") :label ("statement_identifier"))) - ("lexical_declaration" (:*unnamed* ("variable_declarator") :kind nil)) - ("literal_type" (:*unnamed* ("false" "string" "undefined" "null" "number" "true" "unary_expression"))) - ("lookup_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("mapped_type_clause" (:alias ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type") :name ("type_identifier") :type ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("member_expression" (:*unnamed* ("member_expression" "identifier" "property_identifier") :object ("expression") :optional_chain ("optional_chain") :property ("private_property_identifier" "property_identifier"))) - ("method_definition" (:*unnamed* ("accessibility_modifier" "override_modifier") :body ("statement_block") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("method_signature" (:*unnamed* ("accessibility_modifier" "override_modifier") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "asserts_annotation" "type_predicate_annotation") :type_parameters ("type_parameters"))) - ("module" (:body ("statement_block") :name ("string" "identifier" "nested_identifier"))) - ("named_imports" (:*unnamed* ("import_specifier"))) - ("namespace_export" (:*unnamed* ("string" "identifier"))) - ("namespace_import" (:*unnamed* ("identifier"))) - ("nested_identifier" (:*unnamed* ("member_expression" "identifier" "property_identifier"))) - ("nested_type_identifier" (:module ("identifier" "nested_identifier") :name ("type_identifier"))) - ("new_expression" (:arguments ("arguments") :constructor ("primary_expression") :type_arguments ("type_arguments"))) - ("non_null_expression" (:*unnamed* ("expression"))) - ("object" (:*unnamed* ("method_definition" "pair" "spread_element" "shorthand_property_identifier"))) - ("object_assignment_pattern" (:left ("shorthand_property_identifier_pattern" "object_pattern" "array_pattern") :right ("expression"))) - ("object_pattern" (:*unnamed* ("shorthand_property_identifier_pattern" "object_assignment_pattern" "rest_pattern" "pair_pattern"))) - ("object_type" (:*unnamed* ("call_signature" "property_signature" "construct_signature" "export_statement" "method_signature" "index_signature"))) - ("omitting_type_annotation" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("opting_type_annotation" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("optional_parameter" (:*unnamed* ("accessibility_modifier" "override_modifier") :decorator ("decorator") :name ("identifier") :pattern ("this" "pattern") :type ("type_annotation") :value ("expression"))) - ("optional_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("pair" (:key ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :value ("expression"))) - ("pair_pattern" (:key ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :value ("pattern" "assignment_pattern"))) - ("parenthesized_expression" (:*unnamed* ("sequence_expression" "expression") :type ("type_annotation"))) - ("parenthesized_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("program" (:*unnamed* ("hash_bang_line" "statement"))) - ("property_signature" (:*unnamed* ("accessibility_modifier" "override_modifier") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :type ("type_annotation"))) - ("public_field_definition" (:*unnamed* ("accessibility_modifier" "override_modifier") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :type ("type_annotation") :value ("expression"))) - ("readonly_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("regex" (:flags ("regex_flags") :pattern ("regex_pattern"))) - ("required_parameter" (:*unnamed* ("accessibility_modifier" "override_modifier") :decorator ("decorator") :name ("identifier" "rest_pattern") :pattern ("this" "pattern") :type ("type_annotation") :value ("expression"))) - ("rest_pattern" (:*unnamed* ("member_expression" "identifier" "undefined" "object_pattern" "array_pattern" "non_null_expression" "subscript_expression"))) - ("rest_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("return_statement" (:*unnamed* ("sequence_expression" "expression"))) - ("satisfies_expression" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "expression" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("sequence_expression" (:left ("expression") :right ("sequence_expression" "expression"))) - ("spread_element" (:*unnamed* ("expression"))) - ("statement_block" (:*unnamed* ("statement"))) - ("string" (:*unnamed* ("string_fragment" "escape_sequence"))) - ("subscript_expression" (:index ("sequence_expression" "predefined_type" "string" "expression" "number") :object ("expression") :optional_chain ("optional_chain"))) - ("switch_body" (:*unnamed* ("switch_case" "switch_default"))) - ("switch_case" (:body ("statement") :value ("sequence_expression" "expression"))) - ("switch_default" (:body ("statement"))) - ("switch_statement" (:body ("switch_body") :value ("parenthesized_expression"))) - ("template_literal_type" (:*unnamed* ("template_type"))) - ("template_string" (:*unnamed* ("template_substitution" "escape_sequence"))) - ("template_substitution" (:*unnamed* ("sequence_expression" "expression"))) - ("template_type" (:*unnamed* ("parenthesized_type" "type_query" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "conditional_type" "nested_type_identifier" "predefined_type" "existential_type" "union_type"))) - ("ternary_expression" (:alternative ("expression") :condition ("expression") :consequence ("expression"))) - ("throw_statement" (:*unnamed* ("sequence_expression" "expression"))) - ("try_statement" (:body ("statement_block") :finalizer ("finally_clause") :handler ("catch_clause"))) - ("tuple_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "optional_type" "tuple_type" "flow_maybe_type" "intersection_type" "rest_type" "generic_type" "lookup_type" "infer_type" "optional_parameter" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "required_parameter" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("type_alias_declaration" (:name ("type_identifier") :type_parameters ("type_parameters") :value ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("type_annotation" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("type_arguments" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("type_assertion" (:*unnamed* ("type_arguments" "expression"))) - ("type_parameter" (:constraint ("constraint") :name ("type_identifier") :value ("default_type"))) - ("type_parameters" (:*unnamed* ("type_parameter"))) - ("type_predicate" (:name ("this" "identifier") :type ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("type_predicate_annotation" (:*unnamed* ("type_predicate"))) - ("type_query" (:*unnamed* ("member_expression" "identifier" "call_expression" "instantiation_expression" "subscript_expression"))) - ("unary_expression" (:argument ("number" "expression") :operator nil)) - ("union_type" (:*unnamed* ("parenthesized_type" "type_query" "function_type" "tuple_type" "flow_maybe_type" "intersection_type" "generic_type" "lookup_type" "infer_type" "array_type" "type_identifier" "literal_type" "this_type" "object_type" "index_type_query" "template_literal_type" "constructor_type" "conditional_type" "nested_type_identifier" "readonly_type" "predefined_type" "existential_type" "union_type"))) - ("update_expression" (:argument ("expression") :operator nil)) - ("variable_declaration" (:*unnamed* ("variable_declarator"))) - ("variable_declarator" (:name ("object_pattern" "identifier" "array_pattern") :type ("type_annotation") :value ("expression"))) - ("while_statement" (:body ("statement") :condition ("parenthesized_expression"))) - ("with_statement" (:body ("statement") :object ("parenthesized_expression"))) - ("yield_expression" (:*unnamed* ("expression"))) - ("comment" (:*unnamed* nil)) - ("escape_sequence" (:*unnamed* nil)) - ("false" (:*unnamed* nil)) - ("hash_bang_line" (:*unnamed* nil)) - ("null" (:*unnamed* nil)) - ("number" (:*unnamed* nil)) - ("private_property_identifier" (:*unnamed* nil)) - ("property_identifier" (:*unnamed* nil)) - ("regex_flags" (:*unnamed* nil)) - ("regex_pattern" (:*unnamed* nil)) - ("shorthand_property_identifier" (:*unnamed* nil)) - ("shorthand_property_identifier_pattern" (:*unnamed* nil)) - ("statement_identifier" (:*unnamed* nil)) - ("string_fragment" (:*unnamed* nil)) - ("super" (:*unnamed* nil)) - ("this" (:*unnamed* nil)) - ("this_type" (:*unnamed* nil)) - ("true" (:*unnamed* nil)) - ("type_identifier" (:*unnamed* nil)) - ("undefined" (:*unnamed* nil)) - )) +(defconst combobulate-rules-typescript + '(("_primary_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "predefined_type" "tuple_type" "nested_type_identifier" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("declaration" (:*unnamed* ("ambient_declaration" "import_alias" "class_declaration" "type_alias_declaration" "interface_declaration" "function_signature" "variable_declaration" "generator_function_declaration" "internal_module" "enum_declaration" "module" "lexical_declaration" "abstract_class_declaration" "function_declaration"))) + ("expression" (:*unnamed* ("update_expression" "ternary_expression" "satisfies_expression" "assignment_expression" "glimmer_template" "binary_expression" "type_assertion" "new_expression" "instantiation_expression" "as_expression" "primary_expression" "unary_expression" "internal_module" "augmented_assignment_expression" "yield_expression" "await_expression"))) + ("pattern" (:*unnamed* ("non_null_expression" "undefined" "array_pattern" "object_pattern" "identifier" "member_expression" "rest_pattern" "subscript_expression"))) + ("primary_expression" (:*unnamed* ("arrow_function" "false" "object" "template_string" "undefined" "meta_property" "function" "number" "class" "subscript_expression" "parenthesized_expression" "call_expression" "non_null_expression" "import" "true" "string" "member_expression" "identifier" "null" "regex" "array" "super" "this" "generator_function"))) + ("statement" (:*unnamed* ("break_statement" "import_statement" "expression_statement" "do_statement" "with_statement" "if_statement" "continue_statement" "switch_statement" "try_statement" "declaration" "empty_statement" "for_statement" "debugger_statement" "export_statement" "statement_block" "throw_statement" "while_statement" "return_statement" "labeled_statement" "for_in_statement"))) + ("abstract_class_declaration" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("type_identifier") :type_parameters ("type_parameters"))) + ("abstract_method_signature" (:*unnamed* ("accessibility_modifier") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("accessibility_modifier" (:*unnamed* nil)) + ("ambient_declaration" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "property_identifier" "union_type" "conditional_type" "index_type_query" "declaration" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "statement_block" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("arguments" (:*unnamed* ("expression" "spread_element"))) + ("array" (:*unnamed* ("expression" "spread_element"))) + ("array_pattern" (:*unnamed* ("assignment_pattern" "pattern"))) + ("array_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "predefined_type" "tuple_type" "nested_type_identifier" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("arrow_function" (:*unnamed* nil :body ("expression" "statement_block") :parameter ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("as_expression" (:*unnamed* ("expression" "object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("asserts" (:*unnamed* ("identifier" "type_predicate" "this"))) + ("asserts_annotation" (:*unnamed* ("asserts"))) + ("assignment_expression" (:*unnamed* nil :left ("parenthesized_expression" "non_null_expression" "undefined" "array_pattern" "object_pattern" "identifier" "member_expression" "subscript_expression") :right ("expression"))) + ("assignment_pattern" (:*unnamed* nil :left ("pattern") :right ("expression"))) + ("augmented_assignment_expression" (:*unnamed* nil :left ("parenthesized_expression" "identifier" "non_null_expression" "subscript_expression" "member_expression") :operator nil :right ("expression"))) + ("await_expression" (:*unnamed* ("expression"))) + ("binary_expression" (:*unnamed* nil :left ("expression") :operator nil :right ("expression"))) + ("break_statement" (:*unnamed* nil :label ("statement_identifier"))) + ("call_expression" (:*unnamed* nil :arguments ("arguments" "template_string") :function ("expression") :type_arguments ("type_arguments"))) + ("call_signature" (:*unnamed* nil :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("catch_clause" (:*unnamed* nil :body ("statement_block") :parameter ("identifier" "array_pattern" "object_pattern") :type ("type_annotation"))) + ("class" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("type_identifier") :type_parameters ("type_parameters"))) + ("class_body" (:*unnamed* ("index_signature" "decorator" "method_definition" "public_field_definition" "method_signature" "abstract_method_signature" "class_static_block"))) + ("class_declaration" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("type_identifier") :type_parameters ("type_parameters"))) + ("class_heritage" (:*unnamed* ("extends_clause" "implements_clause"))) + ("class_static_block" (:*unnamed* nil :body ("statement_block"))) + ("computed_property_name" (:*unnamed* ("expression"))) + ("conditional_type" (:*unnamed* nil :alternative ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :consequence ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :left ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :right ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("constraint" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("construct_signature" (:*unnamed* nil :parameters ("formal_parameters") :type ("type_annotation") :type_parameters ("type_parameters"))) + ("constructor_type" (:*unnamed* nil :parameters ("formal_parameters") :type ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :type_parameters ("type_parameters"))) + ("continue_statement" (:*unnamed* nil :label ("statement_identifier"))) + ("debugger_statement" (:*unnamed* nil)) + ("decorator" (:*unnamed* ("identifier" "call_expression" "member_expression"))) + ("default_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("do_statement" (:*unnamed* nil :body ("statement") :condition ("parenthesized_expression"))) + ("else_clause" (:*unnamed* ("statement"))) + ("empty_statement" (:*unnamed* nil)) + ("enum_assignment" (:*unnamed* nil :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :value ("expression"))) + ("enum_body" (:*unnamed* ("enum_assignment") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier"))) + ("enum_declaration" (:*unnamed* nil :body ("enum_body") :name ("identifier"))) + ("existential_type" (:*unnamed* nil)) + ("export_clause" (:*unnamed* ("export_specifier"))) + ("export_specifier" (:*unnamed* nil :alias ("identifier" "string") :name ("identifier" "string"))) + ("export_statement" (:*unnamed* ("identifier" "expression" "export_clause" "namespace_export") :declaration ("declaration") :decorator ("decorator") :source ("string") :value ("expression"))) + ("expression_statement" (:*unnamed* ("expression" "sequence_expression"))) + ("extends_clause" (:*unnamed* nil :type_arguments ("type_arguments") :value ("expression"))) + ("extends_type_clause" (:*unnamed* nil :type ("type_identifier" "nested_type_identifier" "generic_type"))) + ("finally_clause" (:*unnamed* nil :body ("statement_block"))) + ("flow_maybe_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "predefined_type" "tuple_type" "nested_type_identifier" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("for_in_statement" (:*unnamed* nil :body ("statement") :kind nil :left ("parenthesized_expression" "non_null_expression" "undefined" "array_pattern" "object_pattern" "identifier" "member_expression" "subscript_expression") :operator nil :right ("expression" "sequence_expression") :value ("expression"))) + ("for_statement" (:*unnamed* nil :body ("statement") :condition ("empty_statement" "expression_statement") :increment ("expression" "sequence_expression") :initializer ("empty_statement" "lexical_declaration" "expression_statement" "variable_declaration"))) + ("formal_parameters" (:*unnamed* ("required_parameter" "optional_parameter"))) + ("function" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("function_declaration" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("function_signature" (:*unnamed* nil :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("function_type" (:*unnamed* nil :parameters ("formal_parameters") :return_type ("object_type" "intersection_type" "asserts" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "type_predicate" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :type_parameters ("type_parameters"))) + ("generator_function" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("generator_function_declaration" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("generic_type" (:*unnamed* nil :name ("type_identifier" "nested_type_identifier") :type_arguments ("type_arguments"))) + ("glimmer_closing_tag" (:*unnamed* nil)) + ("glimmer_opening_tag" (:*unnamed* nil)) + ("glimmer_template" (:*unnamed* nil :close_tag ("glimmer_closing_tag") :open_tag ("glimmer_opening_tag"))) + ("identifier" (:*unnamed* nil)) + ("if_statement" (:*unnamed* nil :alternative ("else_clause") :condition ("parenthesized_expression") :consequence ("statement"))) + ("implements_clause" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("import" (:*unnamed* nil)) + ("import_alias" (:*unnamed* ("identifier" "nested_identifier"))) + ("import_clause" (:*unnamed* ("identifier" "named_imports" "namespace_import"))) + ("import_require_clause" (:*unnamed* ("identifier") :source ("string"))) + ("import_specifier" (:*unnamed* nil :alias ("identifier") :name ("identifier" "string"))) + ("import_statement" (:*unnamed* ("import_require_clause" "import_clause") :source ("string"))) + ("index_signature" (:*unnamed* ("mapped_type_clause") :index_type ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :name ("identifier") :sign nil :type ("type_annotation" "omitting_type_annotation" "opting_type_annotation"))) + ("index_type_query" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "predefined_type" "tuple_type" "nested_type_identifier" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("infer_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("instantiation_expression" (:*unnamed* ("expression") :function ("identifier" "subscript_expression" "member_expression" "import") :type_arguments ("type_arguments"))) + ("interface_declaration" (:*unnamed* ("extends_type_clause") :body ("object_type") :name ("type_identifier") :type_parameters ("type_parameters"))) + ("internal_module" (:*unnamed* nil :body ("statement_block") :name ("identifier" "string" "nested_identifier"))) + ("intersection_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("jsx_attribute" (:*unnamed* ("jsx_expression" "jsx_self_closing_element" "property_identifier" "jsx_namespace_name" "jsx_element" "string"))) + ("jsx_closing_element" (:*unnamed* nil :name ("identifier" "jsx_namespace_name" "member_expression"))) + ("jsx_element" (:*unnamed* ("jsx_self_closing_element" "jsx_text" "jsx_expression" "jsx_element") :close_tag ("jsx_closing_element") :open_tag ("jsx_opening_element"))) + ("jsx_expression" (:*unnamed* ("expression" "sequence_expression" "spread_element"))) + ("jsx_namespace_name" (:*unnamed* ("identifier"))) + ("jsx_opening_element" (:*unnamed* nil :attribute ("jsx_expression" "jsx_attribute") :name ("identifier" "jsx_namespace_name" "member_expression") :type_arguments ("type_arguments"))) + ("jsx_self_closing_element" (:*unnamed* nil :attribute ("jsx_expression" "jsx_attribute") :name ("identifier" "jsx_namespace_name" "member_expression") :type_arguments ("type_arguments"))) + ("jsx_text" (:*unnamed* nil)) + ("labeled_statement" (:*unnamed* nil :body ("statement") :label ("statement_identifier"))) + ("lexical_declaration" (:*unnamed* ("variable_declarator") :kind nil)) + ("literal_type" (:*unnamed* ("false" "unary_expression" "null" "undefined" "true" "string" "number"))) + ("lookup_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("mapped_type_clause" (:*unnamed* nil :alias ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type") :name ("type_identifier") :type ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("member_expression" (:*unnamed* ("identifier" "property_identifier" "member_expression") :object ("expression") :optional_chain ("optional_chain") :property ("property_identifier" "private_property_identifier"))) + ("meta_property" (:*unnamed* nil)) + ("method_definition" (:*unnamed* ("override_modifier" "accessibility_modifier") :body ("statement_block") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("method_signature" (:*unnamed* ("override_modifier" "accessibility_modifier") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :parameters ("formal_parameters") :return_type ("type_annotation" "type_predicate_annotation" "asserts_annotation") :type_parameters ("type_parameters"))) + ("module" (:*unnamed* nil :body ("statement_block") :name ("identifier" "string" "nested_identifier"))) + ("named_imports" (:*unnamed* ("import_specifier"))) + ("namespace_export" (:*unnamed* ("identifier" "string"))) + ("namespace_import" (:*unnamed* ("identifier"))) + ("nested_identifier" (:*unnamed* ("identifier" "property_identifier" "member_expression"))) + ("nested_type_identifier" (:*unnamed* nil :module ("identifier" "nested_identifier") :name ("type_identifier"))) + ("new_expression" (:*unnamed* nil :arguments ("arguments") :constructor ("primary_expression") :type_arguments ("type_arguments"))) + ("non_null_expression" (:*unnamed* ("expression"))) + ("object" (:*unnamed* ("pair" "method_definition" "shorthand_property_identifier" "spread_element"))) + ("object_assignment_pattern" (:*unnamed* nil :left ("shorthand_property_identifier_pattern" "array_pattern" "object_pattern") :right ("expression"))) + ("object_pattern" (:*unnamed* ("object_assignment_pattern" "shorthand_property_identifier_pattern" "rest_pattern" "pair_pattern"))) + ("object_type" (:*unnamed* ("index_signature" "call_signature" "export_statement" "method_signature" "construct_signature" "property_signature"))) + ("omitting_type_annotation" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("opting_type_annotation" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("optional_chain" (:*unnamed* nil)) + ("optional_parameter" (:*unnamed* ("override_modifier" "accessibility_modifier") :decorator ("decorator") :name ("identifier") :pattern ("pattern" "this") :type ("type_annotation") :value ("expression"))) + ("optional_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("override_modifier" (:*unnamed* nil)) + ("pair" (:*unnamed* nil :key ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :value ("expression"))) + ("pair_pattern" (:*unnamed* nil :key ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :value ("assignment_pattern" "pattern"))) + ("parenthesized_expression" (:*unnamed* ("expression" "sequence_expression") :type ("type_annotation"))) + ("parenthesized_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("predefined_type" (:*unnamed* nil)) + ("program" (:*unnamed* ("statement" "hash_bang_line"))) + ("property_signature" (:*unnamed* ("override_modifier" "accessibility_modifier") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :type ("type_annotation"))) + ("public_field_definition" (:*unnamed* ("override_modifier" "accessibility_modifier") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :type ("type_annotation") :value ("expression"))) + ("readonly_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("regex" (:*unnamed* nil :flags ("regex_flags") :pattern ("regex_pattern"))) + ("required_parameter" (:*unnamed* ("override_modifier" "accessibility_modifier") :decorator ("decorator") :name ("identifier" "rest_pattern") :pattern ("pattern" "this") :type ("type_annotation") :value ("expression"))) + ("rest_pattern" (:*unnamed* ("identifier" "non_null_expression" "member_expression" "undefined" "subscript_expression" "array_pattern" "object_pattern"))) + ("rest_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("return_statement" (:*unnamed* ("expression" "sequence_expression"))) + ("satisfies_expression" (:*unnamed* ("expression" "object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("sequence_expression" (:*unnamed* nil :left ("expression") :right ("expression" "sequence_expression"))) + ("spread_element" (:*unnamed* ("expression"))) + ("statement_block" (:*unnamed* ("statement"))) + ("string" (:*unnamed* ("string_fragment" "escape_sequence"))) + ("subscript_expression" (:*unnamed* nil :index ("expression" "predefined_type" "sequence_expression" "string" "number") :object ("expression") :optional_chain ("optional_chain"))) + ("switch_body" (:*unnamed* ("switch_case" "switch_default"))) + ("switch_case" (:*unnamed* nil :body ("statement") :value ("expression" "sequence_expression"))) + ("switch_default" (:*unnamed* nil :body ("statement"))) + ("switch_statement" (:*unnamed* nil :body ("switch_body") :value ("parenthesized_expression"))) + ("template_literal_type" (:*unnamed* ("template_type"))) + ("template_string" (:*unnamed* ("template_substitution" "escape_sequence"))) + ("template_substitution" (:*unnamed* ("expression" "sequence_expression"))) + ("template_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "nested_type_identifier" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("ternary_expression" (:*unnamed* nil :alternative ("expression") :condition ("expression") :consequence ("expression"))) + ("throw_statement" (:*unnamed* ("expression" "sequence_expression"))) + ("try_statement" (:*unnamed* nil :body ("statement_block") :finalizer ("finally_clause") :handler ("catch_clause"))) + ("tuple_type" (:*unnamed* ("object_type" "optional_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "optional_parameter" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "required_parameter" "rest_type" "lookup_type"))) + ("type_alias_declaration" (:*unnamed* nil :name ("type_identifier") :type_parameters ("type_parameters") :value ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("type_annotation" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("type_arguments" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("type_assertion" (:*unnamed* ("expression" "type_arguments"))) + ("type_parameter" (:*unnamed* nil :constraint ("constraint") :name ("type_identifier") :value ("default_type"))) + ("type_parameters" (:*unnamed* ("type_parameter"))) + ("type_predicate" (:*unnamed* nil :name ("identifier" "this") :type ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("type_predicate_annotation" (:*unnamed* ("type_predicate"))) + ("type_query" (:*unnamed* ("identifier" "call_expression" "instantiation_expression" "subscript_expression" "member_expression"))) + ("unary_expression" (:*unnamed* nil :argument ("expression" "number") :operator nil)) + ("union_type" (:*unnamed* ("object_type" "intersection_type" "this_type" "type_query" "literal_type" "union_type" "conditional_type" "index_type_query" "type_identifier" "infer_type" "predefined_type" "tuple_type" "function_type" "nested_type_identifier" "constructor_type" "readonly_type" "existential_type" "parenthesized_type" "template_literal_type" "flow_maybe_type" "array_type" "generic_type" "lookup_type"))) + ("update_expression" (:*unnamed* nil :argument ("expression") :operator nil)) + ("variable_declaration" (:*unnamed* ("variable_declarator"))) + ("variable_declarator" (:*unnamed* nil :name ("identifier" "array_pattern" "object_pattern") :type ("type_annotation") :value ("expression"))) + ("while_statement" (:*unnamed* nil :body ("statement") :condition ("parenthesized_expression"))) + ("with_statement" (:*unnamed* nil :body ("statement") :object ("parenthesized_expression"))) + ("yield_expression" (:*unnamed* ("expression"))) + ("comment" (:*unnamed* nil)) + ("escape_sequence" (:*unnamed* nil)) + ("false" (:*unnamed* nil)) + ("hash_bang_line" (:*unnamed* nil)) + ("null" (:*unnamed* nil)) + ("number" (:*unnamed* nil)) + ("private_property_identifier" (:*unnamed* nil)) + ("property_identifier" (:*unnamed* nil)) + ("regex_flags" (:*unnamed* nil)) + ("regex_pattern" (:*unnamed* nil)) + ("shorthand_property_identifier" (:*unnamed* nil)) + ("shorthand_property_identifier_pattern" (:*unnamed* nil)) + ("statement_identifier" (:*unnamed* nil)) + ("string_fragment" (:*unnamed* nil)) + ("super" (:*unnamed* nil)) + ("this" (:*unnamed* nil)) + ("this_type" (:*unnamed* nil)) + ("true" (:*unnamed* nil)) + ("type_identifier" (:*unnamed* nil)) + ("undefined" (:*unnamed* nil)) +)) ;; END Production rules for typescript ;; START Inverse production rules for typescript -(defconst combobulate-rules-typescript-inverse - '(("abstract_class_declaration" ("declaration")) - ("abstract_method_signature" ("class_body")) - ("accessibility_modifier" ("abstract_method_signature" "public_field_definition" "method_definition" "required_parameter" "method_signature" "property_signature" "optional_parameter")) - ("ambient_declaration" ("declaration")) - ("arguments" ("new_expression" "call_expression")) - ("array" ("primary_expression")) - ("array_pattern" ("for_in_statement" "pattern" "assignment_expression" "rest_pattern" "object_assignment_pattern" "variable_declarator" "catch_clause")) - ("array_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("arrow_function" ("primary_expression")) - ("as_expression" ("expression")) - ("asserts" ("asserts_annotation" "function_type")) - ("asserts_annotation" ("abstract_method_signature" "method_definition" "arrow_function" "function_signature" "generator_function" "generator_function_declaration" "function_declaration" "method_signature" "call_signature" "function")) - ("assignment_expression" ("expression")) - ("assignment_pattern" ("pair_pattern" "array_pattern")) - ("augmented_assignment_expression" ("expression")) - ("await_expression" ("expression")) - ("binary_expression" ("expression")) - ("break_statement" ("statement")) - ("call_expression" ("primary_expression" "decorator" "type_query")) - ("call_signature" ("object_type")) - ("catch_clause" ("try_statement")) - ("class" ("primary_expression")) - ("class_body" ("abstract_class_declaration" "class_declaration" "class")) - ("class_declaration" ("declaration")) - ("class_heritage" ("abstract_class_declaration" "class_declaration" "class")) - ("class_static_block" ("class_body")) - ("computed_property_name" ("abstract_method_signature" "enum_body" "public_field_definition" "method_definition" "method_signature" "pair" "enum_assignment" "pair_pattern" "property_signature")) - ("conditional_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("constraint" ("type_parameter")) - ("construct_signature" ("object_type")) - ("constructor_type" ("function_type" "implements_clause" "rest_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("continue_statement" ("statement")) - ("debugger_statement" ("statement")) - ("declaration" ("ambient_declaration" "export_statement" "statement")) - ("decorator" ("optional_parameter" "required_parameter" "export_statement" "abstract_class_declaration" "class_declaration" "class_body" "class")) - ("default_type" ("type_parameter")) - ("do_statement" ("statement")) - ("else_clause" ("if_statement")) - ("empty_statement" ("for_statement" "statement")) - ("enum_assignment" ("enum_body")) - ("enum_body" ("enum_declaration")) - ("enum_declaration" ("declaration")) - ("escape_sequence" ("template_string" "string")) - ("existential_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("export_clause" ("export_statement")) - ("export_specifier" ("export_clause")) - ("export_statement" ("object_type" "statement")) - ("expression" ("jsx_expression" "member_expression" "sequence_expression" "parenthesized_expression" "spread_element" "binary_expression" "return_statement" "computed_property_name" "switch_case" "required_parameter" "instantiation_expression" "await_expression" "ternary_expression" "pair" "enum_assignment" "object_assignment_pattern" "non_null_expression" "variable_declarator" "template_substitution" "array" "type_assertion" "public_field_definition" "for_statement" "yield_expression" "export_statement" "arrow_function" "as_expression" "satisfies_expression" "call_expression" "augmented_assignment_expression" "extends_clause" "for_in_statement" "throw_statement" "optional_parameter" "subscript_expression" "assignment_expression" "arguments" "expression_statement" "update_expression" "assignment_pattern" "unary_expression")) - ("expression_statement" ("for_statement" "statement")) - ("extends_clause" ("class_heritage")) - ("extends_type_clause" ("interface_declaration")) - ("false" ("primary_expression" "literal_type")) - ("finally_clause" ("try_statement")) - ("flow_maybe_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("for_in_statement" ("statement")) - ("for_statement" ("statement")) - ("formal_parameters" ("abstract_method_signature" "function_type" "method_definition" "construct_signature" "arrow_function" "function_signature" "generator_function" "constructor_type" "function_declaration" "generator_function_declaration" "method_signature" "call_signature" "function")) - ("function" ("primary_expression")) - ("function_declaration" ("declaration")) - ("function_signature" ("declaration")) - ("function_type" ("function_type" "implements_clause" "rest_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("generator_function" ("primary_expression")) - ("generator_function_declaration" ("declaration")) - ("generic_type" ("function_type" "extends_type_clause" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("glimmer_closing_tag" ("glimmer_template")) - ("glimmer_opening_tag" ("glimmer_template")) - ("glimmer_template" ("expression")) - ("hash_bang_line" ("program")) - ("identifier" ("member_expression" "type_query" "jsx_closing_element" "rest_pattern" "enum_declaration" "internal_module" "type_predicate" "namespace_import" "export_specifier" "module" "jsx_self_closing_element" "instantiation_expression" "required_parameter" "function_signature" "generator_function_declaration" "function_declaration" "variable_declarator" "import_clause" "catch_clause" "import_require_clause" "export_statement" "arrow_function" "generator_function" "namespace_export" "augmented_assignment_expression" "import_alias" "import_specifier" "for_in_statement" "function" "optional_parameter" "assignment_expression" "primary_expression" "jsx_namespace_name" "pattern" "decorator" "nested_identifier" "index_signature" "asserts" "nested_type_identifier" "jsx_opening_element")) - ("if_statement" ("statement")) - ("implements_clause" ("class_heritage")) - ("import" ("primary_expression" "instantiation_expression")) - ("import_alias" ("declaration")) - ("import_clause" ("import_statement")) - ("import_require_clause" ("import_statement")) - ("import_specifier" ("named_imports")) - ("import_statement" ("statement")) - ("index_signature" ("object_type" "class_body")) - ("index_type_query" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("infer_type" ("function_type" "implements_clause" "rest_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("instantiation_expression" ("expression" "type_query")) - ("interface_declaration" ("declaration")) - ("internal_module" ("declaration" "expression")) - ("intersection_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("jsx_attribute" ("jsx_self_closing_element" "jsx_opening_element")) - ("jsx_closing_element" ("jsx_element")) - ("jsx_element" ("jsx_attribute" "jsx_element")) - ("jsx_expression" ("jsx_self_closing_element" "jsx_attribute" "jsx_element" "jsx_opening_element")) - ("jsx_namespace_name" ("jsx_self_closing_element" "jsx_attribute" "jsx_closing_element" "jsx_opening_element")) - ("jsx_opening_element" ("jsx_element")) - ("jsx_self_closing_element" ("jsx_attribute" "jsx_element")) - ("jsx_text" ("jsx_element")) - ("labeled_statement" ("statement")) - ("lexical_declaration" ("for_statement" "declaration")) - ("literal_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("lookup_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("mapped_type_clause" ("index_signature")) - ("member_expression" ("member_expression" "primary_expression" "pattern" "type_query" "jsx_self_closing_element" "instantiation_expression" "jsx_closing_element" "decorator" "nested_identifier" "rest_pattern" "augmented_assignment_expression" "jsx_opening_element" "for_in_statement" "assignment_expression")) - ("meta_property" ("primary_expression")) - ("method_definition" ("object" "class_body")) - ("method_signature" ("object_type" "class_body")) - ("module" ("declaration")) - ("named_imports" ("import_clause")) - ("namespace_export" ("export_statement")) - ("namespace_import" ("import_clause")) - ("nested_identifier" ("module" "internal_module" "nested_type_identifier" "import_alias")) - ("nested_type_identifier" ("function_type" "extends_type_clause" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "generic_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("new_expression" ("expression")) - ("non_null_expression" ("primary_expression" "pattern" "rest_pattern" "augmented_assignment_expression" "for_in_statement" "assignment_expression")) - ("null" ("primary_expression" "literal_type")) - ("number" ("primary_expression" "literal_type" "abstract_method_signature" "enum_body" "public_field_definition" "method_definition" "method_signature" "pair" "enum_assignment" "pair_pattern" "property_signature" "subscript_expression" "unary_expression")) - ("object" ("primary_expression")) - ("object_assignment_pattern" ("object_pattern")) - ("object_pattern" ("for_in_statement" "pattern" "assignment_expression" "rest_pattern" "object_assignment_pattern" "variable_declarator" "catch_clause")) - ("object_type" ("interface_declaration" "function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("omitting_type_annotation" ("index_signature")) - ("opting_type_annotation" ("index_signature")) - ("optional_chain" ("member_expression" "subscript_expression")) - ("optional_parameter" ("formal_parameters" "tuple_type")) - ("optional_type" ("tuple_type")) - ("override_modifier" ("public_field_definition" "method_definition" "required_parameter" "method_signature" "property_signature" "optional_parameter")) - ("pair" ("object")) - ("pair_pattern" ("object_pattern")) - ("parenthesized_expression" ("primary_expression" "while_statement" "switch_statement" "with_statement" "if_statement" "do_statement" "augmented_assignment_expression" "for_in_statement" "assignment_expression")) - ("parenthesized_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("pattern" ("array_pattern" "required_parameter" "assignment_pattern" "pair_pattern" "optional_parameter")) - ("predefined_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "subscript_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("primary_expression" ("new_expression" "expression")) - ("private_property_identifier" ("member_expression" "abstract_method_signature" "enum_body" "public_field_definition" "method_definition" "method_signature" "pair" "enum_assignment" "pair_pattern" "property_signature")) - ("property_identifier" ("ambient_declaration" "jsx_attribute" "member_expression" "abstract_method_signature" "enum_body" "public_field_definition" "method_definition" "method_signature" "nested_identifier" "pair" "enum_assignment" "pair_pattern" "property_signature")) - ("property_signature" ("object_type")) - ("public_field_definition" ("class_body")) - ("readonly_type" ("function_type" "implements_clause" "rest_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("regex" ("primary_expression")) - ("regex_flags" ("regex")) - ("regex_pattern" ("regex")) - ("required_parameter" ("formal_parameters" "tuple_type")) - ("rest_pattern" ("required_parameter" "pattern" "object_pattern")) - ("rest_type" ("tuple_type")) - ("return_statement" ("statement")) - ("satisfies_expression" ("expression")) - ("sequence_expression" ("jsx_expression" "sequence_expression" "parenthesized_expression" "for_statement" "throw_statement" "expression_statement" "return_statement" "switch_case" "for_in_statement" "template_substitution" "subscript_expression")) - ("shorthand_property_identifier" ("object")) - ("shorthand_property_identifier_pattern" ("object_assignment_pattern" "object_pattern")) - ("spread_element" ("array" "arguments" "jsx_expression" "object")) - ("statement" ("switch_default" "while_statement" "for_statement" "statement_block" "with_statement" "if_statement" "do_statement" "else_clause" "labeled_statement" "program" "switch_case" "for_in_statement")) - ("statement_block" ("ambient_declaration" "finally_clause" "method_definition" "module" "statement" "arrow_function" "generator_function" "generator_function_declaration" "try_statement" "function_declaration" "class_static_block" "internal_module" "function" "catch_clause")) - ("statement_identifier" ("labeled_statement" "continue_statement" "break_statement")) - ("string" ("enum_body" "method_signature" "internal_module" "export_specifier" "module" "method_definition" "pair" "enum_assignment" "property_signature" "jsx_attribute" "import_require_clause" "public_field_definition" "export_statement" "import_statement" "namespace_export" "import_specifier" "subscript_expression" "primary_expression" "literal_type" "abstract_method_signature" "pair_pattern")) - ("string_fragment" ("string")) - ("subscript_expression" ("primary_expression" "pattern" "type_query" "instantiation_expression" "rest_pattern" "augmented_assignment_expression" "for_in_statement" "assignment_expression")) - ("super" ("primary_expression")) - ("switch_body" ("switch_statement")) - ("switch_case" ("switch_body")) - ("switch_default" ("switch_body")) - ("switch_statement" ("statement")) - ("template_literal_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("template_string" ("primary_expression" "call_expression")) - ("template_substitution" ("template_string")) - ("template_type" ("template_literal_type")) - ("ternary_expression" ("expression")) - ("this" ("primary_expression" "required_parameter" "type_predicate" "asserts" "optional_parameter")) - ("this_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("throw_statement" ("statement")) - ("true" ("primary_expression" "literal_type")) - ("try_statement" ("statement")) - ("tuple_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("type_alias_declaration" ("declaration")) - ("type_annotation" ("parenthesized_expression" "method_signature" "call_signature" "method_definition" "required_parameter" "function_signature" "generator_function_declaration" "function_declaration" "property_signature" "variable_declarator" "catch_clause" "public_field_definition" "arrow_function" "generator_function" "optional_parameter" "function" "abstract_method_signature" "construct_signature" "index_signature")) - ("type_arguments" ("type_assertion" "jsx_self_closing_element" "instantiation_expression" "generic_type" "call_expression" "jsx_opening_element" "extends_clause" "new_expression")) - ("type_assertion" ("expression")) - ("type_identifier" ("interface_declaration" "function_type" "extends_type_clause" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "generic_type" "class_declaration" "tuple_type" "lookup_type" "default_type" "infer_type" "class" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "abstract_class_declaration" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "nested_type_identifier" "readonly_type" "type_parameter")) - ("type_parameter" ("type_parameters")) - ("type_parameters" ("interface_declaration" "method_signature" "abstract_method_signature" "function_type" "method_definition" "construct_signature" "arrow_function" "function_signature" "generator_function" "abstract_class_declaration" "constructor_type" "function_declaration" "class_declaration" "function" "generator_function_declaration" "call_signature" "class" "type_alias_declaration")) - ("type_predicate" ("type_predicate_annotation" "asserts" "function_type")) - ("type_predicate_annotation" ("abstract_method_signature" "method_definition" "arrow_function" "function_signature" "generator_function" "generator_function_declaration" "function_declaration" "method_signature" "call_signature" "function")) - ("type_query" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("unary_expression" ("literal_type" "expression")) - ("undefined" ("primary_expression" "literal_type" "pattern" "rest_pattern" "for_in_statement" "assignment_expression")) - ("union_type" ("function_type" "implements_clause" "rest_type" "flow_maybe_type" "_primary_type" "intersection_type" "tuple_type" "lookup_type" "default_type" "infer_type" "type_predicate" "array_type" "index_type_query" "mapped_type_clause" "omitting_type_annotation" "constructor_type" "type_arguments" "union_type" "ambient_declaration" "constraint" "parenthesized_type" "template_type" "type_annotation" "optional_type" "opting_type_annotation" "as_expression" "satisfies_expression" "type_alias_declaration" "index_signature" "conditional_type" "readonly_type")) - ("update_expression" ("expression")) - ("variable_declaration" ("for_statement" "declaration")) - ("variable_declarator" ("variable_declaration" "lexical_declaration")) - ("while_statement" ("statement")) - ("with_statement" ("statement")) - ("yield_expression" ("expression")) - ) - ) +(defconst combobulate-rules-typescript-inverse + '(("abstract_class_declaration" ("declaration")) + ("abstract_method_signature" ("class_body")) + ("accessibility_modifier" ("method_definition" "method_signature" "optional_parameter" "required_parameter" "public_field_definition" "abstract_method_signature" "property_signature")) + ("ambient_declaration" ("declaration")) + ("arguments" ("new_expression" "call_expression")) + ("array" ("primary_expression")) + ("array_pattern" ("object_assignment_pattern" "variable_declarator" "assignment_expression" "rest_pattern" "pattern" "for_in_statement" "catch_clause")) + ("array_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("arrow_function" ("primary_expression")) + ("as_expression" ("expression")) + ("asserts" ("function_type" "asserts_annotation")) + ("asserts_annotation" ("arrow_function" "method_definition" "function_signature" "method_signature" "generator_function_declaration" "call_signature" "function" "abstract_method_signature" "generator_function" "function_declaration")) + ("assignment_expression" ("expression")) + ("assignment_pattern" ("pair_pattern" "array_pattern")) + ("augmented_assignment_expression" ("expression")) + ("await_expression" ("expression")) + ("binary_expression" ("expression")) + ("break_statement" ("statement")) + ("call_expression" ("primary_expression" "type_query" "decorator")) + ("call_signature" ("object_type")) + ("catch_clause" ("try_statement")) + ("class" ("primary_expression")) + ("class_body" ("class_declaration" "class" "abstract_class_declaration")) + ("class_declaration" ("declaration")) + ("class_heritage" ("class_declaration" "class" "abstract_class_declaration")) + ("class_static_block" ("class_body")) + ("computed_property_name" ("enum_assignment" "enum_body" "method_definition" "method_signature" "pair_pattern" "pair" "public_field_definition" "abstract_method_signature" "property_signature")) + ("conditional_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("constraint" ("type_parameter")) + ("construct_signature" ("object_type")) + ("constructor_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "constructor_type" "parenthesized_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "opting_type_annotation" "constraint" "lookup_type")) + ("continue_statement" ("statement")) + ("debugger_statement" ("statement")) + ("declaration" ("ambient_declaration" "statement" "export_statement")) + ("decorator" ("class_declaration" "export_statement" "class_body" "optional_parameter" "required_parameter" "class" "abstract_class_declaration")) + ("default_type" ("type_parameter")) + ("do_statement" ("statement")) + ("else_clause" ("if_statement")) + ("empty_statement" ("statement" "for_statement")) + ("enum_assignment" ("enum_body")) + ("enum_body" ("enum_declaration")) + ("enum_declaration" ("declaration")) + ("escape_sequence" ("string" "template_string")) + ("existential_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("export_clause" ("export_statement")) + ("export_specifier" ("export_clause")) + ("export_statement" ("statement" "object_type")) + ("expression" ("arrow_function" "extends_clause" "update_expression" "satisfies_expression" "jsx_expression" "binary_expression" "computed_property_name" "type_assertion" "parenthesized_expression" "enum_assignment" "call_expression" "for_statement" "instantiation_expression" "spread_element" "as_expression" "member_expression" "optional_parameter" "return_statement" "for_in_statement" "public_field_definition" "yield_expression" "await_expression" "object_assignment_pattern" "ternary_expression" "expression_statement" "assignment_expression" "pair" "switch_case" "subscript_expression" "variable_declarator" "export_statement" "non_null_expression" "assignment_pattern" "throw_statement" "unary_expression" "required_parameter" "arguments" "augmented_assignment_expression" "template_substitution" "array" "sequence_expression")) + ("expression_statement" ("statement" "for_statement")) + ("extends_clause" ("class_heritage")) + ("extends_type_clause" ("interface_declaration")) + ("false" ("primary_expression" "literal_type")) + ("finally_clause" ("try_statement")) + ("flow_maybe_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("for_in_statement" ("statement")) + ("for_statement" ("statement")) + ("formal_parameters" ("arrow_function" "function_declaration" "method_definition" "function_signature" "method_signature" "construct_signature" "function_type" "generator_function_declaration" "constructor_type" "function" "abstract_method_signature" "generator_function" "call_signature")) + ("function" ("primary_expression")) + ("function_declaration" ("declaration")) + ("function_signature" ("declaration")) + ("function_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "constructor_type" "parenthesized_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "opting_type_annotation" "constraint" "lookup_type")) + ("generator_function" ("primary_expression")) + ("generator_function_declaration" ("declaration")) + ("generic_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "extends_type_clause" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("glimmer_closing_tag" ("glimmer_template")) + ("glimmer_opening_tag" ("glimmer_template")) + ("glimmer_template" ("expression")) + ("hash_bang_line" ("program")) + ("identifier" ("import_require_clause" "arrow_function" "jsx_self_closing_element" "jsx_namespace_name" "namespace_import" "nested_identifier" "type_query" "jsx_opening_element" "import_clause" "function_declaration" "instantiation_expression" "nested_type_identifier" "member_expression" "optional_parameter" "enum_declaration" "namespace_export" "pattern" "decorator" "for_in_statement" "catch_clause" "generator_function_declaration" "generator_function" "import_alias" "function_signature" "assignment_expression" "export_specifier" "asserts" "function" "index_signature" "variable_declarator" "type_predicate" "export_statement" "primary_expression" "internal_module" "required_parameter" "jsx_closing_element" "rest_pattern" "augmented_assignment_expression" "import_specifier" "module")) + ("if_statement" ("statement")) + ("implements_clause" ("class_heritage")) + ("import" ("primary_expression" "instantiation_expression")) + ("import_alias" ("declaration")) + ("import_clause" ("import_statement")) + ("import_require_clause" ("import_statement")) + ("import_specifier" ("named_imports")) + ("import_statement" ("statement")) + ("index_signature" ("object_type" "class_body")) + ("index_type_query" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("infer_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "opting_type_annotation" "constraint" "lookup_type")) + ("instantiation_expression" ("expression" "type_query")) + ("interface_declaration" ("declaration")) + ("internal_module" ("expression" "declaration")) + ("intersection_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("jsx_attribute" ("jsx_self_closing_element" "jsx_opening_element")) + ("jsx_closing_element" ("jsx_element")) + ("jsx_element" ("jsx_element" "jsx_attribute")) + ("jsx_expression" ("jsx_self_closing_element" "jsx_element" "jsx_attribute" "jsx_opening_element")) + ("jsx_namespace_name" ("jsx_closing_element" "jsx_self_closing_element" "jsx_attribute" "jsx_opening_element")) + ("jsx_opening_element" ("jsx_element")) + ("jsx_self_closing_element" ("jsx_element" "jsx_attribute")) + ("jsx_text" ("jsx_element")) + ("labeled_statement" ("statement")) + ("lexical_declaration" ("for_statement" "declaration")) + ("literal_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("lookup_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("mapped_type_clause" ("index_signature")) + ("member_expression" ("jsx_self_closing_element" "instantiation_expression" "primary_expression" "assignment_expression" "member_expression" "nested_identifier" "jsx_closing_element" "rest_pattern" "augmented_assignment_expression" "pattern" "decorator" "for_in_statement" "jsx_opening_element" "type_query")) + ("meta_property" ("primary_expression")) + ("method_definition" ("object" "class_body")) + ("method_signature" ("object_type" "class_body")) + ("module" ("declaration")) + ("named_imports" ("import_clause")) + ("namespace_export" ("export_statement")) + ("namespace_import" ("import_clause")) + ("nested_identifier" ("import_alias" "module" "nested_type_identifier" "internal_module")) + ("nested_type_identifier" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "generic_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "extends_type_clause" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("new_expression" ("expression")) + ("non_null_expression" ("primary_expression" "assignment_expression" "rest_pattern" "augmented_assignment_expression" "pattern" "for_in_statement")) + ("null" ("primary_expression" "literal_type")) + ("number" ("enum_assignment" "enum_body" "method_definition" "method_signature" "primary_expression" "unary_expression" "pair_pattern" "literal_type" "pair" "public_field_definition" "abstract_method_signature" "subscript_expression" "property_signature")) + ("object" ("primary_expression")) + ("object_assignment_pattern" ("object_pattern")) + ("object_pattern" ("object_assignment_pattern" "variable_declarator" "assignment_expression" "rest_pattern" "pattern" "for_in_statement" "catch_clause")) + ("object_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "interface_declaration" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("omitting_type_annotation" ("index_signature")) + ("opting_type_annotation" ("index_signature")) + ("optional_chain" ("subscript_expression" "member_expression")) + ("optional_parameter" ("formal_parameters" "tuple_type")) + ("optional_type" ("tuple_type")) + ("override_modifier" ("method_definition" "method_signature" "optional_parameter" "required_parameter" "public_field_definition" "property_signature")) + ("pair" ("object")) + ("pair_pattern" ("object_pattern")) + ("parenthesized_expression" ("primary_expression" "assignment_expression" "do_statement" "if_statement" "while_statement" "with_statement" "switch_statement" "augmented_assignment_expression" "for_in_statement")) + ("parenthesized_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("pattern" ("assignment_pattern" "array_pattern" "optional_parameter" "pair_pattern" "required_parameter")) + ("predefined_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "subscript_expression" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("primary_expression" ("expression" "new_expression")) + ("private_property_identifier" ("enum_assignment" "enum_body" "method_definition" "method_signature" "member_expression" "pair_pattern" "pair" "public_field_definition" "abstract_method_signature" "property_signature")) + ("property_identifier" ("ambient_declaration" "enum_assignment" "enum_body" "method_definition" "method_signature" "member_expression" "nested_identifier" "pair_pattern" "pair" "jsx_attribute" "public_field_definition" "abstract_method_signature" "property_signature")) + ("property_signature" ("object_type")) + ("public_field_definition" ("class_body")) + ("readonly_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "constructor_type" "parenthesized_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "opting_type_annotation" "constraint" "lookup_type")) + ("regex" ("primary_expression")) + ("regex_flags" ("regex")) + ("regex_pattern" ("regex")) + ("required_parameter" ("formal_parameters" "tuple_type")) + ("rest_pattern" ("required_parameter" "pattern" "object_pattern")) + ("rest_type" ("tuple_type")) + ("return_statement" ("statement")) + ("satisfies_expression" ("expression")) + ("sequence_expression" ("parenthesized_expression" "for_statement" "throw_statement" "expression_statement" "return_statement" "jsx_expression" "template_substitution" "for_in_statement" "switch_case" "subscript_expression" "sequence_expression")) + ("shorthand_property_identifier" ("object")) + ("shorthand_property_identifier_pattern" ("object_assignment_pattern" "object_pattern")) + ("spread_element" ("array" "jsx_expression" "arguments" "object")) + ("statement" ("for_statement" "statement_block" "do_statement" "if_statement" "while_statement" "with_statement" "labeled_statement" "program" "for_in_statement" "switch_case" "switch_default" "else_clause")) + ("statement_block" ("ambient_declaration" "arrow_function" "method_definition" "statement" "class_static_block" "generator_function_declaration" "internal_module" "function" "finally_clause" "module" "catch_clause" "generator_function" "try_statement" "function_declaration")) + ("statement_identifier" ("continue_statement" "break_statement" "labeled_statement")) + ("string" ("import_require_clause" "import_statement" "method_signature" "pair_pattern" "literal_type" "enum_assignment" "method_definition" "namespace_export" "public_field_definition" "abstract_method_signature" "export_specifier" "pair" "jsx_attribute" "subscript_expression" "property_signature" "enum_body" "export_statement" "primary_expression" "internal_module" "import_specifier" "module")) + ("string_fragment" ("string")) + ("subscript_expression" ("instantiation_expression" "primary_expression" "assignment_expression" "rest_pattern" "type_query" "augmented_assignment_expression" "pattern" "for_in_statement")) + ("super" ("primary_expression")) + ("switch_body" ("switch_statement")) + ("switch_case" ("switch_body")) + ("switch_default" ("switch_body")) + ("switch_statement" ("statement")) + ("template_literal_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("template_string" ("primary_expression" "call_expression")) + ("template_substitution" ("template_string")) + ("template_type" ("template_literal_type")) + ("ternary_expression" ("expression")) + ("this" ("type_predicate" "primary_expression" "optional_parameter" "asserts" "required_parameter")) + ("this_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("throw_statement" ("statement")) + ("true" ("primary_expression" "literal_type")) + ("try_statement" ("statement")) + ("tuple_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("type_alias_declaration" ("declaration")) + ("type_annotation" ("arrow_function" "method_signature" "function_declaration" "parenthesized_expression" "method_definition" "optional_parameter" "public_field_definition" "abstract_method_signature" "catch_clause" "generator_function_declaration" "generator_function" "function_signature" "construct_signature" "function" "property_signature" "index_signature" "call_signature" "variable_declarator" "required_parameter")) + ("type_arguments" ("new_expression" "extends_clause" "call_expression" "jsx_self_closing_element" "instantiation_expression" "jsx_opening_element" "generic_type" "type_assertion")) + ("type_assertion" ("expression")) + ("type_identifier" ("ambient_declaration" "class_declaration" "intersection_type" "satisfies_expression" "type_arguments" "class" "index_type_query" "abstract_class_declaration" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "nested_type_identifier" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "generic_type" "default_type" "rest_type" "interface_declaration" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "extends_type_clause" "flow_maybe_type" "opting_type_annotation" "type_parameter" "lookup_type")) + ("type_parameter" ("type_parameters")) + ("type_parameters" ("arrow_function" "class_declaration" "type_alias_declaration" "function_declaration" "interface_declaration" "function_signature" "method_definition" "method_signature" "construct_signature" "function_type" "generator_function_declaration" "constructor_type" "function" "abstract_method_signature" "class" "generator_function" "abstract_class_declaration" "call_signature")) + ("type_predicate" ("asserts" "function_type" "type_predicate_annotation")) + ("type_predicate_annotation" ("arrow_function" "method_definition" "function_signature" "method_signature" "generator_function_declaration" "call_signature" "function" "abstract_method_signature" "generator_function" "function_declaration")) + ("type_query" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("unary_expression" ("expression" "literal_type")) + ("undefined" ("primary_expression" "assignment_expression" "rest_pattern" "literal_type" "pattern" "for_in_statement")) + ("union_type" ("ambient_declaration" "intersection_type" "satisfies_expression" "type_arguments" "index_type_query" "implements_clause" "type_alias_declaration" "as_expression" "function_type" "tuple_type" "template_type" "constructor_type" "parenthesized_type" "_primary_type" "default_type" "rest_type" "type_annotation" "optional_type" "omitting_type_annotation" "union_type" "mapped_type_clause" "conditional_type" "index_signature" "infer_type" "type_predicate" "readonly_type" "array_type" "constraint" "flow_maybe_type" "opting_type_annotation" "lookup_type")) + ("update_expression" ("expression")) + ("variable_declaration" ("for_statement" "declaration")) + ("variable_declarator" ("lexical_declaration" "variable_declaration")) + ("while_statement" ("statement")) + ("with_statement" ("statement")) + ("yield_expression" ("expression")) + ) +) ;; END Inverse production rules for typescript ;; START All node types in typescript -(defconst combobulate-rules-typescript-types - '("_primary_type" "abstract_class_declaration" "abstract_method_signature" "accessibility_modifier" "ambient_declaration" "arguments" "array" "array_pattern" "array_type" "arrow_function" "as_expression" "asserts" "asserts_annotation" "assignment_expression" "assignment_pattern" "augmented_assignment_expression" "await_expression" "binary_expression" "break_statement" "call_expression" "call_signature" "catch_clause" "class" "class_body" "class_declaration" "class_heritage" "class_static_block" "comment" "computed_property_name" "conditional_type" "constraint" "construct_signature" "constructor_type" "continue_statement" "debugger_statement" "declaration" "decorator" "default_type" "do_statement" "else_clause" "empty_statement" "enum_assignment" "enum_body" "enum_declaration" "escape_sequence" "existential_type" "export_clause" "export_specifier" "export_statement" "expression" "expression_statement" "extends_clause" "extends_type_clause" "false" "finally_clause" "flow_maybe_type" "for_in_statement" "for_statement" "formal_parameters" "function" "function_declaration" "function_signature" "function_type" "generator_function" "generator_function_declaration" "generic_type" "glimmer_closing_tag" "glimmer_opening_tag" "glimmer_template" "hash_bang_line" "identifier" "if_statement" "implements_clause" "import" "import_alias" "import_clause" "import_require_clause" "import_specifier" "import_statement" "index_signature" "index_type_query" "infer_type" "instantiation_expression" "interface_declaration" "internal_module" "intersection_type" "jsx_attribute" "jsx_closing_element" "jsx_element" "jsx_expression" "jsx_namespace_name" "jsx_opening_element" "jsx_self_closing_element" "jsx_text" "labeled_statement" "lexical_declaration" "literal_type" "lookup_type" "mapped_type_clause" "member_expression" "meta_property" "method_definition" "method_signature" "module" "named_imports" "namespace_export" "namespace_import" "nested_identifier" "nested_type_identifier" "new_expression" "non_null_expression" "null" "number" "object" "object_assignment_pattern" "object_pattern" "object_type" "omitting_type_annotation" "opting_type_annotation" "optional_chain" "optional_parameter" "optional_type" "override_modifier" "pair" "pair_pattern" "parenthesized_expression" "parenthesized_type" "pattern" "predefined_type" "primary_expression" "private_property_identifier" "program" "property_identifier" "property_signature" "public_field_definition" "readonly_type" "regex" "regex_flags" "regex_pattern" "required_parameter" "rest_pattern" "rest_type" "return_statement" "satisfies_expression" "sequence_expression" "shorthand_property_identifier" "shorthand_property_identifier_pattern" "spread_element" "statement" "statement_block" "statement_identifier" "string" "string_fragment" "subscript_expression" "super" "switch_body" "switch_case" "switch_default" "switch_statement" "template_literal_type" "template_string" "template_substitution" "template_type" "ternary_expression" "this" "this_type" "throw_statement" "true" "try_statement" "tuple_type" "type_alias_declaration" "type_annotation" "type_arguments" "type_assertion" "type_identifier" "type_parameter" "type_parameters" "type_predicate" "type_predicate_annotation" "type_query" "unary_expression" "undefined" "union_type" "update_expression" "variable_declaration" "variable_declarator" "while_statement" "with_statement" "yield_expression") - ) +(defconst combobulate-rules-typescript-types + '("_primary_type" "abstract_class_declaration" "abstract_method_signature" "accessibility_modifier" "ambient_declaration" "arguments" "array" "array_pattern" "array_type" "arrow_function" "as_expression" "asserts" "asserts_annotation" "assignment_expression" "assignment_pattern" "augmented_assignment_expression" "await_expression" "binary_expression" "break_statement" "call_expression" "call_signature" "catch_clause" "class" "class_body" "class_declaration" "class_heritage" "class_static_block" "comment" "computed_property_name" "conditional_type" "constraint" "construct_signature" "constructor_type" "continue_statement" "debugger_statement" "declaration" "decorator" "default_type" "do_statement" "else_clause" "empty_statement" "enum_assignment" "enum_body" "enum_declaration" "escape_sequence" "existential_type" "export_clause" "export_specifier" "export_statement" "expression" "expression_statement" "extends_clause" "extends_type_clause" "false" "finally_clause" "flow_maybe_type" "for_in_statement" "for_statement" "formal_parameters" "function" "function_declaration" "function_signature" "function_type" "generator_function" "generator_function_declaration" "generic_type" "glimmer_closing_tag" "glimmer_opening_tag" "glimmer_template" "hash_bang_line" "identifier" "if_statement" "implements_clause" "import" "import_alias" "import_clause" "import_require_clause" "import_specifier" "import_statement" "index_signature" "index_type_query" "infer_type" "instantiation_expression" "interface_declaration" "internal_module" "intersection_type" "jsx_attribute" "jsx_closing_element" "jsx_element" "jsx_expression" "jsx_namespace_name" "jsx_opening_element" "jsx_self_closing_element" "jsx_text" "labeled_statement" "lexical_declaration" "literal_type" "lookup_type" "mapped_type_clause" "member_expression" "meta_property" "method_definition" "method_signature" "module" "named_imports" "namespace_export" "namespace_import" "nested_identifier" "nested_type_identifier" "new_expression" "non_null_expression" "null" "number" "object" "object_assignment_pattern" "object_pattern" "object_type" "omitting_type_annotation" "opting_type_annotation" "optional_chain" "optional_parameter" "optional_type" "override_modifier" "pair" "pair_pattern" "parenthesized_expression" "parenthesized_type" "pattern" "predefined_type" "primary_expression" "private_property_identifier" "program" "property_identifier" "property_signature" "public_field_definition" "readonly_type" "regex" "regex_flags" "regex_pattern" "required_parameter" "rest_pattern" "rest_type" "return_statement" "satisfies_expression" "sequence_expression" "shorthand_property_identifier" "shorthand_property_identifier_pattern" "spread_element" "statement" "statement_block" "statement_identifier" "string" "string_fragment" "subscript_expression" "super" "switch_body" "switch_case" "switch_default" "switch_statement" "template_literal_type" "template_string" "template_substitution" "template_type" "ternary_expression" "this" "this_type" "throw_statement" "true" "try_statement" "tuple_type" "type_alias_declaration" "type_annotation" "type_arguments" "type_assertion" "type_identifier" "type_parameter" "type_parameters" "type_predicate" "type_predicate_annotation" "type_query" "unary_expression" "undefined" "union_type" "update_expression" "variable_declaration" "variable_declarator" "while_statement" "with_statement" "yield_expression") +) ;; END All node types in typescript +;; START All supertypes in typescript +(defconst combobulate-rules-typescript-supertypes + '("_primary_type" "declaration" "expression" "pattern" "primary_expression" "statement") +) +;; END All supertypes in typescript ;; START Production rules for javascript -(defconst combobulate-rules-javascript - '(("declaration" (:*unnamed* ("function_declaration" "class_declaration" "variable_declaration" "lexical_declaration" "generator_function_declaration"))) - ("expression" (:*unnamed* ("primary_expression" "jsx_element" "jsx_self_closing_element" "unary_expression" "yield_expression" "update_expression" "await_expression" "glimmer_template" "ternary_expression" "binary_expression" "augmented_assignment_expression" "new_expression" "assignment_expression"))) - ("pattern" (:*unnamed* ("member_expression" "identifier" "undefined" "rest_pattern" "object_pattern" "array_pattern" "subscript_expression"))) - ("primary_expression" (:*unnamed* ("member_expression" "array" "identifier" "string" "undefined" "parenthesized_expression" "arrow_function" "generator_function" "template_string" "call_expression" "class" "function" "subscript_expression" "false" "number" "regex" "super" "object" "true" "this" "null" "meta_property" "import"))) - ("statement" (:*unnamed* ("continue_statement" "for_statement" "with_statement" "export_statement" "import_statement" "if_statement" "do_statement" "declaration" "return_statement" "throw_statement" "for_in_statement" "while_statement" "empty_statement" "switch_statement" "expression_statement" "break_statement" "debugger_statement" "try_statement" "statement_block" "labeled_statement"))) - ("arguments" (:*unnamed* ("spread_element" "expression"))) - ("array" (:*unnamed* ("spread_element" "expression"))) - ("array_pattern" (:*unnamed* ("pattern" "assignment_pattern"))) - ("arrow_function" (:body ("statement_block" "expression") :parameter ("identifier") :parameters ("formal_parameters"))) - ("assignment_expression" (:left ("member_expression" "identifier" "undefined" "object_pattern" "parenthesized_expression" "array_pattern" "subscript_expression") :right ("expression"))) - ("assignment_pattern" (:left ("pattern") :right ("expression"))) - ("augmented_assignment_expression" (:left ("member_expression" "parenthesized_expression" "identifier" "subscript_expression") :operator nil :right ("expression"))) - ("await_expression" (:*unnamed* ("expression"))) - ("binary_expression" (:left ("private_property_identifier" "expression") :operator nil :right ("expression"))) - ("break_statement" (:label ("statement_identifier"))) - ("call_expression" (:arguments ("arguments" "template_string") :function ("expression") :optional_chain ("optional_chain"))) - ("catch_clause" (:body ("statement_block") :parameter ("object_pattern" "identifier" "array_pattern"))) - ("class" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("identifier"))) - ("class_body" (:member ("field_definition" "method_definition" "class_static_block") :template ("glimmer_template"))) - ("class_declaration" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("identifier"))) - ("class_heritage" (:*unnamed* ("expression"))) - ("class_static_block" (:body ("statement_block"))) - ("computed_property_name" (:*unnamed* ("expression"))) - ("continue_statement" (:label ("statement_identifier"))) - ("decorator" (:*unnamed* ("member_expression" "identifier" "call_expression"))) - ("do_statement" (:body ("statement") :condition ("parenthesized_expression"))) - ("else_clause" (:*unnamed* ("statement"))) - ("export_clause" (:*unnamed* ("export_specifier"))) - ("export_specifier" (:alias ("string" "identifier") :name ("string" "identifier"))) - ("export_statement" (:*unnamed* ("export_clause" "namespace_export") :declaration ("declaration") :decorator ("decorator") :source ("string") :value ("expression"))) - ("expression_statement" (:*unnamed* ("sequence_expression" "expression"))) - ("field_definition" (:decorator ("decorator") :property ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :value ("expression"))) - ("finally_clause" (:body ("statement_block"))) - ("for_in_statement" (:body ("statement") :kind nil :left ("member_expression" "identifier" "undefined" "object_pattern" "parenthesized_expression" "array_pattern" "subscript_expression") :operator nil :right ("sequence_expression" "expression") :value ("expression"))) - ("for_statement" (:body ("statement") :condition ("expression_statement" "empty_statement") :increment ("sequence_expression" "expression") :initializer ("lexical_declaration" "expression_statement" "variable_declaration" "empty_statement"))) - ("formal_parameters" (:*unnamed* ("pattern" "assignment_pattern"))) - ("function" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) - ("function_declaration" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) - ("generator_function" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) - ("generator_function_declaration" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) - ("glimmer_template" (:close_tag ("glimmer_closing_tag") :open_tag ("glimmer_opening_tag"))) - ("if_statement" (:alternative ("else_clause") :condition ("parenthesized_expression") :consequence ("statement"))) - ("import_clause" (:*unnamed* ("namespace_import" "identifier" "named_imports"))) - ("import_specifier" (:alias ("identifier") :name ("string" "identifier"))) - ("import_statement" (:*unnamed* ("import_clause") :source ("string"))) - ("jsx_attribute" (:*unnamed* ("jsx_expression" "jsx_namespace_name" "jsx_element" "string" "jsx_self_closing_element" "property_identifier"))) - ("jsx_closing_element" (:name ("member_expression" "jsx_namespace_name" "identifier"))) - ("jsx_element" (:*unnamed* ("jsx_expression" "jsx_element" "jsx_text" "jsx_self_closing_element") :close_tag ("jsx_closing_element") :open_tag ("jsx_opening_element"))) - ("jsx_expression" (:*unnamed* ("sequence_expression" "spread_element" "expression"))) - ("jsx_namespace_name" (:*unnamed* ("identifier"))) - ("jsx_opening_element" (:attribute ("jsx_expression" "jsx_attribute") :name ("member_expression" "jsx_namespace_name" "identifier"))) - ("jsx_self_closing_element" (:attribute ("jsx_expression" "jsx_attribute") :name ("member_expression" "jsx_namespace_name" "identifier"))) - ("labeled_statement" (:body ("statement") :label ("statement_identifier"))) - ("lexical_declaration" (:*unnamed* ("variable_declarator") :kind nil)) - ("member_expression" (:*unnamed* ("member_expression" "identifier" "property_identifier") :object ("expression") :optional_chain ("optional_chain") :property ("private_property_identifier" "property_identifier"))) - ("method_definition" (:body ("statement_block") :decorator ("decorator") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :parameters ("formal_parameters"))) - ("named_imports" (:*unnamed* ("import_specifier"))) - ("namespace_export" (:*unnamed* ("string" "identifier"))) - ("namespace_import" (:*unnamed* ("identifier"))) - ("new_expression" (:arguments ("arguments") :constructor ("primary_expression" "new_expression"))) - ("object" (:*unnamed* ("method_definition" "pair" "spread_element" "shorthand_property_identifier"))) - ("object_assignment_pattern" (:left ("shorthand_property_identifier_pattern" "object_pattern" "array_pattern") :right ("expression"))) - ("object_pattern" (:*unnamed* ("shorthand_property_identifier_pattern" "object_assignment_pattern" "rest_pattern" "pair_pattern"))) - ("pair" (:key ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :value ("expression"))) - ("pair_pattern" (:key ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :value ("pattern" "assignment_pattern"))) - ("parenthesized_expression" (:*unnamed* ("sequence_expression" "expression"))) - ("program" (:*unnamed* ("hash_bang_line" "statement"))) - ("regex" (:flags ("regex_flags") :pattern ("regex_pattern"))) - ("rest_pattern" (:*unnamed* ("member_expression" "identifier" "undefined" "object_pattern" "array_pattern" "subscript_expression"))) - ("return_statement" (:*unnamed* ("sequence_expression" "expression"))) - ("sequence_expression" (:left ("expression") :right ("sequence_expression" "expression"))) - ("spread_element" (:*unnamed* ("expression"))) - ("statement_block" (:*unnamed* ("statement"))) - ("string" (:*unnamed* ("string_fragment" "escape_sequence"))) - ("subscript_expression" (:index ("sequence_expression" "expression") :object ("expression") :optional_chain ("optional_chain"))) - ("switch_body" (:*unnamed* ("switch_case" "switch_default"))) - ("switch_case" (:body ("statement") :value ("sequence_expression" "expression"))) - ("switch_default" (:body ("statement"))) - ("switch_statement" (:body ("switch_body") :value ("parenthesized_expression"))) - ("template_string" (:*unnamed* ("template_substitution" "escape_sequence"))) - ("template_substitution" (:*unnamed* ("sequence_expression" "expression"))) - ("ternary_expression" (:alternative ("expression") :condition ("expression") :consequence ("expression"))) - ("throw_statement" (:*unnamed* ("sequence_expression" "expression"))) - ("try_statement" (:body ("statement_block") :finalizer ("finally_clause") :handler ("catch_clause"))) - ("unary_expression" (:argument ("expression") :operator nil)) - ("update_expression" (:argument ("expression") :operator nil)) - ("variable_declaration" (:*unnamed* ("variable_declarator"))) - ("variable_declarator" (:name ("object_pattern" "identifier" "array_pattern") :value ("expression"))) - ("while_statement" (:body ("statement") :condition ("parenthesized_expression"))) - ("with_statement" (:body ("statement") :object ("parenthesized_expression"))) - ("yield_expression" (:*unnamed* ("expression"))) - ("comment" (:*unnamed* nil)) - ("escape_sequence" (:*unnamed* nil)) - ("false" (:*unnamed* nil)) - ("hash_bang_line" (:*unnamed* nil)) - ("identifier" (:*unnamed* nil)) - ("null" (:*unnamed* nil)) - ("number" (:*unnamed* nil)) - ("optional_chain" (:*unnamed* nil)) - ("private_property_identifier" (:*unnamed* nil)) - ("property_identifier" (:*unnamed* nil)) - ("regex_flags" (:*unnamed* nil)) - ("regex_pattern" (:*unnamed* nil)) - ("shorthand_property_identifier" (:*unnamed* nil)) - ("shorthand_property_identifier_pattern" (:*unnamed* nil)) - ("statement_identifier" (:*unnamed* nil)) - ("string_fragment" (:*unnamed* nil)) - ("super" (:*unnamed* nil)) - ("this" (:*unnamed* nil)) - ("true" (:*unnamed* nil)) - ("undefined" (:*unnamed* nil)) - )) +(defconst combobulate-rules-javascript + '(("declaration" (:*unnamed* ("class_declaration" "lexical_declaration" "variable_declaration" "generator_function_declaration" "function_declaration"))) + ("expression" (:*unnamed* ("new_expression" "jsx_self_closing_element" "update_expression" "ternary_expression" "primary_expression" "jsx_element" "assignment_expression" "unary_expression" "glimmer_template" "augmented_assignment_expression" "binary_expression" "yield_expression" "await_expression"))) + ("pattern" (:*unnamed* ("identifier" "rest_pattern" "member_expression" "undefined" "subscript_expression" "array_pattern" "object_pattern"))) + ("primary_expression" (:*unnamed* ("arrow_function" "false" "object" "template_string" "undefined" "meta_property" "function" "number" "class" "subscript_expression" "parenthesized_expression" "call_expression" "import" "true" "string" "member_expression" "identifier" "null" "regex" "array" "super" "this" "generator_function"))) + ("statement" (:*unnamed* ("break_statement" "import_statement" "expression_statement" "do_statement" "with_statement" "if_statement" "continue_statement" "switch_statement" "try_statement" "declaration" "empty_statement" "for_statement" "debugger_statement" "export_statement" "statement_block" "throw_statement" "while_statement" "return_statement" "labeled_statement" "for_in_statement"))) + ("arguments" (:*unnamed* ("expression" "spread_element"))) + ("array" (:*unnamed* ("expression" "spread_element"))) + ("array_pattern" (:*unnamed* ("assignment_pattern" "pattern"))) + ("arrow_function" (:*unnamed* nil :body ("expression" "statement_block") :parameter ("identifier") :parameters ("formal_parameters"))) + ("assignment_expression" (:*unnamed* nil :left ("parenthesized_expression" "identifier" "member_expression" "undefined" "subscript_expression" "array_pattern" "object_pattern") :right ("expression"))) + ("assignment_pattern" (:*unnamed* nil :left ("pattern") :right ("expression"))) + ("augmented_assignment_expression" (:*unnamed* nil :left ("identifier" "subscript_expression" "parenthesized_expression" "member_expression") :operator nil :right ("expression"))) + ("await_expression" (:*unnamed* ("expression"))) + ("binary_expression" (:*unnamed* nil :left ("expression" "private_property_identifier") :operator nil :right ("expression"))) + ("break_statement" (:*unnamed* nil :label ("statement_identifier"))) + ("call_expression" (:*unnamed* nil :arguments ("arguments" "template_string") :function ("expression") :optional_chain ("optional_chain"))) + ("catch_clause" (:*unnamed* nil :body ("statement_block") :parameter ("identifier" "array_pattern" "object_pattern"))) + ("class" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("identifier"))) + ("class_body" (:*unnamed* nil :member ("field_definition" "class_static_block" "method_definition") :template ("glimmer_template"))) + ("class_declaration" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("identifier"))) + ("class_heritage" (:*unnamed* ("expression"))) + ("class_static_block" (:*unnamed* nil :body ("statement_block"))) + ("computed_property_name" (:*unnamed* ("expression"))) + ("continue_statement" (:*unnamed* nil :label ("statement_identifier"))) + ("debugger_statement" (:*unnamed* nil)) + ("decorator" (:*unnamed* ("identifier" "call_expression" "member_expression"))) + ("do_statement" (:*unnamed* nil :body ("statement") :condition ("parenthesized_expression"))) + ("else_clause" (:*unnamed* ("statement"))) + ("empty_statement" (:*unnamed* nil)) + ("export_clause" (:*unnamed* ("export_specifier"))) + ("export_specifier" (:*unnamed* nil :alias ("identifier" "string") :name ("identifier" "string"))) + ("export_statement" (:*unnamed* ("namespace_export" "export_clause") :declaration ("declaration") :decorator ("decorator") :source ("string") :value ("expression"))) + ("expression_statement" (:*unnamed* ("expression" "sequence_expression"))) + ("field_definition" (:*unnamed* nil :decorator ("decorator") :property ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :value ("expression"))) + ("finally_clause" (:*unnamed* nil :body ("statement_block"))) + ("for_in_statement" (:*unnamed* nil :body ("statement") :kind nil :left ("parenthesized_expression" "identifier" "member_expression" "undefined" "subscript_expression" "array_pattern" "object_pattern") :operator nil :right ("expression" "sequence_expression") :value ("expression"))) + ("for_statement" (:*unnamed* nil :body ("statement") :condition ("empty_statement" "expression_statement") :increment ("expression" "sequence_expression") :initializer ("empty_statement" "lexical_declaration" "expression_statement" "variable_declaration"))) + ("formal_parameters" (:*unnamed* ("assignment_pattern" "pattern"))) + ("function" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) + ("function_declaration" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) + ("generator_function" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) + ("generator_function_declaration" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) + ("glimmer_closing_tag" (:*unnamed* nil)) + ("glimmer_opening_tag" (:*unnamed* nil)) + ("glimmer_template" (:*unnamed* nil :close_tag ("glimmer_closing_tag") :open_tag ("glimmer_opening_tag"))) + ("if_statement" (:*unnamed* nil :alternative ("else_clause") :condition ("parenthesized_expression") :consequence ("statement"))) + ("import" (:*unnamed* nil)) + ("import_clause" (:*unnamed* ("identifier" "named_imports" "namespace_import"))) + ("import_specifier" (:*unnamed* nil :alias ("identifier") :name ("identifier" "string"))) + ("import_statement" (:*unnamed* ("import_clause") :source ("string"))) + ("jsx_attribute" (:*unnamed* ("jsx_expression" "jsx_self_closing_element" "property_identifier" "jsx_namespace_name" "jsx_element" "string"))) + ("jsx_closing_element" (:*unnamed* nil :name ("identifier" "jsx_namespace_name" "member_expression"))) + ("jsx_element" (:*unnamed* ("jsx_self_closing_element" "jsx_text" "jsx_expression" "jsx_element") :close_tag ("jsx_closing_element") :open_tag ("jsx_opening_element"))) + ("jsx_expression" (:*unnamed* ("expression" "sequence_expression" "spread_element"))) + ("jsx_namespace_name" (:*unnamed* ("identifier"))) + ("jsx_opening_element" (:*unnamed* nil :attribute ("jsx_expression" "jsx_attribute") :name ("identifier" "jsx_namespace_name" "member_expression"))) + ("jsx_self_closing_element" (:*unnamed* nil :attribute ("jsx_expression" "jsx_attribute") :name ("identifier" "jsx_namespace_name" "member_expression"))) + ("jsx_text" (:*unnamed* nil)) + ("labeled_statement" (:*unnamed* nil :body ("statement") :label ("statement_identifier"))) + ("lexical_declaration" (:*unnamed* ("variable_declarator") :kind nil)) + ("member_expression" (:*unnamed* ("identifier" "property_identifier" "member_expression") :object ("expression") :optional_chain ("optional_chain") :property ("property_identifier" "private_property_identifier"))) + ("meta_property" (:*unnamed* nil)) + ("method_definition" (:*unnamed* nil :body ("statement_block") :decorator ("decorator") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :parameters ("formal_parameters"))) + ("named_imports" (:*unnamed* ("import_specifier"))) + ("namespace_export" (:*unnamed* ("identifier" "string"))) + ("namespace_import" (:*unnamed* ("identifier"))) + ("new_expression" (:*unnamed* nil :arguments ("arguments") :constructor ("new_expression" "primary_expression"))) + ("object" (:*unnamed* ("pair" "method_definition" "shorthand_property_identifier" "spread_element"))) + ("object_assignment_pattern" (:*unnamed* nil :left ("shorthand_property_identifier_pattern" "array_pattern" "object_pattern") :right ("expression"))) + ("object_pattern" (:*unnamed* ("object_assignment_pattern" "shorthand_property_identifier_pattern" "rest_pattern" "pair_pattern"))) + ("pair" (:*unnamed* nil :key ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :value ("expression"))) + ("pair_pattern" (:*unnamed* nil :key ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :value ("assignment_pattern" "pattern"))) + ("parenthesized_expression" (:*unnamed* ("expression" "sequence_expression"))) + ("program" (:*unnamed* ("statement" "hash_bang_line"))) + ("regex" (:*unnamed* nil :flags ("regex_flags") :pattern ("regex_pattern"))) + ("rest_pattern" (:*unnamed* ("identifier" "member_expression" "undefined" "subscript_expression" "array_pattern" "object_pattern"))) + ("return_statement" (:*unnamed* ("expression" "sequence_expression"))) + ("sequence_expression" (:*unnamed* nil :left ("expression") :right ("expression" "sequence_expression"))) + ("spread_element" (:*unnamed* ("expression"))) + ("statement_block" (:*unnamed* ("statement"))) + ("string" (:*unnamed* ("string_fragment" "escape_sequence"))) + ("subscript_expression" (:*unnamed* nil :index ("expression" "sequence_expression") :object ("expression") :optional_chain ("optional_chain"))) + ("switch_body" (:*unnamed* ("switch_case" "switch_default"))) + ("switch_case" (:*unnamed* nil :body ("statement") :value ("expression" "sequence_expression"))) + ("switch_default" (:*unnamed* nil :body ("statement"))) + ("switch_statement" (:*unnamed* nil :body ("switch_body") :value ("parenthesized_expression"))) + ("template_string" (:*unnamed* ("template_substitution" "escape_sequence"))) + ("template_substitution" (:*unnamed* ("expression" "sequence_expression"))) + ("ternary_expression" (:*unnamed* nil :alternative ("expression") :condition ("expression") :consequence ("expression"))) + ("throw_statement" (:*unnamed* ("expression" "sequence_expression"))) + ("try_statement" (:*unnamed* nil :body ("statement_block") :finalizer ("finally_clause") :handler ("catch_clause"))) + ("unary_expression" (:*unnamed* nil :argument ("expression") :operator nil)) + ("update_expression" (:*unnamed* nil :argument ("expression") :operator nil)) + ("variable_declaration" (:*unnamed* ("variable_declarator"))) + ("variable_declarator" (:*unnamed* nil :name ("identifier" "array_pattern" "object_pattern") :value ("expression"))) + ("while_statement" (:*unnamed* nil :body ("statement") :condition ("parenthesized_expression"))) + ("with_statement" (:*unnamed* nil :body ("statement") :object ("parenthesized_expression"))) + ("yield_expression" (:*unnamed* ("expression"))) + ("comment" (:*unnamed* nil)) + ("escape_sequence" (:*unnamed* nil)) + ("false" (:*unnamed* nil)) + ("hash_bang_line" (:*unnamed* nil)) + ("identifier" (:*unnamed* nil)) + ("null" (:*unnamed* nil)) + ("number" (:*unnamed* nil)) + ("optional_chain" (:*unnamed* nil)) + ("private_property_identifier" (:*unnamed* nil)) + ("property_identifier" (:*unnamed* nil)) + ("regex_flags" (:*unnamed* nil)) + ("regex_pattern" (:*unnamed* nil)) + ("shorthand_property_identifier" (:*unnamed* nil)) + ("shorthand_property_identifier_pattern" (:*unnamed* nil)) + ("statement_identifier" (:*unnamed* nil)) + ("string_fragment" (:*unnamed* nil)) + ("super" (:*unnamed* nil)) + ("this" (:*unnamed* nil)) + ("true" (:*unnamed* nil)) + ("undefined" (:*unnamed* nil)) +)) ;; END Production rules for javascript ;; START Inverse production rules for javascript -(defconst combobulate-rules-javascript-inverse - '(("arguments" ("new_expression" "call_expression")) - ("array" ("primary_expression")) - ("array_pattern" ("for_in_statement" "pattern" "assignment_expression" "rest_pattern" "object_assignment_pattern" "variable_declarator" "catch_clause")) - ("arrow_function" ("primary_expression")) - ("assignment_expression" ("expression")) - ("assignment_pattern" ("formal_parameters" "pair_pattern" "array_pattern")) - ("augmented_assignment_expression" ("expression")) - ("await_expression" ("expression")) - ("binary_expression" ("expression")) - ("break_statement" ("statement")) - ("call_expression" ("primary_expression" "decorator")) - ("catch_clause" ("try_statement")) - ("class" ("primary_expression")) - ("class_body" ("class_declaration" "class")) - ("class_declaration" ("declaration")) - ("class_heritage" ("class_declaration" "class")) - ("class_static_block" ("class_body")) - ("computed_property_name" ("field_definition" "pair_pattern" "pair" "method_definition")) - ("continue_statement" ("statement")) - ("debugger_statement" ("statement")) - ("declaration" ("export_statement" "statement")) - ("decorator" ("method_definition" "export_statement" "class_declaration" "field_definition" "class")) - ("do_statement" ("statement")) - ("else_clause" ("if_statement")) - ("empty_statement" ("for_statement" "statement")) - ("escape_sequence" ("template_string" "string")) - ("export_clause" ("export_statement")) - ("export_specifier" ("export_clause")) - ("export_statement" ("statement")) - ("expression" ("jsx_expression" "member_expression" "sequence_expression" "parenthesized_expression" "class_heritage" "spread_element" "binary_expression" "return_statement" "computed_property_name" "field_definition" "switch_case" "await_expression" "ternary_expression" "pair" "object_assignment_pattern" "variable_declarator" "template_substitution" "array" "for_statement" "yield_expression" "export_statement" "arrow_function" "call_expression" "augmented_assignment_expression" "for_in_statement" "throw_statement" "subscript_expression" "assignment_expression" "arguments" "expression_statement" "update_expression" "assignment_pattern" "unary_expression")) - ("expression_statement" ("for_statement" "statement")) - ("false" ("primary_expression")) - ("field_definition" ("class_body")) - ("finally_clause" ("try_statement")) - ("for_in_statement" ("statement")) - ("for_statement" ("statement")) - ("formal_parameters" ("method_definition" "arrow_function" "generator_function_declaration" "generator_function" "function_declaration" "function")) - ("function" ("primary_expression")) - ("function_declaration" ("declaration")) - ("generator_function" ("primary_expression")) - ("generator_function_declaration" ("declaration")) - ("glimmer_closing_tag" ("glimmer_template")) - ("glimmer_opening_tag" ("glimmer_template")) - ("glimmer_template" ("expression" "class_body")) - ("hash_bang_line" ("program")) - ("identifier" ("member_expression" "jsx_closing_element" "class_declaration" "rest_pattern" "class" "namespace_import" "export_specifier" "jsx_self_closing_element" "generator_function_declaration" "function_declaration" "variable_declarator" "import_clause" "catch_clause" "arrow_function" "generator_function" "namespace_export" "augmented_assignment_expression" "import_specifier" "for_in_statement" "function" "assignment_expression" "primary_expression" "jsx_namespace_name" "pattern" "decorator" "jsx_opening_element")) - ("if_statement" ("statement")) - ("import" ("primary_expression")) - ("import_clause" ("import_statement")) - ("import_specifier" ("named_imports")) - ("import_statement" ("statement")) - ("jsx_attribute" ("jsx_self_closing_element" "jsx_opening_element")) - ("jsx_closing_element" ("jsx_element")) - ("jsx_element" ("jsx_attribute" "jsx_element" "expression")) - ("jsx_expression" ("jsx_self_closing_element" "jsx_attribute" "jsx_element" "jsx_opening_element")) - ("jsx_namespace_name" ("jsx_self_closing_element" "jsx_attribute" "jsx_closing_element" "jsx_opening_element")) - ("jsx_opening_element" ("jsx_element")) - ("jsx_self_closing_element" ("jsx_attribute" "jsx_element" "expression")) - ("jsx_text" ("jsx_element")) - ("labeled_statement" ("statement")) - ("lexical_declaration" ("for_statement" "declaration")) - ("member_expression" ("member_expression" "primary_expression" "pattern" "jsx_self_closing_element" "jsx_closing_element" "decorator" "rest_pattern" "augmented_assignment_expression" "jsx_opening_element" "for_in_statement" "assignment_expression")) - ("meta_property" ("primary_expression")) - ("method_definition" ("object" "class_body")) - ("named_imports" ("import_clause")) - ("namespace_export" ("export_statement")) - ("namespace_import" ("import_clause")) - ("new_expression" ("new_expression" "expression")) - ("null" ("primary_expression")) - ("number" ("primary_expression" "method_definition" "pair" "pair_pattern" "field_definition")) - ("object" ("primary_expression")) - ("object_assignment_pattern" ("object_pattern")) - ("object_pattern" ("for_in_statement" "pattern" "assignment_expression" "rest_pattern" "object_assignment_pattern" "variable_declarator" "catch_clause")) - ("optional_chain" ("member_expression" "call_expression" "subscript_expression")) - ("pair" ("object")) - ("pair_pattern" ("object_pattern")) - ("parenthesized_expression" ("primary_expression" "while_statement" "switch_statement" "with_statement" "if_statement" "do_statement" "augmented_assignment_expression" "for_in_statement" "assignment_expression")) - ("pattern" ("formal_parameters" "assignment_pattern" "pair_pattern" "array_pattern")) - ("primary_expression" ("new_expression" "expression")) - ("private_property_identifier" ("member_expression" "method_definition" "pair" "binary_expression" "pair_pattern" "field_definition")) - ("property_identifier" ("member_expression" "jsx_attribute" "method_definition" "pair" "pair_pattern" "field_definition")) - ("regex" ("primary_expression")) - ("regex_flags" ("regex")) - ("regex_pattern" ("regex")) - ("rest_pattern" ("pattern" "object_pattern")) - ("return_statement" ("statement")) - ("sequence_expression" ("jsx_expression" "sequence_expression" "parenthesized_expression" "for_statement" "throw_statement" "expression_statement" "return_statement" "switch_case" "for_in_statement" "template_substitution" "subscript_expression")) - ("shorthand_property_identifier" ("object")) - ("shorthand_property_identifier_pattern" ("object_assignment_pattern" "object_pattern")) - ("spread_element" ("array" "arguments" "jsx_expression" "object")) - ("statement" ("switch_default" "while_statement" "for_statement" "statement_block" "with_statement" "if_statement" "do_statement" "else_clause" "labeled_statement" "program" "switch_case" "for_in_statement")) - ("statement_block" ("finally_clause" "method_definition" "statement" "arrow_function" "generator_function" "generator_function_declaration" "try_statement" "function_declaration" "class_static_block" "function" "catch_clause")) - ("statement_identifier" ("labeled_statement" "continue_statement" "break_statement")) - ("string" ("primary_expression" "jsx_attribute" "export_specifier" "method_definition" "export_statement" "import_statement" "pair" "namespace_export" "pair_pattern" "import_specifier" "field_definition")) - ("string_fragment" ("string")) - ("subscript_expression" ("primary_expression" "pattern" "rest_pattern" "augmented_assignment_expression" "for_in_statement" "assignment_expression")) - ("super" ("primary_expression")) - ("switch_body" ("switch_statement")) - ("switch_case" ("switch_body")) - ("switch_default" ("switch_body")) - ("switch_statement" ("statement")) - ("template_string" ("primary_expression" "call_expression")) - ("template_substitution" ("template_string")) - ("ternary_expression" ("expression")) - ("this" ("primary_expression")) - ("throw_statement" ("statement")) - ("true" ("primary_expression")) - ("try_statement" ("statement")) - ("unary_expression" ("expression")) - ("undefined" ("primary_expression" "pattern" "rest_pattern" "for_in_statement" "assignment_expression")) - ("update_expression" ("expression")) - ("variable_declaration" ("for_statement" "declaration")) - ("variable_declarator" ("variable_declaration" "lexical_declaration")) - ("while_statement" ("statement")) - ("with_statement" ("statement")) - ("yield_expression" ("expression")) - ) - ) +(defconst combobulate-rules-javascript-inverse + '(("arguments" ("new_expression" "call_expression")) + ("array" ("primary_expression")) + ("array_pattern" ("object_assignment_pattern" "variable_declarator" "assignment_expression" "rest_pattern" "pattern" "for_in_statement" "catch_clause")) + ("arrow_function" ("primary_expression")) + ("assignment_expression" ("expression")) + ("assignment_pattern" ("pair_pattern" "formal_parameters" "array_pattern")) + ("augmented_assignment_expression" ("expression")) + ("await_expression" ("expression")) + ("binary_expression" ("expression")) + ("break_statement" ("statement")) + ("call_expression" ("primary_expression" "decorator")) + ("catch_clause" ("try_statement")) + ("class" ("primary_expression")) + ("class_body" ("class_declaration" "class")) + ("class_declaration" ("declaration")) + ("class_heritage" ("class_declaration" "class")) + ("class_static_block" ("class_body")) + ("computed_property_name" ("field_definition" "pair" "method_definition" "pair_pattern")) + ("continue_statement" ("statement")) + ("debugger_statement" ("statement")) + ("declaration" ("statement" "export_statement")) + ("decorator" ("field_definition" "class_declaration" "export_statement" "method_definition" "class")) + ("do_statement" ("statement")) + ("else_clause" ("if_statement")) + ("empty_statement" ("statement" "for_statement")) + ("escape_sequence" ("string" "template_string")) + ("export_clause" ("export_statement")) + ("export_specifier" ("export_clause")) + ("export_statement" ("statement")) + ("expression" ("arrow_function" "update_expression" "jsx_expression" "binary_expression" "computed_property_name" "parenthesized_expression" "call_expression" "for_statement" "spread_element" "member_expression" "return_statement" "for_in_statement" "yield_expression" "await_expression" "object_assignment_pattern" "ternary_expression" "expression_statement" "assignment_expression" "pair" "switch_case" "subscript_expression" "field_definition" "variable_declarator" "export_statement" "assignment_pattern" "throw_statement" "unary_expression" "class_heritage" "arguments" "augmented_assignment_expression" "template_substitution" "array" "sequence_expression")) + ("expression_statement" ("statement" "for_statement")) + ("false" ("primary_expression")) + ("field_definition" ("class_body")) + ("finally_clause" ("try_statement")) + ("for_in_statement" ("statement")) + ("for_statement" ("statement")) + ("formal_parameters" ("arrow_function" "function_declaration" "method_definition" "function" "generator_function" "generator_function_declaration")) + ("function" ("primary_expression")) + ("function_declaration" ("declaration")) + ("generator_function" ("primary_expression")) + ("generator_function_declaration" ("declaration")) + ("glimmer_closing_tag" ("glimmer_template")) + ("glimmer_opening_tag" ("glimmer_template")) + ("glimmer_template" ("expression" "class_body")) + ("hash_bang_line" ("program")) + ("identifier" ("arrow_function" "class_declaration" "jsx_self_closing_element" "jsx_namespace_name" "namespace_import" "jsx_opening_element" "import_clause" "class" "function_declaration" "member_expression" "namespace_export" "pattern" "decorator" "for_in_statement" "catch_clause" "generator_function_declaration" "generator_function" "assignment_expression" "export_specifier" "function" "variable_declarator" "primary_expression" "jsx_closing_element" "rest_pattern" "augmented_assignment_expression" "import_specifier")) + ("if_statement" ("statement")) + ("import" ("primary_expression")) + ("import_clause" ("import_statement")) + ("import_specifier" ("named_imports")) + ("import_statement" ("statement")) + ("jsx_attribute" ("jsx_self_closing_element" "jsx_opening_element")) + ("jsx_closing_element" ("jsx_element")) + ("jsx_element" ("expression" "jsx_element" "jsx_attribute")) + ("jsx_expression" ("jsx_self_closing_element" "jsx_element" "jsx_attribute" "jsx_opening_element")) + ("jsx_namespace_name" ("jsx_closing_element" "jsx_self_closing_element" "jsx_attribute" "jsx_opening_element")) + ("jsx_opening_element" ("jsx_element")) + ("jsx_self_closing_element" ("expression" "jsx_element" "jsx_attribute")) + ("jsx_text" ("jsx_element")) + ("labeled_statement" ("statement")) + ("lexical_declaration" ("for_statement" "declaration")) + ("member_expression" ("jsx_self_closing_element" "primary_expression" "assignment_expression" "member_expression" "jsx_closing_element" "rest_pattern" "augmented_assignment_expression" "pattern" "decorator" "for_in_statement" "jsx_opening_element")) + ("meta_property" ("primary_expression")) + ("method_definition" ("object" "class_body")) + ("named_imports" ("import_clause")) + ("namespace_export" ("export_statement")) + ("namespace_import" ("import_clause")) + ("new_expression" ("expression" "new_expression")) + ("null" ("primary_expression")) + ("number" ("field_definition" "method_definition" "primary_expression" "pair_pattern" "pair")) + ("object" ("primary_expression")) + ("object_assignment_pattern" ("object_pattern")) + ("object_pattern" ("object_assignment_pattern" "variable_declarator" "assignment_expression" "rest_pattern" "pattern" "for_in_statement" "catch_clause")) + ("optional_chain" ("subscript_expression" "call_expression" "member_expression")) + ("pair" ("object")) + ("pair_pattern" ("object_pattern")) + ("parenthesized_expression" ("primary_expression" "assignment_expression" "do_statement" "if_statement" "while_statement" "with_statement" "switch_statement" "augmented_assignment_expression" "for_in_statement")) + ("pattern" ("assignment_pattern" "formal_parameters" "array_pattern" "pair_pattern")) + ("primary_expression" ("expression" "new_expression")) + ("private_property_identifier" ("field_definition" "method_definition" "member_expression" "pair_pattern" "pair" "binary_expression")) + ("property_identifier" ("field_definition" "method_definition" "member_expression" "pair_pattern" "pair" "jsx_attribute")) + ("regex" ("primary_expression")) + ("regex_flags" ("regex")) + ("regex_pattern" ("regex")) + ("rest_pattern" ("pattern" "object_pattern")) + ("return_statement" ("statement")) + ("sequence_expression" ("parenthesized_expression" "for_statement" "throw_statement" "expression_statement" "return_statement" "jsx_expression" "template_substitution" "for_in_statement" "switch_case" "subscript_expression" "sequence_expression")) + ("shorthand_property_identifier" ("object")) + ("shorthand_property_identifier_pattern" ("object_assignment_pattern" "object_pattern")) + ("spread_element" ("array" "jsx_expression" "arguments" "object")) + ("statement" ("for_statement" "statement_block" "do_statement" "if_statement" "while_statement" "with_statement" "labeled_statement" "program" "for_in_statement" "switch_case" "switch_default" "else_clause")) + ("statement_block" ("arrow_function" "method_definition" "statement" "class_static_block" "generator_function_declaration" "function" "finally_clause" "catch_clause" "generator_function" "try_statement" "function_declaration")) + ("statement_identifier" ("continue_statement" "break_statement" "labeled_statement")) + ("string" ("field_definition" "export_statement" "import_statement" "method_definition" "primary_expression" "export_specifier" "pair_pattern" "namespace_export" "pair" "jsx_attribute" "import_specifier")) + ("string_fragment" ("string")) + ("subscript_expression" ("primary_expression" "assignment_expression" "rest_pattern" "augmented_assignment_expression" "pattern" "for_in_statement")) + ("super" ("primary_expression")) + ("switch_body" ("switch_statement")) + ("switch_case" ("switch_body")) + ("switch_default" ("switch_body")) + ("switch_statement" ("statement")) + ("template_string" ("primary_expression" "call_expression")) + ("template_substitution" ("template_string")) + ("ternary_expression" ("expression")) + ("this" ("primary_expression")) + ("throw_statement" ("statement")) + ("true" ("primary_expression")) + ("try_statement" ("statement")) + ("unary_expression" ("expression")) + ("undefined" ("primary_expression" "assignment_expression" "rest_pattern" "pattern" "for_in_statement")) + ("update_expression" ("expression")) + ("variable_declaration" ("for_statement" "declaration")) + ("variable_declarator" ("lexical_declaration" "variable_declaration")) + ("while_statement" ("statement")) + ("with_statement" ("statement")) + ("yield_expression" ("expression")) + ) +) ;; END Inverse production rules for javascript ;; START All node types in javascript -(defconst combobulate-rules-javascript-types - '("arguments" "array" "array_pattern" "arrow_function" "assignment_expression" "assignment_pattern" "augmented_assignment_expression" "await_expression" "binary_expression" "break_statement" "call_expression" "catch_clause" "class" "class_body" "class_declaration" "class_heritage" "class_static_block" "comment" "computed_property_name" "continue_statement" "debugger_statement" "declaration" "decorator" "do_statement" "else_clause" "empty_statement" "escape_sequence" "export_clause" "export_specifier" "export_statement" "expression" "expression_statement" "false" "field_definition" "finally_clause" "for_in_statement" "for_statement" "formal_parameters" "function" "function_declaration" "generator_function" "generator_function_declaration" "glimmer_closing_tag" "glimmer_opening_tag" "glimmer_template" "hash_bang_line" "identifier" "if_statement" "import" "import_clause" "import_specifier" "import_statement" "jsx_attribute" "jsx_closing_element" "jsx_element" "jsx_expression" "jsx_namespace_name" "jsx_opening_element" "jsx_self_closing_element" "jsx_text" "labeled_statement" "lexical_declaration" "member_expression" "meta_property" "method_definition" "named_imports" "namespace_export" "namespace_import" "new_expression" "null" "number" "object" "object_assignment_pattern" "object_pattern" "optional_chain" "pair" "pair_pattern" "parenthesized_expression" "pattern" "primary_expression" "private_property_identifier" "program" "property_identifier" "regex" "regex_flags" "regex_pattern" "rest_pattern" "return_statement" "sequence_expression" "shorthand_property_identifier" "shorthand_property_identifier_pattern" "spread_element" "statement" "statement_block" "statement_identifier" "string" "string_fragment" "subscript_expression" "super" "switch_body" "switch_case" "switch_default" "switch_statement" "template_string" "template_substitution" "ternary_expression" "this" "throw_statement" "true" "try_statement" "unary_expression" "undefined" "update_expression" "variable_declaration" "variable_declarator" "while_statement" "with_statement" "yield_expression") - ) +(defconst combobulate-rules-javascript-types + '("arguments" "array" "array_pattern" "arrow_function" "assignment_expression" "assignment_pattern" "augmented_assignment_expression" "await_expression" "binary_expression" "break_statement" "call_expression" "catch_clause" "class" "class_body" "class_declaration" "class_heritage" "class_static_block" "comment" "computed_property_name" "continue_statement" "debugger_statement" "declaration" "decorator" "do_statement" "else_clause" "empty_statement" "escape_sequence" "export_clause" "export_specifier" "export_statement" "expression" "expression_statement" "false" "field_definition" "finally_clause" "for_in_statement" "for_statement" "formal_parameters" "function" "function_declaration" "generator_function" "generator_function_declaration" "glimmer_closing_tag" "glimmer_opening_tag" "glimmer_template" "hash_bang_line" "identifier" "if_statement" "import" "import_clause" "import_specifier" "import_statement" "jsx_attribute" "jsx_closing_element" "jsx_element" "jsx_expression" "jsx_namespace_name" "jsx_opening_element" "jsx_self_closing_element" "jsx_text" "labeled_statement" "lexical_declaration" "member_expression" "meta_property" "method_definition" "named_imports" "namespace_export" "namespace_import" "new_expression" "null" "number" "object" "object_assignment_pattern" "object_pattern" "optional_chain" "pair" "pair_pattern" "parenthesized_expression" "pattern" "primary_expression" "private_property_identifier" "program" "property_identifier" "regex" "regex_flags" "regex_pattern" "rest_pattern" "return_statement" "sequence_expression" "shorthand_property_identifier" "shorthand_property_identifier_pattern" "spread_element" "statement" "statement_block" "statement_identifier" "string" "string_fragment" "subscript_expression" "super" "switch_body" "switch_case" "switch_default" "switch_statement" "template_string" "template_substitution" "ternary_expression" "this" "throw_statement" "true" "try_statement" "unary_expression" "undefined" "update_expression" "variable_declaration" "variable_declarator" "while_statement" "with_statement" "yield_expression") +) ;; END All node types in javascript +;; START All supertypes in javascript +(defconst combobulate-rules-javascript-supertypes + '("declaration" "expression" "pattern" "primary_expression" "statement") +) +;; END All supertypes in javascript ;; START Production rules for jsx -(defconst combobulate-rules-jsx - '(("declaration" (:*unnamed* ("function_declaration" "class_declaration" "variable_declaration" "lexical_declaration" "generator_function_declaration"))) - ("expression" (:*unnamed* ("primary_expression" "jsx_element" "jsx_self_closing_element" "unary_expression" "yield_expression" "update_expression" "await_expression" "glimmer_template" "ternary_expression" "binary_expression" "augmented_assignment_expression" "new_expression" "assignment_expression"))) - ("pattern" (:*unnamed* ("member_expression" "identifier" "undefined" "rest_pattern" "object_pattern" "array_pattern" "subscript_expression"))) - ("primary_expression" (:*unnamed* ("member_expression" "array" "identifier" "string" "undefined" "parenthesized_expression" "arrow_function" "generator_function" "template_string" "call_expression" "class" "function" "subscript_expression" "false" "number" "regex" "super" "object" "true" "this" "null" "meta_property" "import"))) - ("statement" (:*unnamed* ("continue_statement" "for_statement" "with_statement" "export_statement" "import_statement" "if_statement" "do_statement" "declaration" "return_statement" "throw_statement" "for_in_statement" "while_statement" "empty_statement" "switch_statement" "expression_statement" "break_statement" "debugger_statement" "try_statement" "statement_block" "labeled_statement"))) - ("arguments" (:*unnamed* ("spread_element" "expression"))) - ("array" (:*unnamed* ("spread_element" "expression"))) - ("array_pattern" (:*unnamed* ("pattern" "assignment_pattern"))) - ("arrow_function" (:body ("statement_block" "expression") :parameter ("identifier") :parameters ("formal_parameters"))) - ("assignment_expression" (:left ("member_expression" "identifier" "undefined" "object_pattern" "parenthesized_expression" "array_pattern" "subscript_expression") :right ("expression"))) - ("assignment_pattern" (:left ("pattern") :right ("expression"))) - ("augmented_assignment_expression" (:left ("member_expression" "parenthesized_expression" "identifier" "subscript_expression") :operator nil :right ("expression"))) - ("await_expression" (:*unnamed* ("expression"))) - ("binary_expression" (:left ("private_property_identifier" "expression") :operator nil :right ("expression"))) - ("break_statement" (:label ("statement_identifier"))) - ("call_expression" (:arguments ("arguments" "template_string") :function ("expression") :optional_chain ("optional_chain"))) - ("catch_clause" (:body ("statement_block") :parameter ("object_pattern" "identifier" "array_pattern"))) - ("class" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("identifier"))) - ("class_body" (:member ("field_definition" "method_definition" "class_static_block") :template ("glimmer_template"))) - ("class_declaration" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("identifier"))) - ("class_heritage" (:*unnamed* ("expression"))) - ("class_static_block" (:body ("statement_block"))) - ("computed_property_name" (:*unnamed* ("expression"))) - ("continue_statement" (:label ("statement_identifier"))) - ("decorator" (:*unnamed* ("member_expression" "identifier" "call_expression"))) - ("do_statement" (:body ("statement") :condition ("parenthesized_expression"))) - ("else_clause" (:*unnamed* ("statement"))) - ("export_clause" (:*unnamed* ("export_specifier"))) - ("export_specifier" (:alias ("string" "identifier") :name ("string" "identifier"))) - ("export_statement" (:*unnamed* ("export_clause" "namespace_export") :declaration ("declaration") :decorator ("decorator") :source ("string") :value ("expression"))) - ("expression_statement" (:*unnamed* ("sequence_expression" "expression"))) - ("field_definition" (:decorator ("decorator") :property ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :value ("expression"))) - ("finally_clause" (:body ("statement_block"))) - ("for_in_statement" (:body ("statement") :kind nil :left ("member_expression" "identifier" "undefined" "object_pattern" "parenthesized_expression" "array_pattern" "subscript_expression") :operator nil :right ("sequence_expression" "expression") :value ("expression"))) - ("for_statement" (:body ("statement") :condition ("expression_statement" "empty_statement") :increment ("sequence_expression" "expression") :initializer ("lexical_declaration" "expression_statement" "variable_declaration" "empty_statement"))) - ("formal_parameters" (:*unnamed* ("pattern" "assignment_pattern"))) - ("function" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) - ("function_declaration" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) - ("generator_function" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) - ("generator_function_declaration" (:body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) - ("glimmer_template" (:close_tag ("glimmer_closing_tag") :open_tag ("glimmer_opening_tag"))) - ("if_statement" (:alternative ("else_clause") :condition ("parenthesized_expression") :consequence ("statement"))) - ("import_clause" (:*unnamed* ("namespace_import" "identifier" "named_imports"))) - ("import_specifier" (:alias ("identifier") :name ("string" "identifier"))) - ("import_statement" (:*unnamed* ("import_clause") :source ("string"))) - ("jsx_attribute" (:*unnamed* ("jsx_expression" "jsx_namespace_name" "jsx_element" "string" "jsx_self_closing_element" "property_identifier"))) - ("jsx_closing_element" (:name ("member_expression" "jsx_namespace_name" "identifier"))) - ("jsx_element" (:*unnamed* ("jsx_expression" "jsx_element" "jsx_text" "jsx_self_closing_element") :close_tag ("jsx_closing_element") :open_tag ("jsx_opening_element"))) - ("jsx_expression" (:*unnamed* ("sequence_expression" "spread_element" "expression"))) - ("jsx_namespace_name" (:*unnamed* ("identifier"))) - ("jsx_opening_element" (:attribute ("jsx_expression" "jsx_attribute") :name ("member_expression" "jsx_namespace_name" "identifier"))) - ("jsx_self_closing_element" (:attribute ("jsx_expression" "jsx_attribute") :name ("member_expression" "jsx_namespace_name" "identifier"))) - ("labeled_statement" (:body ("statement") :label ("statement_identifier"))) - ("lexical_declaration" (:*unnamed* ("variable_declarator") :kind nil)) - ("member_expression" (:*unnamed* ("member_expression" "identifier" "property_identifier") :object ("expression") :optional_chain ("optional_chain") :property ("private_property_identifier" "property_identifier"))) - ("method_definition" (:body ("statement_block") :decorator ("decorator") :name ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :parameters ("formal_parameters"))) - ("named_imports" (:*unnamed* ("import_specifier"))) - ("namespace_export" (:*unnamed* ("string" "identifier"))) - ("namespace_import" (:*unnamed* ("identifier"))) - ("new_expression" (:arguments ("arguments") :constructor ("primary_expression" "new_expression"))) - ("object" (:*unnamed* ("method_definition" "pair" "spread_element" "shorthand_property_identifier"))) - ("object_assignment_pattern" (:left ("shorthand_property_identifier_pattern" "object_pattern" "array_pattern") :right ("expression"))) - ("object_pattern" (:*unnamed* ("shorthand_property_identifier_pattern" "object_assignment_pattern" "rest_pattern" "pair_pattern"))) - ("pair" (:key ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :value ("expression"))) - ("pair_pattern" (:key ("string" "computed_property_name" "number" "private_property_identifier" "property_identifier") :value ("pattern" "assignment_pattern"))) - ("parenthesized_expression" (:*unnamed* ("sequence_expression" "expression"))) - ("program" (:*unnamed* ("hash_bang_line" "statement"))) - ("regex" (:flags ("regex_flags") :pattern ("regex_pattern"))) - ("rest_pattern" (:*unnamed* ("member_expression" "identifier" "undefined" "object_pattern" "array_pattern" "subscript_expression"))) - ("return_statement" (:*unnamed* ("sequence_expression" "expression"))) - ("sequence_expression" (:left ("expression") :right ("sequence_expression" "expression"))) - ("spread_element" (:*unnamed* ("expression"))) - ("statement_block" (:*unnamed* ("statement"))) - ("string" (:*unnamed* ("string_fragment" "escape_sequence"))) - ("subscript_expression" (:index ("sequence_expression" "expression") :object ("expression") :optional_chain ("optional_chain"))) - ("switch_body" (:*unnamed* ("switch_case" "switch_default"))) - ("switch_case" (:body ("statement") :value ("sequence_expression" "expression"))) - ("switch_default" (:body ("statement"))) - ("switch_statement" (:body ("switch_body") :value ("parenthesized_expression"))) - ("template_string" (:*unnamed* ("template_substitution" "escape_sequence"))) - ("template_substitution" (:*unnamed* ("sequence_expression" "expression"))) - ("ternary_expression" (:alternative ("expression") :condition ("expression") :consequence ("expression"))) - ("throw_statement" (:*unnamed* ("sequence_expression" "expression"))) - ("try_statement" (:body ("statement_block") :finalizer ("finally_clause") :handler ("catch_clause"))) - ("unary_expression" (:argument ("expression") :operator nil)) - ("update_expression" (:argument ("expression") :operator nil)) - ("variable_declaration" (:*unnamed* ("variable_declarator"))) - ("variable_declarator" (:name ("object_pattern" "identifier" "array_pattern") :value ("expression"))) - ("while_statement" (:body ("statement") :condition ("parenthesized_expression"))) - ("with_statement" (:body ("statement") :object ("parenthesized_expression"))) - ("yield_expression" (:*unnamed* ("expression"))) - ("comment" (:*unnamed* nil)) - ("escape_sequence" (:*unnamed* nil)) - ("false" (:*unnamed* nil)) - ("hash_bang_line" (:*unnamed* nil)) - ("identifier" (:*unnamed* nil)) - ("null" (:*unnamed* nil)) - ("number" (:*unnamed* nil)) - ("optional_chain" (:*unnamed* nil)) - ("private_property_identifier" (:*unnamed* nil)) - ("property_identifier" (:*unnamed* nil)) - ("regex_flags" (:*unnamed* nil)) - ("regex_pattern" (:*unnamed* nil)) - ("shorthand_property_identifier" (:*unnamed* nil)) - ("shorthand_property_identifier_pattern" (:*unnamed* nil)) - ("statement_identifier" (:*unnamed* nil)) - ("string_fragment" (:*unnamed* nil)) - ("super" (:*unnamed* nil)) - ("this" (:*unnamed* nil)) - ("true" (:*unnamed* nil)) - ("undefined" (:*unnamed* nil)) - )) +(defconst combobulate-rules-jsx + '(("declaration" (:*unnamed* ("class_declaration" "lexical_declaration" "variable_declaration" "generator_function_declaration" "function_declaration"))) + ("expression" (:*unnamed* ("new_expression" "jsx_self_closing_element" "update_expression" "ternary_expression" "primary_expression" "jsx_element" "assignment_expression" "unary_expression" "glimmer_template" "augmented_assignment_expression" "binary_expression" "yield_expression" "await_expression"))) + ("pattern" (:*unnamed* ("identifier" "rest_pattern" "member_expression" "undefined" "subscript_expression" "array_pattern" "object_pattern"))) + ("primary_expression" (:*unnamed* ("arrow_function" "false" "object" "template_string" "undefined" "meta_property" "function" "number" "class" "subscript_expression" "parenthesized_expression" "call_expression" "import" "true" "string" "member_expression" "identifier" "null" "regex" "array" "super" "this" "generator_function"))) + ("statement" (:*unnamed* ("break_statement" "import_statement" "expression_statement" "do_statement" "with_statement" "if_statement" "continue_statement" "switch_statement" "try_statement" "declaration" "empty_statement" "for_statement" "debugger_statement" "export_statement" "statement_block" "throw_statement" "while_statement" "return_statement" "labeled_statement" "for_in_statement"))) + ("arguments" (:*unnamed* ("expression" "spread_element"))) + ("array" (:*unnamed* ("expression" "spread_element"))) + ("array_pattern" (:*unnamed* ("assignment_pattern" "pattern"))) + ("arrow_function" (:*unnamed* nil :body ("expression" "statement_block") :parameter ("identifier") :parameters ("formal_parameters"))) + ("assignment_expression" (:*unnamed* nil :left ("parenthesized_expression" "identifier" "member_expression" "undefined" "subscript_expression" "array_pattern" "object_pattern") :right ("expression"))) + ("assignment_pattern" (:*unnamed* nil :left ("pattern") :right ("expression"))) + ("augmented_assignment_expression" (:*unnamed* nil :left ("identifier" "subscript_expression" "parenthesized_expression" "member_expression") :operator nil :right ("expression"))) + ("await_expression" (:*unnamed* ("expression"))) + ("binary_expression" (:*unnamed* nil :left ("expression" "private_property_identifier") :operator nil :right ("expression"))) + ("break_statement" (:*unnamed* nil :label ("statement_identifier"))) + ("call_expression" (:*unnamed* nil :arguments ("arguments" "template_string") :function ("expression") :optional_chain ("optional_chain"))) + ("catch_clause" (:*unnamed* nil :body ("statement_block") :parameter ("identifier" "array_pattern" "object_pattern"))) + ("class" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("identifier"))) + ("class_body" (:*unnamed* nil :member ("field_definition" "class_static_block" "method_definition") :template ("glimmer_template"))) + ("class_declaration" (:*unnamed* ("class_heritage") :body ("class_body") :decorator ("decorator") :name ("identifier"))) + ("class_heritage" (:*unnamed* ("expression"))) + ("class_static_block" (:*unnamed* nil :body ("statement_block"))) + ("computed_property_name" (:*unnamed* ("expression"))) + ("continue_statement" (:*unnamed* nil :label ("statement_identifier"))) + ("debugger_statement" (:*unnamed* nil)) + ("decorator" (:*unnamed* ("identifier" "call_expression" "member_expression"))) + ("do_statement" (:*unnamed* nil :body ("statement") :condition ("parenthesized_expression"))) + ("else_clause" (:*unnamed* ("statement"))) + ("empty_statement" (:*unnamed* nil)) + ("export_clause" (:*unnamed* ("export_specifier"))) + ("export_specifier" (:*unnamed* nil :alias ("identifier" "string") :name ("identifier" "string"))) + ("export_statement" (:*unnamed* ("namespace_export" "export_clause") :declaration ("declaration") :decorator ("decorator") :source ("string") :value ("expression"))) + ("expression_statement" (:*unnamed* ("expression" "sequence_expression"))) + ("field_definition" (:*unnamed* nil :decorator ("decorator") :property ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :value ("expression"))) + ("finally_clause" (:*unnamed* nil :body ("statement_block"))) + ("for_in_statement" (:*unnamed* nil :body ("statement") :kind nil :left ("parenthesized_expression" "identifier" "member_expression" "undefined" "subscript_expression" "array_pattern" "object_pattern") :operator nil :right ("expression" "sequence_expression") :value ("expression"))) + ("for_statement" (:*unnamed* nil :body ("statement") :condition ("empty_statement" "expression_statement") :increment ("expression" "sequence_expression") :initializer ("empty_statement" "lexical_declaration" "expression_statement" "variable_declaration"))) + ("formal_parameters" (:*unnamed* ("assignment_pattern" "pattern"))) + ("function" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) + ("function_declaration" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) + ("generator_function" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) + ("generator_function_declaration" (:*unnamed* nil :body ("statement_block") :name ("identifier") :parameters ("formal_parameters"))) + ("glimmer_closing_tag" (:*unnamed* nil)) + ("glimmer_opening_tag" (:*unnamed* nil)) + ("glimmer_template" (:*unnamed* nil :close_tag ("glimmer_closing_tag") :open_tag ("glimmer_opening_tag"))) + ("if_statement" (:*unnamed* nil :alternative ("else_clause") :condition ("parenthesized_expression") :consequence ("statement"))) + ("import" (:*unnamed* nil)) + ("import_clause" (:*unnamed* ("identifier" "named_imports" "namespace_import"))) + ("import_specifier" (:*unnamed* nil :alias ("identifier") :name ("identifier" "string"))) + ("import_statement" (:*unnamed* ("import_clause") :source ("string"))) + ("jsx_attribute" (:*unnamed* ("jsx_expression" "jsx_self_closing_element" "property_identifier" "jsx_namespace_name" "jsx_element" "string"))) + ("jsx_closing_element" (:*unnamed* nil :name ("identifier" "jsx_namespace_name" "member_expression"))) + ("jsx_element" (:*unnamed* ("jsx_self_closing_element" "jsx_text" "jsx_expression" "jsx_element") :close_tag ("jsx_closing_element") :open_tag ("jsx_opening_element"))) + ("jsx_expression" (:*unnamed* ("expression" "sequence_expression" "spread_element"))) + ("jsx_namespace_name" (:*unnamed* ("identifier"))) + ("jsx_opening_element" (:*unnamed* nil :attribute ("jsx_expression" "jsx_attribute") :name ("identifier" "jsx_namespace_name" "member_expression"))) + ("jsx_self_closing_element" (:*unnamed* nil :attribute ("jsx_expression" "jsx_attribute") :name ("identifier" "jsx_namespace_name" "member_expression"))) + ("jsx_text" (:*unnamed* nil)) + ("labeled_statement" (:*unnamed* nil :body ("statement") :label ("statement_identifier"))) + ("lexical_declaration" (:*unnamed* ("variable_declarator") :kind nil)) + ("member_expression" (:*unnamed* ("identifier" "property_identifier" "member_expression") :object ("expression") :optional_chain ("optional_chain") :property ("property_identifier" "private_property_identifier"))) + ("meta_property" (:*unnamed* nil)) + ("method_definition" (:*unnamed* nil :body ("statement_block") :decorator ("decorator") :name ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :parameters ("formal_parameters"))) + ("named_imports" (:*unnamed* ("import_specifier"))) + ("namespace_export" (:*unnamed* ("identifier" "string"))) + ("namespace_import" (:*unnamed* ("identifier"))) + ("new_expression" (:*unnamed* nil :arguments ("arguments") :constructor ("new_expression" "primary_expression"))) + ("object" (:*unnamed* ("pair" "method_definition" "shorthand_property_identifier" "spread_element"))) + ("object_assignment_pattern" (:*unnamed* nil :left ("shorthand_property_identifier_pattern" "array_pattern" "object_pattern") :right ("expression"))) + ("object_pattern" (:*unnamed* ("object_assignment_pattern" "shorthand_property_identifier_pattern" "rest_pattern" "pair_pattern"))) + ("pair" (:*unnamed* nil :key ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :value ("expression"))) + ("pair_pattern" (:*unnamed* nil :key ("property_identifier" "computed_property_name" "string" "number" "private_property_identifier") :value ("assignment_pattern" "pattern"))) + ("parenthesized_expression" (:*unnamed* ("expression" "sequence_expression"))) + ("program" (:*unnamed* ("statement" "hash_bang_line"))) + ("regex" (:*unnamed* nil :flags ("regex_flags") :pattern ("regex_pattern"))) + ("rest_pattern" (:*unnamed* ("identifier" "member_expression" "undefined" "subscript_expression" "array_pattern" "object_pattern"))) + ("return_statement" (:*unnamed* ("expression" "sequence_expression"))) + ("sequence_expression" (:*unnamed* nil :left ("expression") :right ("expression" "sequence_expression"))) + ("spread_element" (:*unnamed* ("expression"))) + ("statement_block" (:*unnamed* ("statement"))) + ("string" (:*unnamed* ("string_fragment" "escape_sequence"))) + ("subscript_expression" (:*unnamed* nil :index ("expression" "sequence_expression") :object ("expression") :optional_chain ("optional_chain"))) + ("switch_body" (:*unnamed* ("switch_case" "switch_default"))) + ("switch_case" (:*unnamed* nil :body ("statement") :value ("expression" "sequence_expression"))) + ("switch_default" (:*unnamed* nil :body ("statement"))) + ("switch_statement" (:*unnamed* nil :body ("switch_body") :value ("parenthesized_expression"))) + ("template_string" (:*unnamed* ("template_substitution" "escape_sequence"))) + ("template_substitution" (:*unnamed* ("expression" "sequence_expression"))) + ("ternary_expression" (:*unnamed* nil :alternative ("expression") :condition ("expression") :consequence ("expression"))) + ("throw_statement" (:*unnamed* ("expression" "sequence_expression"))) + ("try_statement" (:*unnamed* nil :body ("statement_block") :finalizer ("finally_clause") :handler ("catch_clause"))) + ("unary_expression" (:*unnamed* nil :argument ("expression") :operator nil)) + ("update_expression" (:*unnamed* nil :argument ("expression") :operator nil)) + ("variable_declaration" (:*unnamed* ("variable_declarator"))) + ("variable_declarator" (:*unnamed* nil :name ("identifier" "array_pattern" "object_pattern") :value ("expression"))) + ("while_statement" (:*unnamed* nil :body ("statement") :condition ("parenthesized_expression"))) + ("with_statement" (:*unnamed* nil :body ("statement") :object ("parenthesized_expression"))) + ("yield_expression" (:*unnamed* ("expression"))) + ("comment" (:*unnamed* nil)) + ("escape_sequence" (:*unnamed* nil)) + ("false" (:*unnamed* nil)) + ("hash_bang_line" (:*unnamed* nil)) + ("identifier" (:*unnamed* nil)) + ("null" (:*unnamed* nil)) + ("number" (:*unnamed* nil)) + ("optional_chain" (:*unnamed* nil)) + ("private_property_identifier" (:*unnamed* nil)) + ("property_identifier" (:*unnamed* nil)) + ("regex_flags" (:*unnamed* nil)) + ("regex_pattern" (:*unnamed* nil)) + ("shorthand_property_identifier" (:*unnamed* nil)) + ("shorthand_property_identifier_pattern" (:*unnamed* nil)) + ("statement_identifier" (:*unnamed* nil)) + ("string_fragment" (:*unnamed* nil)) + ("super" (:*unnamed* nil)) + ("this" (:*unnamed* nil)) + ("true" (:*unnamed* nil)) + ("undefined" (:*unnamed* nil)) +)) ;; END Production rules for jsx ;; START Inverse production rules for jsx -(defconst combobulate-rules-jsx-inverse - '(("arguments" ("new_expression" "call_expression")) - ("array" ("primary_expression")) - ("array_pattern" ("for_in_statement" "pattern" "assignment_expression" "rest_pattern" "object_assignment_pattern" "variable_declarator" "catch_clause")) - ("arrow_function" ("primary_expression")) - ("assignment_expression" ("expression")) - ("assignment_pattern" ("formal_parameters" "pair_pattern" "array_pattern")) - ("augmented_assignment_expression" ("expression")) - ("await_expression" ("expression")) - ("binary_expression" ("expression")) - ("break_statement" ("statement")) - ("call_expression" ("primary_expression" "decorator")) - ("catch_clause" ("try_statement")) - ("class" ("primary_expression")) - ("class_body" ("class_declaration" "class")) - ("class_declaration" ("declaration")) - ("class_heritage" ("class_declaration" "class")) - ("class_static_block" ("class_body")) - ("computed_property_name" ("field_definition" "pair_pattern" "pair" "method_definition")) - ("continue_statement" ("statement")) - ("debugger_statement" ("statement")) - ("declaration" ("export_statement" "statement")) - ("decorator" ("method_definition" "export_statement" "class_declaration" "field_definition" "class")) - ("do_statement" ("statement")) - ("else_clause" ("if_statement")) - ("empty_statement" ("for_statement" "statement")) - ("escape_sequence" ("template_string" "string")) - ("export_clause" ("export_statement")) - ("export_specifier" ("export_clause")) - ("export_statement" ("statement")) - ("expression" ("jsx_expression" "member_expression" "sequence_expression" "parenthesized_expression" "class_heritage" "spread_element" "binary_expression" "return_statement" "computed_property_name" "field_definition" "switch_case" "await_expression" "ternary_expression" "pair" "object_assignment_pattern" "variable_declarator" "template_substitution" "array" "for_statement" "yield_expression" "export_statement" "arrow_function" "call_expression" "augmented_assignment_expression" "for_in_statement" "throw_statement" "subscript_expression" "assignment_expression" "arguments" "expression_statement" "update_expression" "assignment_pattern" "unary_expression")) - ("expression_statement" ("for_statement" "statement")) - ("false" ("primary_expression")) - ("field_definition" ("class_body")) - ("finally_clause" ("try_statement")) - ("for_in_statement" ("statement")) - ("for_statement" ("statement")) - ("formal_parameters" ("method_definition" "arrow_function" "generator_function_declaration" "generator_function" "function_declaration" "function")) - ("function" ("primary_expression")) - ("function_declaration" ("declaration")) - ("generator_function" ("primary_expression")) - ("generator_function_declaration" ("declaration")) - ("glimmer_closing_tag" ("glimmer_template")) - ("glimmer_opening_tag" ("glimmer_template")) - ("glimmer_template" ("expression" "class_body")) - ("hash_bang_line" ("program")) - ("identifier" ("member_expression" "jsx_closing_element" "class_declaration" "rest_pattern" "class" "namespace_import" "export_specifier" "jsx_self_closing_element" "generator_function_declaration" "function_declaration" "variable_declarator" "import_clause" "catch_clause" "arrow_function" "generator_function" "namespace_export" "augmented_assignment_expression" "import_specifier" "for_in_statement" "function" "assignment_expression" "primary_expression" "jsx_namespace_name" "pattern" "decorator" "jsx_opening_element")) - ("if_statement" ("statement")) - ("import" ("primary_expression")) - ("import_clause" ("import_statement")) - ("import_specifier" ("named_imports")) - ("import_statement" ("statement")) - ("jsx_attribute" ("jsx_self_closing_element" "jsx_opening_element")) - ("jsx_closing_element" ("jsx_element")) - ("jsx_element" ("jsx_attribute" "jsx_element" "expression")) - ("jsx_expression" ("jsx_self_closing_element" "jsx_attribute" "jsx_element" "jsx_opening_element")) - ("jsx_namespace_name" ("jsx_self_closing_element" "jsx_attribute" "jsx_closing_element" "jsx_opening_element")) - ("jsx_opening_element" ("jsx_element")) - ("jsx_self_closing_element" ("jsx_attribute" "jsx_element" "expression")) - ("jsx_text" ("jsx_element")) - ("labeled_statement" ("statement")) - ("lexical_declaration" ("for_statement" "declaration")) - ("member_expression" ("member_expression" "primary_expression" "pattern" "jsx_self_closing_element" "jsx_closing_element" "decorator" "rest_pattern" "augmented_assignment_expression" "jsx_opening_element" "for_in_statement" "assignment_expression")) - ("meta_property" ("primary_expression")) - ("method_definition" ("object" "class_body")) - ("named_imports" ("import_clause")) - ("namespace_export" ("export_statement")) - ("namespace_import" ("import_clause")) - ("new_expression" ("new_expression" "expression")) - ("null" ("primary_expression")) - ("number" ("primary_expression" "method_definition" "pair" "pair_pattern" "field_definition")) - ("object" ("primary_expression")) - ("object_assignment_pattern" ("object_pattern")) - ("object_pattern" ("for_in_statement" "pattern" "assignment_expression" "rest_pattern" "object_assignment_pattern" "variable_declarator" "catch_clause")) - ("optional_chain" ("member_expression" "call_expression" "subscript_expression")) - ("pair" ("object")) - ("pair_pattern" ("object_pattern")) - ("parenthesized_expression" ("primary_expression" "while_statement" "switch_statement" "with_statement" "if_statement" "do_statement" "augmented_assignment_expression" "for_in_statement" "assignment_expression")) - ("pattern" ("formal_parameters" "assignment_pattern" "pair_pattern" "array_pattern")) - ("primary_expression" ("new_expression" "expression")) - ("private_property_identifier" ("member_expression" "method_definition" "pair" "binary_expression" "pair_pattern" "field_definition")) - ("property_identifier" ("member_expression" "jsx_attribute" "method_definition" "pair" "pair_pattern" "field_definition")) - ("regex" ("primary_expression")) - ("regex_flags" ("regex")) - ("regex_pattern" ("regex")) - ("rest_pattern" ("pattern" "object_pattern")) - ("return_statement" ("statement")) - ("sequence_expression" ("jsx_expression" "sequence_expression" "parenthesized_expression" "for_statement" "throw_statement" "expression_statement" "return_statement" "switch_case" "for_in_statement" "template_substitution" "subscript_expression")) - ("shorthand_property_identifier" ("object")) - ("shorthand_property_identifier_pattern" ("object_assignment_pattern" "object_pattern")) - ("spread_element" ("array" "arguments" "jsx_expression" "object")) - ("statement" ("switch_default" "while_statement" "for_statement" "statement_block" "with_statement" "if_statement" "do_statement" "else_clause" "labeled_statement" "program" "switch_case" "for_in_statement")) - ("statement_block" ("finally_clause" "method_definition" "statement" "arrow_function" "generator_function" "generator_function_declaration" "try_statement" "function_declaration" "class_static_block" "function" "catch_clause")) - ("statement_identifier" ("labeled_statement" "continue_statement" "break_statement")) - ("string" ("primary_expression" "jsx_attribute" "export_specifier" "method_definition" "export_statement" "import_statement" "pair" "namespace_export" "pair_pattern" "import_specifier" "field_definition")) - ("string_fragment" ("string")) - ("subscript_expression" ("primary_expression" "pattern" "rest_pattern" "augmented_assignment_expression" "for_in_statement" "assignment_expression")) - ("super" ("primary_expression")) - ("switch_body" ("switch_statement")) - ("switch_case" ("switch_body")) - ("switch_default" ("switch_body")) - ("switch_statement" ("statement")) - ("template_string" ("primary_expression" "call_expression")) - ("template_substitution" ("template_string")) - ("ternary_expression" ("expression")) - ("this" ("primary_expression")) - ("throw_statement" ("statement")) - ("true" ("primary_expression")) - ("try_statement" ("statement")) - ("unary_expression" ("expression")) - ("undefined" ("primary_expression" "pattern" "rest_pattern" "for_in_statement" "assignment_expression")) - ("update_expression" ("expression")) - ("variable_declaration" ("for_statement" "declaration")) - ("variable_declarator" ("variable_declaration" "lexical_declaration")) - ("while_statement" ("statement")) - ("with_statement" ("statement")) - ("yield_expression" ("expression")) - ) - ) +(defconst combobulate-rules-jsx-inverse + '(("arguments" ("new_expression" "call_expression")) + ("array" ("primary_expression")) + ("array_pattern" ("object_assignment_pattern" "variable_declarator" "assignment_expression" "rest_pattern" "pattern" "for_in_statement" "catch_clause")) + ("arrow_function" ("primary_expression")) + ("assignment_expression" ("expression")) + ("assignment_pattern" ("pair_pattern" "formal_parameters" "array_pattern")) + ("augmented_assignment_expression" ("expression")) + ("await_expression" ("expression")) + ("binary_expression" ("expression")) + ("break_statement" ("statement")) + ("call_expression" ("primary_expression" "decorator")) + ("catch_clause" ("try_statement")) + ("class" ("primary_expression")) + ("class_body" ("class_declaration" "class")) + ("class_declaration" ("declaration")) + ("class_heritage" ("class_declaration" "class")) + ("class_static_block" ("class_body")) + ("computed_property_name" ("field_definition" "pair" "method_definition" "pair_pattern")) + ("continue_statement" ("statement")) + ("debugger_statement" ("statement")) + ("declaration" ("statement" "export_statement")) + ("decorator" ("field_definition" "class_declaration" "export_statement" "method_definition" "class")) + ("do_statement" ("statement")) + ("else_clause" ("if_statement")) + ("empty_statement" ("statement" "for_statement")) + ("escape_sequence" ("string" "template_string")) + ("export_clause" ("export_statement")) + ("export_specifier" ("export_clause")) + ("export_statement" ("statement")) + ("expression" ("arrow_function" "update_expression" "jsx_expression" "binary_expression" "computed_property_name" "parenthesized_expression" "call_expression" "for_statement" "spread_element" "member_expression" "return_statement" "for_in_statement" "yield_expression" "await_expression" "object_assignment_pattern" "ternary_expression" "expression_statement" "assignment_expression" "pair" "switch_case" "subscript_expression" "field_definition" "variable_declarator" "export_statement" "assignment_pattern" "throw_statement" "unary_expression" "class_heritage" "arguments" "augmented_assignment_expression" "template_substitution" "array" "sequence_expression")) + ("expression_statement" ("statement" "for_statement")) + ("false" ("primary_expression")) + ("field_definition" ("class_body")) + ("finally_clause" ("try_statement")) + ("for_in_statement" ("statement")) + ("for_statement" ("statement")) + ("formal_parameters" ("arrow_function" "function_declaration" "method_definition" "function" "generator_function" "generator_function_declaration")) + ("function" ("primary_expression")) + ("function_declaration" ("declaration")) + ("generator_function" ("primary_expression")) + ("generator_function_declaration" ("declaration")) + ("glimmer_closing_tag" ("glimmer_template")) + ("glimmer_opening_tag" ("glimmer_template")) + ("glimmer_template" ("expression" "class_body")) + ("hash_bang_line" ("program")) + ("identifier" ("arrow_function" "class_declaration" "jsx_self_closing_element" "jsx_namespace_name" "namespace_import" "jsx_opening_element" "import_clause" "class" "function_declaration" "member_expression" "namespace_export" "pattern" "decorator" "for_in_statement" "catch_clause" "generator_function_declaration" "generator_function" "assignment_expression" "export_specifier" "function" "variable_declarator" "primary_expression" "jsx_closing_element" "rest_pattern" "augmented_assignment_expression" "import_specifier")) + ("if_statement" ("statement")) + ("import" ("primary_expression")) + ("import_clause" ("import_statement")) + ("import_specifier" ("named_imports")) + ("import_statement" ("statement")) + ("jsx_attribute" ("jsx_self_closing_element" "jsx_opening_element")) + ("jsx_closing_element" ("jsx_element")) + ("jsx_element" ("expression" "jsx_element" "jsx_attribute")) + ("jsx_expression" ("jsx_self_closing_element" "jsx_element" "jsx_attribute" "jsx_opening_element")) + ("jsx_namespace_name" ("jsx_closing_element" "jsx_self_closing_element" "jsx_attribute" "jsx_opening_element")) + ("jsx_opening_element" ("jsx_element")) + ("jsx_self_closing_element" ("expression" "jsx_element" "jsx_attribute")) + ("jsx_text" ("jsx_element")) + ("labeled_statement" ("statement")) + ("lexical_declaration" ("for_statement" "declaration")) + ("member_expression" ("jsx_self_closing_element" "primary_expression" "assignment_expression" "member_expression" "jsx_closing_element" "rest_pattern" "augmented_assignment_expression" "pattern" "decorator" "for_in_statement" "jsx_opening_element")) + ("meta_property" ("primary_expression")) + ("method_definition" ("object" "class_body")) + ("named_imports" ("import_clause")) + ("namespace_export" ("export_statement")) + ("namespace_import" ("import_clause")) + ("new_expression" ("expression" "new_expression")) + ("null" ("primary_expression")) + ("number" ("field_definition" "method_definition" "primary_expression" "pair_pattern" "pair")) + ("object" ("primary_expression")) + ("object_assignment_pattern" ("object_pattern")) + ("object_pattern" ("object_assignment_pattern" "variable_declarator" "assignment_expression" "rest_pattern" "pattern" "for_in_statement" "catch_clause")) + ("optional_chain" ("subscript_expression" "call_expression" "member_expression")) + ("pair" ("object")) + ("pair_pattern" ("object_pattern")) + ("parenthesized_expression" ("primary_expression" "assignment_expression" "do_statement" "if_statement" "while_statement" "with_statement" "switch_statement" "augmented_assignment_expression" "for_in_statement")) + ("pattern" ("assignment_pattern" "formal_parameters" "array_pattern" "pair_pattern")) + ("primary_expression" ("expression" "new_expression")) + ("private_property_identifier" ("field_definition" "method_definition" "member_expression" "pair_pattern" "pair" "binary_expression")) + ("property_identifier" ("field_definition" "method_definition" "member_expression" "pair_pattern" "pair" "jsx_attribute")) + ("regex" ("primary_expression")) + ("regex_flags" ("regex")) + ("regex_pattern" ("regex")) + ("rest_pattern" ("pattern" "object_pattern")) + ("return_statement" ("statement")) + ("sequence_expression" ("parenthesized_expression" "for_statement" "throw_statement" "expression_statement" "return_statement" "jsx_expression" "template_substitution" "for_in_statement" "switch_case" "subscript_expression" "sequence_expression")) + ("shorthand_property_identifier" ("object")) + ("shorthand_property_identifier_pattern" ("object_assignment_pattern" "object_pattern")) + ("spread_element" ("array" "jsx_expression" "arguments" "object")) + ("statement" ("for_statement" "statement_block" "do_statement" "if_statement" "while_statement" "with_statement" "labeled_statement" "program" "for_in_statement" "switch_case" "switch_default" "else_clause")) + ("statement_block" ("arrow_function" "method_definition" "statement" "class_static_block" "generator_function_declaration" "function" "finally_clause" "catch_clause" "generator_function" "try_statement" "function_declaration")) + ("statement_identifier" ("continue_statement" "break_statement" "labeled_statement")) + ("string" ("field_definition" "export_statement" "import_statement" "method_definition" "primary_expression" "export_specifier" "pair_pattern" "namespace_export" "pair" "jsx_attribute" "import_specifier")) + ("string_fragment" ("string")) + ("subscript_expression" ("primary_expression" "assignment_expression" "rest_pattern" "augmented_assignment_expression" "pattern" "for_in_statement")) + ("super" ("primary_expression")) + ("switch_body" ("switch_statement")) + ("switch_case" ("switch_body")) + ("switch_default" ("switch_body")) + ("switch_statement" ("statement")) + ("template_string" ("primary_expression" "call_expression")) + ("template_substitution" ("template_string")) + ("ternary_expression" ("expression")) + ("this" ("primary_expression")) + ("throw_statement" ("statement")) + ("true" ("primary_expression")) + ("try_statement" ("statement")) + ("unary_expression" ("expression")) + ("undefined" ("primary_expression" "assignment_expression" "rest_pattern" "pattern" "for_in_statement")) + ("update_expression" ("expression")) + ("variable_declaration" ("for_statement" "declaration")) + ("variable_declarator" ("lexical_declaration" "variable_declaration")) + ("while_statement" ("statement")) + ("with_statement" ("statement")) + ("yield_expression" ("expression")) + ) +) ;; END Inverse production rules for jsx ;; START All node types in jsx -(defconst combobulate-rules-jsx-types - '("arguments" "array" "array_pattern" "arrow_function" "assignment_expression" "assignment_pattern" "augmented_assignment_expression" "await_expression" "binary_expression" "break_statement" "call_expression" "catch_clause" "class" "class_body" "class_declaration" "class_heritage" "class_static_block" "comment" "computed_property_name" "continue_statement" "debugger_statement" "declaration" "decorator" "do_statement" "else_clause" "empty_statement" "escape_sequence" "export_clause" "export_specifier" "export_statement" "expression" "expression_statement" "false" "field_definition" "finally_clause" "for_in_statement" "for_statement" "formal_parameters" "function" "function_declaration" "generator_function" "generator_function_declaration" "glimmer_closing_tag" "glimmer_opening_tag" "glimmer_template" "hash_bang_line" "identifier" "if_statement" "import" "import_clause" "import_specifier" "import_statement" "jsx_attribute" "jsx_closing_element" "jsx_element" "jsx_expression" "jsx_namespace_name" "jsx_opening_element" "jsx_self_closing_element" "jsx_text" "labeled_statement" "lexical_declaration" "member_expression" "meta_property" "method_definition" "named_imports" "namespace_export" "namespace_import" "new_expression" "null" "number" "object" "object_assignment_pattern" "object_pattern" "optional_chain" "pair" "pair_pattern" "parenthesized_expression" "pattern" "primary_expression" "private_property_identifier" "program" "property_identifier" "regex" "regex_flags" "regex_pattern" "rest_pattern" "return_statement" "sequence_expression" "shorthand_property_identifier" "shorthand_property_identifier_pattern" "spread_element" "statement" "statement_block" "statement_identifier" "string" "string_fragment" "subscript_expression" "super" "switch_body" "switch_case" "switch_default" "switch_statement" "template_string" "template_substitution" "ternary_expression" "this" "throw_statement" "true" "try_statement" "unary_expression" "undefined" "update_expression" "variable_declaration" "variable_declarator" "while_statement" "with_statement" "yield_expression") - ) +(defconst combobulate-rules-jsx-types + '("arguments" "array" "array_pattern" "arrow_function" "assignment_expression" "assignment_pattern" "augmented_assignment_expression" "await_expression" "binary_expression" "break_statement" "call_expression" "catch_clause" "class" "class_body" "class_declaration" "class_heritage" "class_static_block" "comment" "computed_property_name" "continue_statement" "debugger_statement" "declaration" "decorator" "do_statement" "else_clause" "empty_statement" "escape_sequence" "export_clause" "export_specifier" "export_statement" "expression" "expression_statement" "false" "field_definition" "finally_clause" "for_in_statement" "for_statement" "formal_parameters" "function" "function_declaration" "generator_function" "generator_function_declaration" "glimmer_closing_tag" "glimmer_opening_tag" "glimmer_template" "hash_bang_line" "identifier" "if_statement" "import" "import_clause" "import_specifier" "import_statement" "jsx_attribute" "jsx_closing_element" "jsx_element" "jsx_expression" "jsx_namespace_name" "jsx_opening_element" "jsx_self_closing_element" "jsx_text" "labeled_statement" "lexical_declaration" "member_expression" "meta_property" "method_definition" "named_imports" "namespace_export" "namespace_import" "new_expression" "null" "number" "object" "object_assignment_pattern" "object_pattern" "optional_chain" "pair" "pair_pattern" "parenthesized_expression" "pattern" "primary_expression" "private_property_identifier" "program" "property_identifier" "regex" "regex_flags" "regex_pattern" "rest_pattern" "return_statement" "sequence_expression" "shorthand_property_identifier" "shorthand_property_identifier_pattern" "spread_element" "statement" "statement_block" "statement_identifier" "string" "string_fragment" "subscript_expression" "super" "switch_body" "switch_case" "switch_default" "switch_statement" "template_string" "template_substitution" "ternary_expression" "this" "throw_statement" "true" "try_statement" "unary_expression" "undefined" "update_expression" "variable_declaration" "variable_declarator" "while_statement" "with_statement" "yield_expression") +) ;; END All node types in jsx +;; START All supertypes in jsx +(defconst combobulate-rules-jsx-supertypes + '("declaration" "expression" "pattern" "primary_expression" "statement") +) +;; END All supertypes in jsx ;; START Production rules for go -(defconst combobulate-rules-go - '(("_expression" (:*unnamed* ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("_simple_statement" (:*unnamed* ("short_var_declaration" "dec_statement" "inc_statement" "send_statement" "expression_statement" "assignment_statement"))) - ("_simple_type" (:*unnamed* ("type_identifier" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("_statement" (:*unnamed* ("continue_statement" "defer_statement" "type_switch_statement" "send_statement" "for_statement" "if_statement" "dec_statement" "inc_statement" "return_statement" "type_declaration" "short_var_declaration" "assignment_statement" "select_statement" "fallthrough_statement" "go_statement" "empty_statement" "const_declaration" "var_declaration" "expression_switch_statement" "expression_statement" "break_statement" "goto_statement" "block" "labeled_statement"))) - ("_type" (:*unnamed* ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("argument_list" (:*unnamed* ("slice_type" "function_type" "parenthesized_expression" "type_assertion_expression" "map_type" "interpreted_string_literal" "binary_expression" "generic_type" "qualified_type" "array_type" "selector_expression" "type_identifier" "variadic_argument" "interface_type" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "union_type" "parenthesized_type" "identifier" "float_literal" "call_expression" "imaginary_literal" "index_expression" "negated_type" "nil" "type_conversion_expression" "false" "raw_string_literal" "iota" "struct_type" "rune_literal" "pointer_type" "channel_type" "unary_expression"))) - ("array_type" (:element ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type") :length ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("assignment_statement" (:left ("expression_list") :operator nil :right ("expression_list"))) - ("binary_expression" (:left ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression") :operator nil :right ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("block" (:*unnamed* ("continue_statement" "defer_statement" "type_switch_statement" "send_statement" "for_statement" "if_statement" "dec_statement" "inc_statement" "return_statement" "type_declaration" "short_var_declaration" "assignment_statement" "select_statement" "fallthrough_statement" "go_statement" "empty_statement" "const_declaration" "var_declaration" "expression_switch_statement" "expression_statement" "break_statement" "goto_statement" "block" "labeled_statement"))) - ("break_statement" (:*unnamed* ("label_name"))) - ("call_expression" (:arguments ("argument_list") :function ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression") :type_arguments ("type_arguments"))) - ("channel_type" (:value ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("communication_case" (:*unnamed* ("continue_statement" "defer_statement" "type_switch_statement" "send_statement" "for_statement" "if_statement" "dec_statement" "inc_statement" "return_statement" "type_declaration" "short_var_declaration" "assignment_statement" "select_statement" "fallthrough_statement" "go_statement" "empty_statement" "const_declaration" "var_declaration" "expression_switch_statement" "expression_statement" "break_statement" "goto_statement" "block" "labeled_statement") :communication ("receive_statement" "send_statement"))) - ("composite_literal" (:body ("literal_value") :type ("type_identifier" "slice_type" "struct_type" "map_type" "generic_type" "qualified_type" "implicit_length_array_type" "array_type"))) - ("const_declaration" (:*unnamed* ("const_spec"))) - ("const_spec" (:name ("identifier") :type ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type") :value ("expression_list"))) - ("continue_statement" (:*unnamed* ("label_name"))) - ("dec_statement" (:*unnamed* ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("default_case" (:*unnamed* ("continue_statement" "defer_statement" "type_switch_statement" "send_statement" "for_statement" "if_statement" "dec_statement" "inc_statement" "return_statement" "type_declaration" "short_var_declaration" "assignment_statement" "select_statement" "fallthrough_statement" "go_statement" "empty_statement" "const_declaration" "var_declaration" "expression_switch_statement" "expression_statement" "break_statement" "goto_statement" "block" "labeled_statement"))) - ("defer_statement" (:*unnamed* ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("expression_case" (:*unnamed* ("continue_statement" "defer_statement" "type_switch_statement" "send_statement" "for_statement" "if_statement" "dec_statement" "inc_statement" "return_statement" "type_declaration" "short_var_declaration" "assignment_statement" "select_statement" "fallthrough_statement" "go_statement" "empty_statement" "const_declaration" "var_declaration" "expression_switch_statement" "expression_statement" "break_statement" "goto_statement" "block" "labeled_statement") :value ("expression_list"))) - ("expression_list" (:*unnamed* ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("expression_statement" (:*unnamed* ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("expression_switch_statement" (:*unnamed* ("expression_case" "default_case") :initializer ("short_var_declaration" "dec_statement" "inc_statement" "send_statement" "expression_statement" "assignment_statement") :value ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("field_declaration" (:name ("field_identifier") :tag ("interpreted_string_literal" "raw_string_literal") :type ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("field_declaration_list" (:*unnamed* ("field_declaration"))) - ("for_clause" (:condition ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression") :initializer ("short_var_declaration" "dec_statement" "inc_statement" "send_statement" "expression_statement" "assignment_statement") :update ("short_var_declaration" "dec_statement" "inc_statement" "send_statement" "expression_statement" "assignment_statement"))) - ("for_statement" (:*unnamed* ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "for_clause" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "range_clause" "unary_expression") :body ("block"))) - ("func_literal" (:body ("block") :parameters ("parameter_list") :result ("type_identifier" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "parameter_list" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("function_declaration" (:body ("block") :name ("identifier") :parameters ("parameter_list") :result ("type_identifier" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "parameter_list" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type") :type_parameters ("type_parameter_list"))) - ("function_type" (:parameters ("parameter_list") :result ("type_identifier" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "parameter_list" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("generic_type" (:type ("type_identifier" "negated_type" "qualified_type" "union_type") :type_arguments ("type_arguments"))) - ("go_statement" (:*unnamed* ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("goto_statement" (:*unnamed* ("label_name"))) - ("if_statement" (:alternative ("if_statement" "block") :condition ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression") :consequence ("block") :initializer ("short_var_declaration" "dec_statement" "inc_statement" "send_statement" "expression_statement" "assignment_statement"))) - ("implicit_length_array_type" (:element ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("import_declaration" (:*unnamed* ("import_spec_list" "import_spec"))) - ("import_spec" (:name ("package_identifier" "blank_identifier" "dot") :path ("interpreted_string_literal" "raw_string_literal"))) - ("import_spec_list" (:*unnamed* ("import_spec"))) - ("inc_statement" (:*unnamed* ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("index_expression" (:index ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression") :operand ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("interface_type" (:*unnamed* ("constraint_elem" "method_spec" "struct_elem"))) - ("interpreted_string_literal" (:*unnamed* ("escape_sequence"))) - ("keyed_element" (:*unnamed* ("literal_element"))) - ("labeled_statement" (:*unnamed* ("continue_statement" "defer_statement" "type_switch_statement" "send_statement" "for_statement" "if_statement" "dec_statement" "inc_statement" "return_statement" "type_declaration" "short_var_declaration" "assignment_statement" "select_statement" "fallthrough_statement" "go_statement" "empty_statement" "const_declaration" "var_declaration" "expression_switch_statement" "expression_statement" "break_statement" "goto_statement" "block" "labeled_statement") :label ("label_name"))) - ("literal_element" (:*unnamed* ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "literal_value" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("literal_value" (:*unnamed* ("literal_element" "keyed_element"))) - ("map_type" (:key ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type") :value ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("method_declaration" (:body ("block") :name ("field_identifier") :parameters ("parameter_list") :receiver ("parameter_list") :result ("type_identifier" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "parameter_list" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("method_spec" (:name ("field_identifier") :parameters ("parameter_list") :result ("type_identifier" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "parameter_list" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("negated_type" (:*unnamed* ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("package_clause" (:*unnamed* ("package_identifier"))) - ("parameter_declaration" (:name ("identifier") :type ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("parameter_list" (:*unnamed* ("variadic_parameter_declaration" "parameter_declaration"))) - ("parenthesized_expression" (:*unnamed* ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("parenthesized_type" (:*unnamed* ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("pointer_type" (:*unnamed* ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("qualified_type" (:name ("type_identifier") :package ("package_identifier"))) - ("range_clause" (:left ("expression_list") :right ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("receive_statement" (:left ("expression_list") :right ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("return_statement" (:*unnamed* ("expression_list"))) - ("select_statement" (:*unnamed* ("communication_case" "default_case"))) - ("selector_expression" (:field ("field_identifier") :operand ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("send_statement" (:channel ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression") :value ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("short_var_declaration" (:left ("expression_list") :right ("expression_list"))) - ("slice_expression" (:capacity ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression") :end ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression") :operand ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression") :start ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("slice_type" (:element ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("source_file" (:*unnamed* ("continue_statement" "defer_statement" "type_switch_statement" "package_clause" "send_statement" "for_statement" "if_statement" "dec_statement" "inc_statement" "return_statement" "type_declaration" "method_declaration" "import_declaration" "short_var_declaration" "assignment_statement" "select_statement" "fallthrough_statement" "go_statement" "empty_statement" "const_declaration" "var_declaration" "expression_switch_statement" "expression_statement" "break_statement" "function_declaration" "goto_statement" "block" "labeled_statement"))) - ("struct_elem" (:*unnamed* ("struct_term"))) - ("struct_term" (:*unnamed* ("struct_type"))) - ("struct_type" (:*unnamed* ("field_declaration_list"))) - ("type_alias" (:name ("type_identifier") :type ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("type_arguments" (:*unnamed* ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("type_assertion_expression" (:operand ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression") :type ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("type_case" (:*unnamed* ("continue_statement" "defer_statement" "type_switch_statement" "send_statement" "for_statement" "if_statement" "dec_statement" "inc_statement" "return_statement" "type_declaration" "short_var_declaration" "assignment_statement" "select_statement" "fallthrough_statement" "go_statement" "empty_statement" "const_declaration" "var_declaration" "expression_switch_statement" "expression_statement" "break_statement" "goto_statement" "block" "labeled_statement") :type ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("type_conversion_expression" (:operand ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression") :type ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("type_declaration" (:*unnamed* ("type_spec" "type_alias"))) - ("type_parameter_list" (:*unnamed* ("parameter_declaration"))) - ("type_spec" (:name ("type_identifier") :type ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type") :type_parameters ("type_parameter_list"))) - ("type_switch_statement" (:*unnamed* ("type_case" "default_case") :alias ("expression_list") :initializer ("short_var_declaration" "dec_statement" "inc_statement" "send_statement" "expression_statement" "assignment_statement") :value ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("unary_expression" (:operand ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression") :operator nil)) - ("union_type" (:*unnamed* ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("var_declaration" (:*unnamed* ("var_spec"))) - ("var_spec" (:name ("identifier") :type ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type") :value ("expression_list"))) - ("variadic_argument" (:*unnamed* ("identifier" "float_literal" "parenthesized_expression" "type_assertion_expression" "interpreted_string_literal" "binary_expression" "call_expression" "imaginary_literal" "index_expression" "nil" "selector_expression" "type_conversion_expression" "false" "raw_string_literal" "iota" "true" "func_literal" "int_literal" "composite_literal" "slice_expression" "rune_literal" "unary_expression"))) - ("variadic_parameter_declaration" (:name ("identifier") :type ("type_identifier" "parenthesized_type" "slice_type" "function_type" "interface_type" "struct_type" "map_type" "generic_type" "pointer_type" "channel_type" "negated_type" "qualified_type" "union_type" "array_type"))) - ("blank_identifier" (:*unnamed* nil)) - ("comment" (:*unnamed* nil)) - ("escape_sequence" (:*unnamed* nil)) - ("false" (:*unnamed* nil)) - ("field_identifier" (:*unnamed* nil)) - ("float_literal" (:*unnamed* nil)) - ("identifier" (:*unnamed* nil)) - ("imaginary_literal" (:*unnamed* nil)) - ("int_literal" (:*unnamed* nil)) - ("iota" (:*unnamed* nil)) - ("label_name" (:*unnamed* nil)) - ("nil" (:*unnamed* nil)) - ("package_identifier" (:*unnamed* nil)) - ("raw_string_literal" (:*unnamed* nil)) - ("rune_literal" (:*unnamed* nil)) - ("true" (:*unnamed* nil)) - ("type_identifier" (:*unnamed* nil)) - )) +(defconst combobulate-rules-go + '(("_expression" (:*unnamed* ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("_simple_statement" (:*unnamed* ("dec_statement" "assignment_statement" "short_var_declaration" "send_statement" "expression_statement" "inc_statement"))) + ("_simple_type" (:*unnamed* ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("_statement" (:*unnamed* ("break_statement" "type_switch_statement" "expression_statement" "if_statement" "continue_statement" "goto_statement" "expression_switch_statement" "send_statement" "inc_statement" "go_statement" "empty_statement" "dec_statement" "assignment_statement" "short_var_declaration" "for_statement" "defer_statement" "select_statement" "block" "labeled_statement" "fallthrough_statement" "return_statement" "var_declaration" "const_declaration" "type_declaration"))) + ("_type" (:*unnamed* ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("argument_list" (:*unnamed* ("false" "interface_type" "index_expression" "iota" "type_assertion_expression" "negated_type" "binary_expression" "pointer_type" "parenthesized_expression" "type_identifier" "call_expression" "true" "function_type" "channel_type" "variadic_argument" "parenthesized_type" "composite_literal" "generic_type" "rune_literal" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "qualified_type" "type_conversion_expression" "union_type" "slice_expression" "imaginary_literal" "interpreted_string_literal" "nil" "struct_type" "map_type" "float_literal" "unary_expression" "slice_type" "identifier" "array_type"))) + ("array_type" (:*unnamed* nil :element ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type") :length ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("assignment_statement" (:*unnamed* nil :left ("expression_list") :operator nil :right ("expression_list"))) + ("binary_expression" (:*unnamed* nil :left ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :operator nil :right ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("block" (:*unnamed* ("break_statement" "type_switch_statement" "expression_statement" "if_statement" "continue_statement" "goto_statement" "expression_switch_statement" "send_statement" "inc_statement" "go_statement" "empty_statement" "dec_statement" "assignment_statement" "short_var_declaration" "for_statement" "defer_statement" "select_statement" "block" "labeled_statement" "fallthrough_statement" "return_statement" "var_declaration" "const_declaration" "type_declaration"))) + ("break_statement" (:*unnamed* ("label_name"))) + ("call_expression" (:*unnamed* nil :arguments ("argument_list") :function ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :type_arguments ("type_arguments"))) + ("channel_type" (:*unnamed* nil :value ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("communication_case" (:*unnamed* ("break_statement" "type_switch_statement" "expression_statement" "if_statement" "continue_statement" "goto_statement" "expression_switch_statement" "send_statement" "inc_statement" "go_statement" "empty_statement" "dec_statement" "assignment_statement" "short_var_declaration" "for_statement" "defer_statement" "select_statement" "block" "labeled_statement" "fallthrough_statement" "return_statement" "var_declaration" "const_declaration" "type_declaration") :communication ("send_statement" "receive_statement"))) + ("composite_literal" (:*unnamed* nil :body ("literal_value") :type ("implicit_length_array_type" "type_identifier" "struct_type" "map_type" "slice_type" "array_type" "qualified_type" "generic_type"))) + ("const_declaration" (:*unnamed* ("const_spec"))) + ("const_spec" (:*unnamed* nil :name ("identifier") :type ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type") :value ("expression_list"))) + ("continue_statement" (:*unnamed* ("label_name"))) + ("dec_statement" (:*unnamed* ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("default_case" (:*unnamed* ("break_statement" "type_switch_statement" "expression_statement" "if_statement" "continue_statement" "goto_statement" "expression_switch_statement" "send_statement" "inc_statement" "go_statement" "empty_statement" "dec_statement" "assignment_statement" "short_var_declaration" "for_statement" "defer_statement" "select_statement" "block" "labeled_statement" "fallthrough_statement" "return_statement" "var_declaration" "const_declaration" "type_declaration"))) + ("defer_statement" (:*unnamed* ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("dot" (:*unnamed* nil)) + ("empty_statement" (:*unnamed* nil)) + ("expression_case" (:*unnamed* ("break_statement" "type_switch_statement" "expression_statement" "if_statement" "continue_statement" "goto_statement" "expression_switch_statement" "send_statement" "inc_statement" "go_statement" "empty_statement" "dec_statement" "assignment_statement" "short_var_declaration" "for_statement" "defer_statement" "select_statement" "block" "labeled_statement" "fallthrough_statement" "return_statement" "var_declaration" "const_declaration" "type_declaration") :value ("expression_list"))) + ("expression_list" (:*unnamed* ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("expression_statement" (:*unnamed* ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("expression_switch_statement" (:*unnamed* ("default_case" "expression_case") :initializer ("dec_statement" "assignment_statement" "short_var_declaration" "send_statement" "expression_statement" "inc_statement") :value ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("fallthrough_statement" (:*unnamed* nil)) + ("field_declaration" (:*unnamed* nil :name ("field_identifier") :tag ("interpreted_string_literal" "raw_string_literal") :type ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("field_declaration_list" (:*unnamed* ("field_declaration"))) + ("for_clause" (:*unnamed* nil :condition ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :initializer ("dec_statement" "assignment_statement" "short_var_declaration" "send_statement" "expression_statement" "inc_statement") :update ("dec_statement" "assignment_statement" "short_var_declaration" "send_statement" "expression_statement" "inc_statement"))) + ("for_statement" (:*unnamed* ("false" "int_literal" "func_literal" "selector_expression" "range_clause" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "for_clause" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :body ("block"))) + ("func_literal" (:*unnamed* nil :body ("block") :parameters ("parameter_list") :result ("type_identifier" "interface_type" "parameter_list" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("function_declaration" (:*unnamed* nil :body ("block") :name ("identifier") :parameters ("parameter_list") :result ("type_identifier" "interface_type" "parameter_list" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type") :type_parameters ("type_parameter_list"))) + ("function_type" (:*unnamed* nil :parameters ("parameter_list") :result ("type_identifier" "interface_type" "parameter_list" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("generic_type" (:*unnamed* nil :type ("union_type" "type_identifier" "qualified_type" "negated_type") :type_arguments ("type_arguments"))) + ("go_statement" (:*unnamed* ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("goto_statement" (:*unnamed* ("label_name"))) + ("if_statement" (:*unnamed* nil :alternative ("if_statement" "block") :condition ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :consequence ("block") :initializer ("dec_statement" "assignment_statement" "short_var_declaration" "send_statement" "expression_statement" "inc_statement"))) + ("implicit_length_array_type" (:*unnamed* nil :element ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("import_declaration" (:*unnamed* ("import_spec" "import_spec_list"))) + ("import_spec" (:*unnamed* nil :name ("blank_identifier" "dot" "package_identifier") :path ("interpreted_string_literal" "raw_string_literal"))) + ("import_spec_list" (:*unnamed* ("import_spec"))) + ("inc_statement" (:*unnamed* ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("index_expression" (:*unnamed* nil :index ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :operand ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("interface_type" (:*unnamed* ("constraint_elem" "struct_elem" "method_spec"))) + ("interpreted_string_literal" (:*unnamed* ("escape_sequence"))) + ("keyed_element" (:*unnamed* ("literal_element"))) + ("labeled_statement" (:*unnamed* ("break_statement" "type_switch_statement" "expression_statement" "if_statement" "continue_statement" "goto_statement" "expression_switch_statement" "send_statement" "inc_statement" "go_statement" "empty_statement" "dec_statement" "assignment_statement" "short_var_declaration" "for_statement" "defer_statement" "select_statement" "block" "labeled_statement" "fallthrough_statement" "return_statement" "var_declaration" "const_declaration" "type_declaration") :label ("label_name"))) + ("literal_element" (:*unnamed* ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "literal_value" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("literal_value" (:*unnamed* ("literal_element" "keyed_element"))) + ("map_type" (:*unnamed* nil :key ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type") :value ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("method_declaration" (:*unnamed* nil :body ("block") :name ("field_identifier") :parameters ("parameter_list") :receiver ("parameter_list") :result ("type_identifier" "interface_type" "parameter_list" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("method_spec" (:*unnamed* nil :name ("field_identifier") :parameters ("parameter_list") :result ("type_identifier" "interface_type" "parameter_list" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("negated_type" (:*unnamed* ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("package_clause" (:*unnamed* ("package_identifier"))) + ("parameter_declaration" (:*unnamed* nil :name ("identifier") :type ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("parameter_list" (:*unnamed* ("parameter_declaration" "variadic_parameter_declaration"))) + ("parenthesized_expression" (:*unnamed* ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("parenthesized_type" (:*unnamed* ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("pointer_type" (:*unnamed* ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("qualified_type" (:*unnamed* nil :name ("type_identifier") :package ("package_identifier"))) + ("range_clause" (:*unnamed* nil :left ("expression_list") :right ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("receive_statement" (:*unnamed* nil :left ("expression_list") :right ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("return_statement" (:*unnamed* ("expression_list"))) + ("select_statement" (:*unnamed* ("communication_case" "default_case"))) + ("selector_expression" (:*unnamed* nil :field ("field_identifier") :operand ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("send_statement" (:*unnamed* nil :channel ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :value ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("short_var_declaration" (:*unnamed* nil :left ("expression_list") :right ("expression_list"))) + ("slice_expression" (:*unnamed* nil :capacity ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :end ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :operand ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :start ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("slice_type" (:*unnamed* nil :element ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("source_file" (:*unnamed* ("break_statement" "type_switch_statement" "expression_statement" "if_statement" "continue_statement" "goto_statement" "package_clause" "expression_switch_statement" "send_statement" "inc_statement" "go_statement" "function_declaration" "empty_statement" "import_declaration" "dec_statement" "assignment_statement" "short_var_declaration" "for_statement" "defer_statement" "select_statement" "block" "labeled_statement" "fallthrough_statement" "return_statement" "var_declaration" "const_declaration" "method_declaration" "type_declaration"))) + ("struct_elem" (:*unnamed* ("struct_term"))) + ("struct_term" (:*unnamed* ("struct_type"))) + ("struct_type" (:*unnamed* ("field_declaration_list"))) + ("type_alias" (:*unnamed* nil :name ("type_identifier") :type ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("type_arguments" (:*unnamed* ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("type_assertion_expression" (:*unnamed* nil :operand ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :type ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("type_case" (:*unnamed* ("break_statement" "type_switch_statement" "expression_statement" "if_statement" "continue_statement" "goto_statement" "expression_switch_statement" "send_statement" "inc_statement" "go_statement" "empty_statement" "dec_statement" "assignment_statement" "short_var_declaration" "for_statement" "defer_statement" "select_statement" "block" "labeled_statement" "fallthrough_statement" "return_statement" "var_declaration" "const_declaration" "type_declaration") :type ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("type_conversion_expression" (:*unnamed* nil :operand ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :type ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("type_declaration" (:*unnamed* ("type_spec" "type_alias"))) + ("type_parameter_list" (:*unnamed* ("parameter_declaration"))) + ("type_spec" (:*unnamed* nil :name ("type_identifier") :type ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type") :type_parameters ("type_parameter_list"))) + ("type_switch_statement" (:*unnamed* ("type_case" "default_case") :alias ("expression_list") :initializer ("dec_statement" "assignment_statement" "short_var_declaration" "send_statement" "expression_statement" "inc_statement") :value ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("unary_expression" (:*unnamed* nil :operand ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal") :operator nil)) + ("union_type" (:*unnamed* ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("var_declaration" (:*unnamed* ("var_spec"))) + ("var_spec" (:*unnamed* nil :name ("identifier") :type ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type") :value ("expression_list"))) + ("variadic_argument" (:*unnamed* ("false" "int_literal" "func_literal" "selector_expression" "raw_string_literal" "index_expression" "iota" "type_assertion_expression" "binary_expression" "type_conversion_expression" "slice_expression" "parenthesized_expression" "imaginary_literal" "call_expression" "interpreted_string_literal" "nil" "true" "float_literal" "unary_expression" "identifier" "composite_literal" "rune_literal"))) + ("variadic_parameter_declaration" (:*unnamed* nil :name ("identifier") :type ("type_identifier" "interface_type" "struct_type" "map_type" "function_type" "slice_type" "channel_type" "array_type" "parenthesized_type" "qualified_type" "negated_type" "generic_type" "union_type" "pointer_type"))) + ("blank_identifier" (:*unnamed* nil)) + ("comment" (:*unnamed* nil)) + ("escape_sequence" (:*unnamed* nil)) + ("false" (:*unnamed* nil)) + ("field_identifier" (:*unnamed* nil)) + ("float_literal" (:*unnamed* nil)) + ("identifier" (:*unnamed* nil)) + ("imaginary_literal" (:*unnamed* nil)) + ("int_literal" (:*unnamed* nil)) + ("iota" (:*unnamed* nil)) + ("label_name" (:*unnamed* nil)) + ("nil" (:*unnamed* nil)) + ("package_identifier" (:*unnamed* nil)) + ("raw_string_literal" (:*unnamed* nil)) + ("rune_literal" (:*unnamed* nil)) + ("true" (:*unnamed* nil)) + ("type_identifier" (:*unnamed* nil)) +)) ;; END Production rules for go ;; START Inverse production rules for go -(defconst combobulate-rules-go-inverse - '(("argument_list" ("call_expression")) - ("array_type" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "method_declaration" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "composite_literal" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("assignment_statement" ("type_switch_statement" "_simple_statement" "for_clause" "expression_switch_statement" "if_statement" "expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("binary_expression" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("blank_identifier" ("import_spec")) - ("block" ("for_statement" "if_statement" "expression_case" "func_literal" "function_declaration" "communication_case" "_statement" "method_declaration" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("break_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("call_expression" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("channel_type" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "method_declaration" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("communication_case" ("select_statement")) - ("composite_literal" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("const_declaration" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("const_spec" ("const_declaration")) - ("constraint_elem" ("interface_type")) - ("continue_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("dec_statement" ("type_switch_statement" "_simple_statement" "for_clause" "expression_switch_statement" "if_statement" "expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("default_case" ("select_statement" "expression_switch_statement" "type_switch_statement")) - ("defer_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("dot" ("import_spec")) - ("empty_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("escape_sequence" ("interpreted_string_literal")) - ("expression_case" ("expression_switch_statement")) - ("expression_list" ("type_switch_statement" "var_spec" "const_spec" "expression_case" "receive_statement" "return_statement" "range_clause" "short_var_declaration" "assignment_statement")) - ("expression_statement" ("type_switch_statement" "_simple_statement" "for_clause" "expression_switch_statement" "if_statement" "expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("expression_switch_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("fallthrough_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("false" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("field_declaration" ("field_declaration_list")) - ("field_declaration_list" ("struct_type")) - ("field_identifier" ("selector_expression" "field_declaration" "method_declaration" "method_spec")) - ("float_literal" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("for_clause" ("for_statement")) - ("for_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("func_literal" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("function_declaration" ("source_file")) - ("function_type" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "method_declaration" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("generic_type" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "method_declaration" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "composite_literal" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("go_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("goto_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("identifier" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "variadic_parameter_declaration" "go_statement" "for_clause" "expression_list" "function_declaration" "receive_statement" "slice_expression" "range_clause" "var_spec" "_expression" "const_spec" "for_statement" "call_expression" "index_expression" "parameter_declaration" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("if_statement" ("if_statement" "expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("imaginary_literal" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("implicit_length_array_type" ("composite_literal")) - ("import_declaration" ("source_file")) - ("import_spec" ("import_declaration" "import_spec_list")) - ("import_spec_list" ("import_declaration")) - ("inc_statement" ("type_switch_statement" "_simple_statement" "for_clause" "expression_switch_statement" "if_statement" "expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("index_expression" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("int_literal" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("interface_type" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "method_declaration" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("interpreted_string_literal" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "field_declaration" "expression_list" "receive_statement" "slice_expression" "import_spec" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("iota" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("keyed_element" ("literal_value")) - ("label_name" ("labeled_statement" "continue_statement" "break_statement" "goto_statement")) - ("labeled_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("literal_element" ("literal_value" "keyed_element")) - ("literal_value" ("composite_literal" "literal_element")) - ("map_type" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "method_declaration" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "composite_literal" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("method_declaration" ("source_file")) - ("method_spec" ("interface_type")) - ("negated_type" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "generic_type" "method_declaration" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("nil" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("package_clause" ("source_file")) - ("package_identifier" ("qualified_type" "package_clause" "import_spec")) - ("parameter_declaration" ("parameter_list" "type_parameter_list")) - ("parameter_list" ("function_type" "func_literal" "function_declaration" "method_spec" "method_declaration")) - ("parenthesized_expression" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("parenthesized_type" ("slice_type" "type_assertion_expression" "type_alias" "map_type" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "type_arguments" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "pointer_type" "channel_type" "type_case")) - ("pointer_type" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "method_declaration" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("qualified_type" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "generic_type" "method_declaration" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "composite_literal" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("range_clause" ("for_statement")) - ("raw_string_literal" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "field_declaration" "expression_list" "receive_statement" "slice_expression" "import_spec" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("receive_statement" ("communication_case")) - ("return_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("rune_literal" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("select_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("selector_expression" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("send_statement" ("type_switch_statement" "_simple_statement" "for_clause" "expression_switch_statement" "if_statement" "expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("short_var_declaration" ("type_switch_statement" "_simple_statement" "for_clause" "expression_switch_statement" "if_statement" "expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("slice_expression" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("slice_type" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "method_declaration" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "composite_literal" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("struct_elem" ("interface_type")) - ("struct_term" ("struct_elem")) - ("struct_type" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "method_declaration" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "composite_literal" "struct_term" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("true" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("type_alias" ("type_declaration")) - ("type_arguments" ("generic_type" "call_expression")) - ("type_assertion_expression" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("type_case" ("type_switch_statement")) - ("type_conversion_expression" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("type_declaration" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("type_identifier" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "generic_type" "method_declaration" "qualified_type" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "composite_literal" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("type_parameter_list" ("type_spec" "function_declaration")) - ("type_spec" ("type_declaration")) - ("type_switch_statement" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("unary_expression" ("defer_statement" "type_switch_statement" "send_statement" "parenthesized_expression" "type_assertion_expression" "if_statement" "dec_statement" "binary_expression" "inc_statement" "array_type" "selector_expression" "variadic_argument" "go_statement" "for_clause" "expression_list" "receive_statement" "slice_expression" "range_clause" "_expression" "for_statement" "call_expression" "index_expression" "argument_list" "type_conversion_expression" "expression_switch_statement" "expression_statement" "literal_element" "unary_expression")) - ("union_type" ("slice_type" "function_type" "type_assertion_expression" "_simple_type" "map_type" "type_alias" "generic_type" "method_declaration" "implicit_length_array_type" "array_type" "variadic_parameter_declaration" "field_declaration" "func_literal" "function_declaration" "type_case" "var_spec" "union_type" "parenthesized_type" "type_spec" "const_spec" "_type" "negated_type" "parameter_declaration" "argument_list" "type_conversion_expression" "method_spec" "pointer_type" "channel_type" "type_arguments")) - ("var_declaration" ("expression_case" "communication_case" "_statement" "type_case" "block" "labeled_statement" "source_file" "default_case")) - ("var_spec" ("var_declaration")) - ("variadic_argument" ("argument_list")) - ("variadic_parameter_declaration" ("parameter_list")) - ) - ) +(defconst combobulate-rules-go-inverse + '(("argument_list" ("call_expression")) + ("array_type" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "composite_literal" "var_spec" "argument_list" "func_literal" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("assignment_statement" ("communication_case" "default_case" "type_switch_statement" "_statement" "expression_case" "for_clause" "if_statement" "block" "labeled_statement" "expression_switch_statement" "source_file" "_simple_statement" "type_case")) + ("binary_expression" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("blank_identifier" ("import_spec")) + ("block" ("communication_case" "default_case" "expression_case" "_statement" "for_statement" "func_literal" "if_statement" "block" "labeled_statement" "source_file" "type_case" "method_declaration" "function_declaration")) + ("break_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("call_expression" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("channel_type" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "var_spec" "argument_list" "func_literal" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("communication_case" ("select_statement")) + ("composite_literal" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("const_declaration" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("const_spec" ("const_declaration")) + ("constraint_elem" ("interface_type")) + ("continue_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("dec_statement" ("communication_case" "default_case" "type_switch_statement" "_statement" "expression_case" "for_clause" "if_statement" "block" "labeled_statement" "expression_switch_statement" "source_file" "_simple_statement" "type_case")) + ("default_case" ("type_switch_statement" "expression_switch_statement" "select_statement")) + ("defer_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("dot" ("import_spec")) + ("empty_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("escape_sequence" ("interpreted_string_literal")) + ("expression_case" ("expression_switch_statement")) + ("expression_list" ("const_spec" "type_switch_statement" "expression_case" "assignment_statement" "range_clause" "short_var_declaration" "return_statement" "receive_statement" "var_spec")) + ("expression_statement" ("communication_case" "default_case" "type_switch_statement" "_statement" "expression_case" "for_clause" "if_statement" "block" "labeled_statement" "expression_switch_statement" "source_file" "_simple_statement" "type_case")) + ("expression_switch_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("fallthrough_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("false" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("field_declaration" ("field_declaration_list")) + ("field_declaration_list" ("struct_type")) + ("field_identifier" ("selector_expression" "method_declaration" "method_spec" "field_declaration")) + ("float_literal" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("for_clause" ("for_statement")) + ("for_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("func_literal" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("function_declaration" ("source_file")) + ("function_type" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "var_spec" "argument_list" "func_literal" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("generic_type" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "composite_literal" "var_spec" "argument_list" "func_literal" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("go_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("goto_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("identifier" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "function_declaration" "const_spec" "parenthesized_expression" "call_expression" "for_statement" "parameter_declaration" "for_clause" "variadic_argument" "var_spec" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "variadic_parameter_declaration" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("if_statement" ("communication_case" "default_case" "expression_case" "_statement" "if_statement" "block" "labeled_statement" "source_file" "type_case")) + ("imaginary_literal" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("implicit_length_array_type" ("composite_literal")) + ("import_declaration" ("source_file")) + ("import_spec" ("import_declaration" "import_spec_list")) + ("import_spec_list" ("import_declaration")) + ("inc_statement" ("communication_case" "default_case" "type_switch_statement" "_statement" "expression_case" "for_clause" "if_statement" "block" "labeled_statement" "expression_switch_statement" "source_file" "_simple_statement" "type_case")) + ("index_expression" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("int_literal" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("interface_type" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "var_spec" "argument_list" "func_literal" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("interpreted_string_literal" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "import_spec" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "field_declaration" "receive_statement")) + ("iota" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("keyed_element" ("literal_value")) + ("label_name" ("continue_statement" "break_statement" "labeled_statement" "goto_statement")) + ("labeled_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("literal_element" ("literal_value" "keyed_element")) + ("literal_value" ("composite_literal" "literal_element")) + ("map_type" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "composite_literal" "var_spec" "argument_list" "func_literal" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("method_declaration" ("source_file")) + ("method_spec" ("interface_type")) + ("negated_type" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "generic_type" "var_spec" "argument_list" "func_literal" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("nil" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("package_clause" ("source_file")) + ("package_identifier" ("package_clause" "qualified_type" "import_spec")) + ("parameter_declaration" ("parameter_list" "type_parameter_list")) + ("parameter_list" ("func_literal" "method_spec" "function_type" "method_declaration" "function_declaration")) + ("parenthesized_expression" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("parenthesized_type" ("type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "const_spec" "_type" "parameter_declaration" "channel_type" "parenthesized_type" "var_spec" "argument_list" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case")) + ("pointer_type" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "var_spec" "argument_list" "func_literal" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("qualified_type" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "composite_literal" "generic_type" "var_spec" "argument_list" "func_literal" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("range_clause" ("for_statement")) + ("raw_string_literal" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "import_spec" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "field_declaration" "receive_statement")) + ("receive_statement" ("communication_case")) + ("return_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("rune_literal" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("select_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("selector_expression" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("send_statement" ("communication_case" "default_case" "type_switch_statement" "_statement" "expression_case" "for_clause" "if_statement" "block" "labeled_statement" "expression_switch_statement" "source_file" "_simple_statement" "type_case")) + ("short_var_declaration" ("communication_case" "default_case" "type_switch_statement" "_statement" "expression_case" "for_clause" "if_statement" "block" "labeled_statement" "expression_switch_statement" "source_file" "_simple_statement" "type_case")) + ("slice_expression" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("slice_type" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "composite_literal" "var_spec" "argument_list" "func_literal" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("struct_elem" ("interface_type")) + ("struct_term" ("struct_elem")) + ("struct_type" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "composite_literal" "var_spec" "argument_list" "func_literal" "struct_term" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("true" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("type_alias" ("type_declaration")) + ("type_arguments" ("call_expression" "generic_type")) + ("type_assertion_expression" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("type_case" ("type_switch_statement")) + ("type_conversion_expression" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("type_declaration" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("type_identifier" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "composite_literal" "generic_type" "var_spec" "argument_list" "func_literal" "qualified_type" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("type_parameter_list" ("type_spec" "function_declaration")) + ("type_spec" ("type_declaration")) + ("type_switch_statement" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("unary_expression" ("literal_element" "index_expression" "type_assertion_expression" "expression_list" "binary_expression" "parenthesized_expression" "call_expression" "for_statement" "for_clause" "variadic_argument" "type_switch_statement" "argument_list" "selector_expression" "range_clause" "expression_statement" "if_statement" "expression_switch_statement" "send_statement" "type_conversion_expression" "inc_statement" "go_statement" "slice_expression" "_expression" "dec_statement" "defer_statement" "unary_expression" "array_type" "receive_statement")) + ("union_type" ("method_spec" "_simple_type" "type_assertion_expression" "negated_type" "type_arguments" "pointer_type" "type_alias" "function_declaration" "const_spec" "_type" "parameter_declaration" "function_type" "channel_type" "parenthesized_type" "generic_type" "var_spec" "argument_list" "func_literal" "type_conversion_expression" "union_type" "variadic_parameter_declaration" "implicit_length_array_type" "map_type" "slice_type" "array_type" "type_spec" "field_declaration" "type_case" "method_declaration")) + ("var_declaration" ("communication_case" "default_case" "expression_case" "_statement" "block" "labeled_statement" "source_file" "type_case")) + ("var_spec" ("var_declaration")) + ("variadic_argument" ("argument_list")) + ("variadic_parameter_declaration" ("parameter_list")) + ) +) ;; END Inverse production rules for go ;; START All node types in go -(defconst combobulate-rules-go-types - '("_expression" "_simple_statement" "_simple_type" "_statement" "_type" "argument_list" "array_type" "assignment_statement" "binary_expression" "blank_identifier" "block" "break_statement" "call_expression" "channel_type" "comment" "communication_case" "composite_literal" "const_declaration" "const_spec" "constraint_elem" "continue_statement" "dec_statement" "default_case" "defer_statement" "dot" "empty_statement" "escape_sequence" "expression_case" "expression_list" "expression_statement" "expression_switch_statement" "fallthrough_statement" "false" "field_declaration" "field_declaration_list" "field_identifier" "float_literal" "for_clause" "for_statement" "func_literal" "function_declaration" "function_type" "generic_type" "go_statement" "goto_statement" "identifier" "if_statement" "imaginary_literal" "implicit_length_array_type" "import_declaration" "import_spec" "import_spec_list" "inc_statement" "index_expression" "int_literal" "interface_type" "interpreted_string_literal" "iota" "keyed_element" "label_name" "labeled_statement" "literal_element" "literal_value" "map_type" "method_declaration" "method_spec" "negated_type" "nil" "package_clause" "package_identifier" "parameter_declaration" "parameter_list" "parenthesized_expression" "parenthesized_type" "pointer_type" "qualified_type" "range_clause" "raw_string_literal" "receive_statement" "return_statement" "rune_literal" "select_statement" "selector_expression" "send_statement" "short_var_declaration" "slice_expression" "slice_type" "source_file" "struct_elem" "struct_term" "struct_type" "true" "type_alias" "type_arguments" "type_assertion_expression" "type_case" "type_conversion_expression" "type_declaration" "type_identifier" "type_parameter_list" "type_spec" "type_switch_statement" "unary_expression" "union_type" "var_declaration" "var_spec" "variadic_argument" "variadic_parameter_declaration") - ) +(defconst combobulate-rules-go-types + '("_expression" "_simple_statement" "_simple_type" "_statement" "_type" "argument_list" "array_type" "assignment_statement" "binary_expression" "blank_identifier" "block" "break_statement" "call_expression" "channel_type" "comment" "communication_case" "composite_literal" "const_declaration" "const_spec" "constraint_elem" "continue_statement" "dec_statement" "default_case" "defer_statement" "dot" "empty_statement" "escape_sequence" "expression_case" "expression_list" "expression_statement" "expression_switch_statement" "fallthrough_statement" "false" "field_declaration" "field_declaration_list" "field_identifier" "float_literal" "for_clause" "for_statement" "func_literal" "function_declaration" "function_type" "generic_type" "go_statement" "goto_statement" "identifier" "if_statement" "imaginary_literal" "implicit_length_array_type" "import_declaration" "import_spec" "import_spec_list" "inc_statement" "index_expression" "int_literal" "interface_type" "interpreted_string_literal" "iota" "keyed_element" "label_name" "labeled_statement" "literal_element" "literal_value" "map_type" "method_declaration" "method_spec" "negated_type" "nil" "package_clause" "package_identifier" "parameter_declaration" "parameter_list" "parenthesized_expression" "parenthesized_type" "pointer_type" "qualified_type" "range_clause" "raw_string_literal" "receive_statement" "return_statement" "rune_literal" "select_statement" "selector_expression" "send_statement" "short_var_declaration" "slice_expression" "slice_type" "source_file" "struct_elem" "struct_term" "struct_type" "true" "type_alias" "type_arguments" "type_assertion_expression" "type_case" "type_conversion_expression" "type_declaration" "type_identifier" "type_parameter_list" "type_spec" "type_switch_statement" "unary_expression" "union_type" "var_declaration" "var_spec" "variadic_argument" "variadic_parameter_declaration") +) ;; END All node types in go +;; START All supertypes in go +(defconst combobulate-rules-go-supertypes + '("_expression" "_simple_statement" "_simple_type" "_statement" "_type") +) +;; END All supertypes in go ;; START Production rules for python -(defconst combobulate-rules-python - '(("_compound_statement" (:*unnamed* ("function_definition" "while_statement" "decorated_definition" "for_statement" "with_statement" "try_statement" "match_statement" "if_statement" "class_definition"))) - ("_simple_statement" (:*unnamed* ("raise_statement" "continue_statement" "assert_statement" "type_alias_statement" "delete_statement" "import_statement" "return_statement" "pass_statement" "print_statement" "expression_statement" "future_import_statement" "break_statement" "nonlocal_statement" "global_statement" "exec_statement" "import_from_statement"))) - ("expression" (:*unnamed* ("primary_expression" "not_operator" "as_pattern" "comparison_operator" "lambda" "named_expression" "boolean_operator" "conditional_expression"))) - ("parameter" (:*unnamed* ("list_splat_pattern" "identifier" "typed_parameter" "tuple_pattern" "keyword_separator" "positional_separator" "typed_default_parameter" "dictionary_splat_pattern" "default_parameter"))) - ("pattern" (:*unnamed* ("list_splat_pattern" "identifier" "tuple_pattern" "subscript" "attribute" "list_pattern"))) - ("primary_expression" (:*unnamed* ("dictionary" "identifier" "string" "parenthesized_expression" "tuple" "attribute" "list" "await" "dictionary_comprehension" "float" "none" "unary_operator" "ellipsis" "list_comprehension" "false" "set_comprehension" "generator_expression" "subscript" "true" "list_splat" "binary_operator" "call" "concatenated_string" "integer" "set"))) - ("aliased_import" (:alias ("identifier") :name ("dotted_name"))) - ("argument_list" (:*unnamed* ("list_splat" "expression" "keyword_argument" "parenthesized_expression" "dictionary_splat"))) - ("as_pattern" (:*unnamed* ("case_pattern" "identifier" "expression") :alias ("as_pattern_target"))) - ("assert_statement" (:*unnamed* ("expression"))) - ("assignment" (:left ("pattern_list" "pattern") :right ("augmented_assignment" "yield" "expression" "pattern_list" "expression_list" "assignment") :type ("type"))) - ("attribute" (:attribute ("identifier") :object ("primary_expression"))) - ("augmented_assignment" (:left ("pattern_list" "pattern") :operator nil :right ("augmented_assignment" "yield" "expression" "pattern_list" "expression_list" "assignment"))) - ("await" (:*unnamed* ("primary_expression"))) - ("binary_operator" (:left ("primary_expression") :operator nil :right ("primary_expression"))) - ("block" (:*unnamed* ("raise_statement" "continue_statement" "function_definition" "assert_statement" "type_alias_statement" "for_statement" "with_statement" "delete_statement" "if_statement" "import_statement" "return_statement" "class_definition" "pass_statement" "print_statement" "while_statement" "decorated_definition" "expression_statement" "try_statement" "match_statement" "future_import_statement" "break_statement" "nonlocal_statement" "global_statement" "exec_statement" "import_from_statement") :alternative ("case_clause"))) - ("boolean_operator" (:left ("expression") :operator nil :right ("expression"))) - ("call" (:arguments ("generator_expression" "argument_list") :function ("primary_expression"))) - ("case_clause" (:*unnamed* ("case_pattern") :consequence ("block") :guard ("if_clause"))) - ("case_pattern" (:*unnamed* ("string" "dotted_name" "float" "none" "union_pattern" "false" "tuple_pattern" "as_pattern" "class_pattern" "keyword_pattern" "list_pattern" "complex_pattern" "true" "splat_pattern" "concatenated_string" "dict_pattern" "integer"))) - ("chevron" (:*unnamed* ("expression"))) - ("class_definition" (:body ("block") :name ("identifier") :superclasses ("argument_list") :type_parameters ("type_parameter"))) - ("class_pattern" (:*unnamed* ("case_pattern" "dotted_name"))) - ("comparison_operator" (:*unnamed* ("primary_expression") :operators nil)) - ("complex_pattern" (:*unnamed* ("integer" "float"))) - ("concatenated_string" (:*unnamed* ("string"))) - ("conditional_expression" (:*unnamed* ("expression"))) - ("constrained_type" (:*unnamed* ("type"))) - ("decorated_definition" (:*unnamed* ("decorator") :definition ("function_definition" "class_definition"))) - ("decorator" (:*unnamed* ("expression"))) - ("default_parameter" (:name ("identifier" "tuple_pattern") :value ("expression"))) - ("delete_statement" (:*unnamed* ("expression_list" "expression"))) - ("dict_pattern" (:*unnamed* ("splat_pattern") :key ("false" "string" "tuple_pattern" "class_pattern" "list_pattern" "complex_pattern" "dotted_name" "splat_pattern" "float" "true" "none" "union_pattern" "concatenated_string" "dict_pattern" "integer") :value ("case_pattern"))) - ("dictionary" (:*unnamed* ("pair" "dictionary_splat"))) - ("dictionary_comprehension" (:*unnamed* ("for_in_clause" "if_clause") :body ("pair"))) - ("dictionary_splat" (:*unnamed* ("expression"))) - ("dictionary_splat_pattern" (:*unnamed* ("subscript" "attribute" "identifier"))) - ("dotted_name" (:*unnamed* ("identifier"))) - ("elif_clause" (:condition ("expression") :consequence ("block"))) - ("else_clause" (:body ("block"))) - ("except_clause" (:*unnamed* ("expression" "block"))) - ("except_group_clause" (:*unnamed* ("expression" "block"))) - ("exec_statement" (:*unnamed* ("expression") :code ("string" "identifier"))) - ("expression_list" (:*unnamed* ("expression"))) - ("expression_statement" (:*unnamed* ("augmented_assignment" "yield" "expression" "assignment"))) - ("finally_clause" (:*unnamed* ("block"))) - ("for_in_clause" (:left ("pattern_list" "pattern") :right ("expression"))) - ("for_statement" (:alternative ("else_clause") :body ("block") :left ("pattern_list" "pattern") :right ("expression_list" "expression"))) - ("format_expression" (:expression ("pattern_list" "yield" "expression_list" "expression") :format_specifier ("format_specifier") :type_conversion ("type_conversion"))) - ("format_specifier" (:*unnamed* ("format_expression"))) - ("function_definition" (:body ("block") :name ("identifier") :parameters ("parameters") :return_type ("type") :type_parameters ("type_parameter"))) - ("future_import_statement" (:name ("aliased_import" "dotted_name"))) - ("generator_expression" (:*unnamed* ("for_in_clause" "if_clause") :body ("expression"))) - ("generic_type" (:*unnamed* ("identifier" "type_parameter"))) - ("global_statement" (:*unnamed* ("identifier"))) - ("if_clause" (:*unnamed* ("expression"))) - ("if_statement" (:alternative ("else_clause" "elif_clause") :condition ("expression") :consequence ("block"))) - ("import_from_statement" (:*unnamed* ("wildcard_import") :module_name ("relative_import" "dotted_name") :name ("aliased_import" "dotted_name"))) - ("import_statement" (:name ("aliased_import" "dotted_name"))) - ("interpolation" (:expression ("pattern_list" "yield" "expression_list" "expression") :format_specifier ("format_specifier") :type_conversion ("type_conversion"))) - ("keyword_argument" (:name ("identifier") :value ("expression"))) - ("keyword_pattern" (:*unnamed* ("identifier" "string" "dotted_name" "float" "none" "union_pattern" "false" "tuple_pattern" "class_pattern" "list_pattern" "complex_pattern" "true" "splat_pattern" "concatenated_string" "dict_pattern" "integer"))) - ("lambda" (:body ("expression") :parameters ("lambda_parameters"))) - ("lambda_parameters" (:*unnamed* ("parameter"))) - ("list" (:*unnamed* ("list_splat" "yield" "expression" "parenthesized_list_splat"))) - ("list_comprehension" (:*unnamed* ("for_in_clause" "if_clause") :body ("expression"))) - ("list_pattern" (:*unnamed* ("case_pattern" "pattern"))) - ("list_splat" (:*unnamed* ("subscript" "attribute" "expression" "identifier"))) - ("list_splat_pattern" (:*unnamed* ("subscript" "attribute" "identifier"))) - ("match_statement" (:body ("block") :subject ("expression"))) - ("member_type" (:*unnamed* ("type" "identifier"))) - ("module" (:*unnamed* ("raise_statement" "continue_statement" "function_definition" "assert_statement" "type_alias_statement" "for_statement" "with_statement" "delete_statement" "if_statement" "import_statement" "return_statement" "class_definition" "pass_statement" "print_statement" "while_statement" "decorated_definition" "expression_statement" "try_statement" "match_statement" "future_import_statement" "break_statement" "nonlocal_statement" "global_statement" "exec_statement" "import_from_statement"))) - ("named_expression" (:name ("identifier") :value ("expression"))) - ("nonlocal_statement" (:*unnamed* ("identifier"))) - ("not_operator" (:argument ("expression"))) - ("pair" (:key ("expression") :value ("expression"))) - ("parameters" (:*unnamed* ("parameter"))) - ("parenthesized_expression" (:*unnamed* ("parenthesized_expression" "list_splat" "yield" "expression"))) - ("parenthesized_list_splat" (:*unnamed* ("parenthesized_expression" "list_splat"))) - ("pattern_list" (:*unnamed* ("pattern"))) - ("print_statement" (:*unnamed* ("chevron") :argument ("expression"))) - ("raise_statement" (:*unnamed* ("expression_list" "expression") :cause ("expression"))) - ("relative_import" (:*unnamed* ("import_prefix" "dotted_name"))) - ("return_statement" (:*unnamed* ("expression_list" "expression"))) - ("set" (:*unnamed* ("list_splat" "yield" "expression" "parenthesized_list_splat"))) - ("set_comprehension" (:*unnamed* ("for_in_clause" "if_clause") :body ("expression"))) - ("slice" (:*unnamed* ("expression"))) - ("splat_pattern" (:*unnamed* ("identifier"))) - ("splat_type" (:*unnamed* ("identifier"))) - ("string" (:*unnamed* ("string_content" "string_start" "string_end" "interpolation"))) - ("string_content" (:*unnamed* ("escape_interpolation" "escape_sequence"))) - ("subscript" (:subscript ("slice" "expression") :value ("primary_expression"))) - ("try_statement" (:*unnamed* ("else_clause" "except_group_clause" "except_clause" "finally_clause") :body ("block"))) - ("tuple" (:*unnamed* ("list_splat" "yield" "expression" "parenthesized_list_splat"))) - ("tuple_pattern" (:*unnamed* ("case_pattern" "pattern"))) - ("type" (:*unnamed* ("constrained_type" "generic_type" "expression" "member_type" "splat_type" "union_type"))) - ("type_alias_statement" (:*unnamed* ("type"))) - ("type_parameter" (:*unnamed* ("type"))) - ("typed_default_parameter" (:name ("identifier") :type ("type") :value ("expression"))) - ("typed_parameter" (:*unnamed* ("list_splat_pattern" "identifier" "dictionary_splat_pattern") :type ("type"))) - ("unary_operator" (:argument ("primary_expression") :operator nil)) - ("union_pattern" (:*unnamed* ("false" "string" "tuple_pattern" "class_pattern" "list_pattern" "complex_pattern" "dotted_name" "splat_pattern" "float" "true" "none" "union_pattern" "concatenated_string" "dict_pattern" "integer"))) - ("union_type" (:*unnamed* ("type"))) - ("while_statement" (:alternative ("else_clause") :body ("block") :condition ("expression"))) - ("with_clause" (:*unnamed* ("with_item"))) - ("with_item" (:value ("expression"))) - ("with_statement" (:*unnamed* ("with_clause") :body ("block"))) - ("yield" (:*unnamed* ("expression_list" "expression"))) - ("comment" (:*unnamed* nil)) - ("ellipsis" (:*unnamed* nil)) - ("escape_interpolation" (:*unnamed* nil)) - ("escape_sequence" (:*unnamed* nil)) - ("false" (:*unnamed* nil)) - ("float" (:*unnamed* nil)) - ("identifier" (:*unnamed* nil)) - ("integer" (:*unnamed* nil)) - ("line_continuation" (:*unnamed* nil)) - ("none" (:*unnamed* nil)) - ("string_end" (:*unnamed* nil)) - ("string_start" (:*unnamed* nil)) - ("true" (:*unnamed* nil)) - ("type_conversion" (:*unnamed* nil)) - )) +(defconst combobulate-rules-python + '(("_compound_statement" (:*unnamed* ("class_definition" "for_statement" "match_statement" "while_statement" "if_statement" "decorated_definition" "function_definition" "with_statement" "try_statement"))) + ("_simple_statement" (:*unnamed* ("assert_statement" "break_statement" "import_statement" "future_import_statement" "expression_statement" "global_statement" "continue_statement" "exec_statement" "pass_statement" "type_alias_statement" "nonlocal_statement" "delete_statement" "raise_statement" "import_from_statement" "return_statement" "print_statement"))) + ("expression" (:*unnamed* ("as_pattern" "comparison_operator" "primary_expression" "conditional_expression" "boolean_operator" "lambda" "named_expression" "not_operator"))) + ("parameter" (:*unnamed* ("keyword_separator" "default_parameter" "tuple_pattern" "typed_parameter" "typed_default_parameter" "identifier" "list_splat_pattern" "positional_separator" "dictionary_splat_pattern"))) + ("pattern" (:*unnamed* ("identifier" "list_splat_pattern" "tuple_pattern" "attribute" "list_pattern" "subscript"))) + ("primary_expression" (:*unnamed* ("false" "generator_expression" "list_comprehension" "float" "unary_operator" "await" "set" "dictionary_comprehension" "attribute" "integer" "binary_operator" "parenthesized_expression" "tuple" "ellipsis" "concatenated_string" "true" "none" "string" "set_comprehension" "identifier" "list" "call" "dictionary" "list_splat" "subscript"))) + ("aliased_import" (:*unnamed* nil :alias ("identifier") :name ("dotted_name"))) + ("argument_list" (:*unnamed* ("parenthesized_expression" "expression" "dictionary_splat" "list_splat" "keyword_argument"))) + ("as_pattern" (:*unnamed* ("identifier" "expression" "case_pattern") :alias ("as_pattern_target"))) + ("assert_statement" (:*unnamed* ("expression"))) + ("assignment" (:*unnamed* nil :left ("pattern_list" "pattern") :right ("assignment" "expression" "augmented_assignment" "expression_list" "pattern_list" "yield") :type ("type"))) + ("attribute" (:*unnamed* nil :attribute ("identifier") :object ("primary_expression"))) + ("augmented_assignment" (:*unnamed* nil :left ("pattern_list" "pattern") :operator nil :right ("assignment" "expression" "augmented_assignment" "expression_list" "pattern_list" "yield"))) + ("await" (:*unnamed* ("primary_expression"))) + ("binary_operator" (:*unnamed* nil :left ("primary_expression") :operator nil :right ("primary_expression"))) + ("block" (:*unnamed* ("assert_statement" "break_statement" "match_statement" "import_statement" "future_import_statement" "expression_statement" "with_statement" "if_statement" "global_statement" "continue_statement" "exec_statement" "pass_statement" "type_alias_statement" "try_statement" "nonlocal_statement" "class_definition" "for_statement" "delete_statement" "raise_statement" "import_from_statement" "while_statement" "decorated_definition" "function_definition" "return_statement" "print_statement") :alternative ("case_clause"))) + ("boolean_operator" (:*unnamed* nil :left ("expression") :operator nil :right ("expression"))) + ("break_statement" (:*unnamed* nil)) + ("call" (:*unnamed* nil :arguments ("generator_expression" "argument_list") :function ("primary_expression"))) + ("case_clause" (:*unnamed* ("case_pattern") :consequence ("block") :guard ("if_clause"))) + ("case_pattern" (:*unnamed* ("false" "as_pattern" "dict_pattern" "float" "list_pattern" "integer" "complex_pattern" "dotted_name" "tuple_pattern" "union_pattern" "concatenated_string" "splat_pattern" "true" "none" "string" "keyword_pattern" "class_pattern"))) + ("chevron" (:*unnamed* ("expression"))) + ("class_definition" (:*unnamed* nil :body ("block") :name ("identifier") :superclasses ("argument_list") :type_parameters ("type_parameter"))) + ("class_pattern" (:*unnamed* ("dotted_name" "case_pattern"))) + ("comparison_operator" (:*unnamed* ("primary_expression") :operators nil)) + ("complex_pattern" (:*unnamed* ("float" "integer"))) + ("concatenated_string" (:*unnamed* ("string"))) + ("conditional_expression" (:*unnamed* ("expression"))) + ("constrained_type" (:*unnamed* ("type"))) + ("continue_statement" (:*unnamed* nil)) + ("decorated_definition" (:*unnamed* ("decorator") :definition ("class_definition" "function_definition"))) + ("decorator" (:*unnamed* ("expression"))) + ("default_parameter" (:*unnamed* nil :name ("identifier" "tuple_pattern") :value ("expression"))) + ("delete_statement" (:*unnamed* ("expression" "expression_list"))) + ("dict_pattern" (:*unnamed* ("splat_pattern") :key ("false" "dict_pattern" "complex_pattern" "dotted_name" "tuple_pattern" "float" "concatenated_string" "splat_pattern" "list_pattern" "none" "string" "true" "union_pattern" "class_pattern" "integer") :value ("case_pattern"))) + ("dictionary" (:*unnamed* ("dictionary_splat" "pair"))) + ("dictionary_comprehension" (:*unnamed* ("if_clause" "for_in_clause") :body ("pair"))) + ("dictionary_splat" (:*unnamed* ("expression"))) + ("dictionary_splat_pattern" (:*unnamed* ("attribute" "identifier" "subscript"))) + ("dotted_name" (:*unnamed* ("identifier"))) + ("elif_clause" (:*unnamed* nil :condition ("expression") :consequence ("block"))) + ("else_clause" (:*unnamed* nil :body ("block"))) + ("except_clause" (:*unnamed* ("expression" "block"))) + ("except_group_clause" (:*unnamed* ("expression" "block"))) + ("exec_statement" (:*unnamed* ("expression") :code ("identifier" "string"))) + ("expression_list" (:*unnamed* ("expression"))) + ("expression_statement" (:*unnamed* ("assignment" "expression" "augmented_assignment" "yield"))) + ("finally_clause" (:*unnamed* ("block"))) + ("for_in_clause" (:*unnamed* nil :left ("pattern_list" "pattern") :right ("expression"))) + ("for_statement" (:*unnamed* nil :alternative ("else_clause") :body ("block") :left ("pattern_list" "pattern") :right ("expression" "expression_list"))) + ("format_expression" (:*unnamed* nil :expression ("expression" "expression_list" "pattern_list" "yield") :format_specifier ("format_specifier") :type_conversion ("type_conversion"))) + ("format_specifier" (:*unnamed* ("format_expression"))) + ("function_definition" (:*unnamed* nil :body ("block") :name ("identifier") :parameters ("parameters") :return_type ("type") :type_parameters ("type_parameter"))) + ("future_import_statement" (:*unnamed* nil :name ("dotted_name" "aliased_import"))) + ("generator_expression" (:*unnamed* ("if_clause" "for_in_clause") :body ("expression"))) + ("generic_type" (:*unnamed* ("identifier" "type_parameter"))) + ("global_statement" (:*unnamed* ("identifier"))) + ("if_clause" (:*unnamed* ("expression"))) + ("if_statement" (:*unnamed* nil :alternative ("elif_clause" "else_clause") :condition ("expression") :consequence ("block"))) + ("import_from_statement" (:*unnamed* ("wildcard_import") :module_name ("relative_import" "dotted_name") :name ("dotted_name" "aliased_import"))) + ("import_prefix" (:*unnamed* nil)) + ("import_statement" (:*unnamed* nil :name ("dotted_name" "aliased_import"))) + ("interpolation" (:*unnamed* nil :expression ("expression" "expression_list" "pattern_list" "yield") :format_specifier ("format_specifier") :type_conversion ("type_conversion"))) + ("keyword_argument" (:*unnamed* nil :name ("identifier") :value ("expression"))) + ("keyword_pattern" (:*unnamed* ("false" "dict_pattern" "float" "list_pattern" "integer" "complex_pattern" "dotted_name" "tuple_pattern" "union_pattern" "concatenated_string" "splat_pattern" "true" "none" "string" "identifier" "class_pattern"))) + ("keyword_separator" (:*unnamed* nil)) + ("lambda" (:*unnamed* nil :body ("expression") :parameters ("lambda_parameters"))) + ("lambda_parameters" (:*unnamed* ("parameter"))) + ("list" (:*unnamed* ("list_splat" "expression" "parenthesized_list_splat" "yield"))) + ("list_comprehension" (:*unnamed* ("if_clause" "for_in_clause") :body ("expression"))) + ("list_pattern" (:*unnamed* ("pattern" "case_pattern"))) + ("list_splat" (:*unnamed* ("attribute" "expression" "identifier" "subscript"))) + ("list_splat_pattern" (:*unnamed* ("attribute" "identifier" "subscript"))) + ("match_statement" (:*unnamed* nil :body ("block") :subject ("expression"))) + ("member_type" (:*unnamed* ("identifier" "type"))) + ("module" (:*unnamed* ("assert_statement" "break_statement" "match_statement" "import_statement" "future_import_statement" "expression_statement" "with_statement" "if_statement" "global_statement" "continue_statement" "exec_statement" "pass_statement" "type_alias_statement" "try_statement" "nonlocal_statement" "class_definition" "for_statement" "delete_statement" "raise_statement" "import_from_statement" "while_statement" "decorated_definition" "function_definition" "return_statement" "print_statement"))) + ("named_expression" (:*unnamed* nil :name ("identifier") :value ("expression"))) + ("nonlocal_statement" (:*unnamed* ("identifier"))) + ("not_operator" (:*unnamed* nil :argument ("expression"))) + ("pair" (:*unnamed* nil :key ("expression") :value ("expression"))) + ("parameters" (:*unnamed* ("parameter"))) + ("parenthesized_expression" (:*unnamed* ("list_splat" "expression" "parenthesized_expression" "yield"))) + ("parenthesized_list_splat" (:*unnamed* ("list_splat" "parenthesized_expression"))) + ("pass_statement" (:*unnamed* nil)) + ("pattern_list" (:*unnamed* ("pattern"))) + ("positional_separator" (:*unnamed* nil)) + ("print_statement" (:*unnamed* ("chevron") :argument ("expression"))) + ("raise_statement" (:*unnamed* ("expression" "expression_list") :cause ("expression"))) + ("relative_import" (:*unnamed* ("import_prefix" "dotted_name"))) + ("return_statement" (:*unnamed* ("expression" "expression_list"))) + ("set" (:*unnamed* ("list_splat" "expression" "parenthesized_list_splat" "yield"))) + ("set_comprehension" (:*unnamed* ("if_clause" "for_in_clause") :body ("expression"))) + ("slice" (:*unnamed* ("expression"))) + ("splat_pattern" (:*unnamed* ("identifier"))) + ("splat_type" (:*unnamed* ("identifier"))) + ("string" (:*unnamed* ("string_content" "string_end" "string_start" "interpolation"))) + ("string_content" (:*unnamed* ("escape_interpolation" "escape_sequence"))) + ("subscript" (:*unnamed* nil :subscript ("expression" "slice") :value ("primary_expression"))) + ("try_statement" (:*unnamed* ("finally_clause" "except_clause" "except_group_clause" "else_clause") :body ("block"))) + ("tuple" (:*unnamed* ("list_splat" "expression" "parenthesized_list_splat" "yield"))) + ("tuple_pattern" (:*unnamed* ("pattern" "case_pattern"))) + ("type" (:*unnamed* ("expression" "constrained_type" "generic_type" "union_type" "splat_type" "member_type"))) + ("type_alias_statement" (:*unnamed* ("type"))) + ("type_parameter" (:*unnamed* ("type"))) + ("typed_default_parameter" (:*unnamed* nil :name ("identifier") :type ("type") :value ("expression"))) + ("typed_parameter" (:*unnamed* ("identifier" "list_splat_pattern" "dictionary_splat_pattern") :type ("type"))) + ("unary_operator" (:*unnamed* nil :argument ("primary_expression") :operator nil)) + ("union_pattern" (:*unnamed* ("false" "dict_pattern" "complex_pattern" "dotted_name" "tuple_pattern" "float" "concatenated_string" "splat_pattern" "list_pattern" "none" "string" "true" "union_pattern" "class_pattern" "integer"))) + ("union_type" (:*unnamed* ("type"))) + ("while_statement" (:*unnamed* nil :alternative ("else_clause") :body ("block") :condition ("expression"))) + ("wildcard_import" (:*unnamed* nil)) + ("with_clause" (:*unnamed* ("with_item"))) + ("with_item" (:*unnamed* nil :value ("expression"))) + ("with_statement" (:*unnamed* ("with_clause") :body ("block"))) + ("yield" (:*unnamed* ("expression" "expression_list"))) + ("comment" (:*unnamed* nil)) + ("ellipsis" (:*unnamed* nil)) + ("escape_interpolation" (:*unnamed* nil)) + ("escape_sequence" (:*unnamed* nil)) + ("false" (:*unnamed* nil)) + ("float" (:*unnamed* nil)) + ("identifier" (:*unnamed* nil)) + ("integer" (:*unnamed* nil)) + ("line_continuation" (:*unnamed* nil)) + ("none" (:*unnamed* nil)) + ("string_end" (:*unnamed* nil)) + ("string_start" (:*unnamed* nil)) + ("true" (:*unnamed* nil)) + ("type_conversion" (:*unnamed* nil)) +)) ;; END Production rules for python ;; START Inverse production rules for python -(defconst combobulate-rules-python-inverse - '(("aliased_import" ("future_import_statement" "import_statement" "import_from_statement")) - ("argument_list" ("call" "class_definition")) - ("as_pattern" ("case_pattern" "expression")) - ("as_pattern_target" ("as_pattern")) - ("assert_statement" ("module" "_simple_statement" "block")) - ("assignment" ("augmented_assignment" "expression_statement" "assignment")) - ("attribute" ("primary_expression" "list_splat_pattern" "pattern" "list_splat" "dictionary_splat_pattern")) - ("augmented_assignment" ("augmented_assignment" "expression_statement" "assignment")) - ("await" ("primary_expression")) - ("binary_operator" ("primary_expression")) - ("block" ("function_definition" "while_statement" "finally_clause" "for_statement" "with_statement" "try_statement" "match_statement" "if_statement" "else_clause" "except_group_clause" "class_definition" "except_clause" "case_clause" "elif_clause")) - ("boolean_operator" ("expression")) - ("break_statement" ("module" "_simple_statement" "block")) - ("call" ("primary_expression")) - ("case_clause" ("block")) - ("case_pattern" ("tuple_pattern" "as_pattern" "class_pattern" "list_pattern" "dict_pattern" "case_clause")) - ("chevron" ("print_statement")) - ("class_definition" ("_compound_statement" "module" "decorated_definition" "block")) - ("class_pattern" ("case_pattern" "union_pattern" "dict_pattern" "keyword_pattern")) - ("comparison_operator" ("expression")) - ("complex_pattern" ("case_pattern" "union_pattern" "dict_pattern" "keyword_pattern")) - ("concatenated_string" ("case_pattern" "primary_expression" "keyword_pattern" "union_pattern" "dict_pattern")) - ("conditional_expression" ("expression")) - ("constrained_type" ("type")) - ("continue_statement" ("module" "_simple_statement" "block")) - ("decorated_definition" ("_compound_statement" "module" "block")) - ("decorator" ("decorated_definition")) - ("default_parameter" ("parameter")) - ("delete_statement" ("module" "_simple_statement" "block")) - ("dict_pattern" ("case_pattern" "union_pattern" "dict_pattern" "keyword_pattern")) - ("dictionary" ("primary_expression")) - ("dictionary_comprehension" ("primary_expression")) - ("dictionary_splat" ("dictionary" "argument_list")) - ("dictionary_splat_pattern" ("parameter" "typed_parameter")) - ("dotted_name" ("aliased_import" "case_pattern" "keyword_pattern" "class_pattern" "future_import_statement" "import_statement" "relative_import" "union_pattern" "dict_pattern" "import_from_statement")) - ("elif_clause" ("if_statement")) - ("ellipsis" ("primary_expression")) - ("else_clause" ("for_statement" "while_statement" "try_statement" "if_statement")) - ("escape_interpolation" ("string_content")) - ("escape_sequence" ("string_content")) - ("except_clause" ("try_statement")) - ("except_group_clause" ("try_statement")) - ("exec_statement" ("module" "_simple_statement" "block")) - ("expression" ("augmented_assignment" "chevron" "parenthesized_expression" "tuple" "type" "delete_statement" "if_statement" "except_group_clause" "return_statement" "boolean_operator" "conditional_expression" "dictionary_splat" "print_statement" "interpolation" "list_comprehension" "set_comprehension" "expression_list" "match_statement" "assignment" "pair" "lambda" "except_clause" "if_clause" "exec_statement" "raise_statement" "format_expression" "assert_statement" "not_operator" "typed_default_parameter" "for_statement" "list" "keyword_argument" "slice" "default_parameter" "with_item" "elif_clause" "argument_list" "yield" "while_statement" "generator_expression" "as_pattern" "for_in_clause" "subscript" "expression_statement" "decorator" "list_splat" "named_expression" "set")) - ("expression_list" ("raise_statement" "format_expression" "augmented_assignment" "for_statement" "delete_statement" "assignment" "return_statement" "yield" "interpolation")) - ("expression_statement" ("module" "_simple_statement" "block")) - ("false" ("case_pattern" "primary_expression" "keyword_pattern" "union_pattern" "dict_pattern")) - ("finally_clause" ("try_statement")) - ("float" ("case_pattern" "primary_expression" "keyword_pattern" "complex_pattern" "union_pattern" "dict_pattern")) - ("for_in_clause" ("generator_expression" "set_comprehension" "dictionary_comprehension" "list_comprehension")) - ("for_statement" ("_compound_statement" "module" "block")) - ("format_expression" ("format_specifier")) - ("format_specifier" ("format_expression" "interpolation")) - ("function_definition" ("_compound_statement" "module" "decorated_definition" "block")) - ("future_import_statement" ("module" "_simple_statement" "block")) - ("generator_expression" ("primary_expression" "call")) - ("generic_type" ("type")) - ("global_statement" ("module" "_simple_statement" "block")) - ("identifier" ("attribute" "generic_type" "aliased_import" "splat_pattern" "dictionary_splat_pattern" "global_statement" "exec_statement" "list_splat_pattern" "function_definition" "typed_parameter" "typed_default_parameter" "dotted_name" "keyword_argument" "class_definition" "default_parameter" "primary_expression" "pattern" "as_pattern" "keyword_pattern" "parameter" "list_splat" "nonlocal_statement" "named_expression" "member_type" "splat_type")) - ("if_clause" ("set_comprehension" "generator_expression" "dictionary_comprehension" "case_clause" "list_comprehension")) - ("if_statement" ("_compound_statement" "module" "block")) - ("import_from_statement" ("module" "_simple_statement" "block")) - ("import_prefix" ("relative_import")) - ("import_statement" ("module" "_simple_statement" "block")) - ("integer" ("case_pattern" "primary_expression" "keyword_pattern" "complex_pattern" "union_pattern" "dict_pattern")) - ("interpolation" ("string")) - ("keyword_argument" ("argument_list")) - ("keyword_pattern" ("case_pattern")) - ("keyword_separator" ("parameter")) - ("lambda" ("expression")) - ("lambda_parameters" ("lambda")) - ("list" ("primary_expression")) - ("list_comprehension" ("primary_expression")) - ("list_pattern" ("case_pattern" "pattern" "keyword_pattern" "union_pattern" "dict_pattern")) - ("list_splat" ("primary_expression" "parenthesized_expression" "tuple" "list" "parenthesized_list_splat" "set" "argument_list")) - ("list_splat_pattern" ("parameter" "typed_parameter" "pattern")) - ("match_statement" ("_compound_statement" "module" "block")) - ("member_type" ("type")) - ("named_expression" ("expression")) - ("none" ("case_pattern" "primary_expression" "keyword_pattern" "union_pattern" "dict_pattern")) - ("nonlocal_statement" ("module" "_simple_statement" "block")) - ("not_operator" ("expression")) - ("pair" ("dictionary" "dictionary_comprehension")) - ("parameter" ("parameters" "lambda_parameters")) - ("parameters" ("function_definition")) - ("parenthesized_expression" ("parenthesized_expression" "primary_expression" "argument_list" "parenthesized_list_splat")) - ("parenthesized_list_splat" ("tuple" "list" "set")) - ("pass_statement" ("module" "_simple_statement" "block")) - ("pattern" ("augmented_assignment" "tuple_pattern" "for_in_clause" "for_statement" "list_pattern" "assignment" "pattern_list")) - ("pattern_list" ("augmented_assignment" "format_expression" "for_in_clause" "for_statement" "assignment" "interpolation")) - ("positional_separator" ("parameter")) - ("primary_expression" ("expression" "subscript" "attribute" "await" "comparison_operator" "binary_operator" "call" "unary_operator")) - ("print_statement" ("module" "_simple_statement" "block")) - ("raise_statement" ("module" "_simple_statement" "block")) - ("relative_import" ("import_from_statement")) - ("return_statement" ("module" "_simple_statement" "block")) - ("set" ("primary_expression")) - ("set_comprehension" ("primary_expression")) - ("slice" ("subscript")) - ("splat_pattern" ("case_pattern" "union_pattern" "dict_pattern" "keyword_pattern")) - ("splat_type" ("type")) - ("string" ("case_pattern" "primary_expression" "keyword_pattern" "union_pattern" "dict_pattern" "concatenated_string" "exec_statement")) - ("string_content" ("string")) - ("string_end" ("string")) - ("string_start" ("string")) - ("subscript" ("primary_expression" "list_splat_pattern" "pattern" "list_splat" "dictionary_splat_pattern")) - ("true" ("case_pattern" "primary_expression" "keyword_pattern" "union_pattern" "dict_pattern")) - ("try_statement" ("_compound_statement" "module" "block")) - ("tuple" ("primary_expression")) - ("tuple_pattern" ("case_pattern" "pattern" "keyword_pattern" "parameter" "union_pattern" "dict_pattern" "default_parameter")) - ("type" ("constrained_type" "function_definition" "typed_parameter" "type_alias_statement" "typed_default_parameter" "assignment" "member_type" "union_type" "type_parameter")) - ("type_alias_statement" ("module" "_simple_statement" "block")) - ("type_conversion" ("format_expression" "interpolation")) - ("type_parameter" ("generic_type" "function_definition" "class_definition")) - ("typed_default_parameter" ("parameter")) - ("typed_parameter" ("parameter")) - ("unary_operator" ("primary_expression")) - ("union_pattern" ("case_pattern" "union_pattern" "dict_pattern" "keyword_pattern")) - ("union_type" ("type")) - ("while_statement" ("_compound_statement" "module" "block")) - ("wildcard_import" ("import_from_statement")) - ("with_clause" ("with_statement")) - ("with_item" ("with_clause")) - ("with_statement" ("_compound_statement" "module" "block")) - ("yield" ("format_expression" "augmented_assignment" "parenthesized_expression" "tuple" "expression_statement" "list" "assignment" "set" "interpolation")) - ) - ) +(defconst combobulate-rules-python-inverse + '(("aliased_import" ("future_import_statement" "import_from_statement" "import_statement")) + ("argument_list" ("call" "class_definition")) + ("as_pattern" ("expression" "case_pattern")) + ("as_pattern_target" ("as_pattern")) + ("assert_statement" ("_simple_statement" "module" "block")) + ("assignment" ("assignment" "expression_statement" "augmented_assignment")) + ("attribute" ("primary_expression" "list_splat_pattern" "pattern" "list_splat" "dictionary_splat_pattern")) + ("augmented_assignment" ("assignment" "expression_statement" "augmented_assignment")) + ("await" ("primary_expression")) + ("binary_operator" ("primary_expression")) + ("block" ("case_clause" "except_clause" "class_definition" "for_statement" "match_statement" "except_group_clause" "if_statement" "while_statement" "function_definition" "with_statement" "finally_clause" "elif_clause" "try_statement" "else_clause")) + ("boolean_operator" ("expression")) + ("break_statement" ("_simple_statement" "module" "block")) + ("call" ("primary_expression")) + ("case_clause" ("block")) + ("case_pattern" ("as_pattern" "dict_pattern" "case_clause" "tuple_pattern" "list_pattern" "class_pattern")) + ("chevron" ("print_statement")) + ("class_definition" ("block" "decorated_definition" "module" "_compound_statement")) + ("class_pattern" ("dict_pattern" "keyword_pattern" "union_pattern" "case_pattern")) + ("comparison_operator" ("expression")) + ("complex_pattern" ("dict_pattern" "keyword_pattern" "union_pattern" "case_pattern")) + ("concatenated_string" ("dict_pattern" "union_pattern" "case_pattern" "primary_expression" "keyword_pattern")) + ("conditional_expression" ("expression")) + ("constrained_type" ("type")) + ("continue_statement" ("_simple_statement" "module" "block")) + ("decorated_definition" ("block" "module" "_compound_statement")) + ("decorator" ("decorated_definition")) + ("default_parameter" ("parameter")) + ("delete_statement" ("_simple_statement" "module" "block")) + ("dict_pattern" ("dict_pattern" "keyword_pattern" "union_pattern" "case_pattern")) + ("dictionary" ("primary_expression")) + ("dictionary_comprehension" ("primary_expression")) + ("dictionary_splat" ("dictionary" "argument_list")) + ("dictionary_splat_pattern" ("typed_parameter" "parameter")) + ("dotted_name" ("dict_pattern" "import_statement" "case_pattern" "future_import_statement" "aliased_import" "relative_import" "import_from_statement" "union_pattern" "keyword_pattern" "class_pattern")) + ("elif_clause" ("if_statement")) + ("ellipsis" ("primary_expression")) + ("else_clause" ("if_statement" "while_statement" "for_statement" "try_statement")) + ("escape_interpolation" ("string_content")) + ("escape_sequence" ("string_content")) + ("except_clause" ("try_statement")) + ("except_group_clause" ("try_statement")) + ("exec_statement" ("_simple_statement" "module" "block")) + ("expression" ("dictionary_splat" "match_statement" "except_group_clause" "expression_list" "set" "parenthesized_expression" "chevron" "for_statement" "interpolation" "with_item" "typed_default_parameter" "yield" "assignment" "augmented_assignment" "return_statement" "decorator" "print_statement" "list_splat" "slice" "keyword_argument" "elif_clause" "subscript" "assert_statement" "generator_expression" "as_pattern" "argument_list" "default_parameter" "list_comprehension" "expression_statement" "if_statement" "boolean_operator" "lambda" "named_expression" "exec_statement" "format_expression" "pair" "type" "if_clause" "not_operator" "tuple" "except_clause" "delete_statement" "raise_statement" "conditional_expression" "while_statement" "set_comprehension" "list" "for_in_clause")) + ("expression_list" ("for_statement" "delete_statement" "interpolation" "raise_statement" "yield" "assignment" "augmented_assignment" "format_expression" "return_statement")) + ("expression_statement" ("_simple_statement" "module" "block")) + ("false" ("dict_pattern" "union_pattern" "case_pattern" "primary_expression" "keyword_pattern")) + ("finally_clause" ("try_statement")) + ("float" ("dict_pattern" "complex_pattern" "union_pattern" "case_pattern" "primary_expression" "keyword_pattern")) + ("for_in_clause" ("generator_expression" "set_comprehension" "list_comprehension" "dictionary_comprehension")) + ("for_statement" ("block" "module" "_compound_statement")) + ("format_expression" ("format_specifier")) + ("format_specifier" ("format_expression" "interpolation")) + ("function_definition" ("block" "decorated_definition" "module" "_compound_statement")) + ("future_import_statement" ("_simple_statement" "module" "block")) + ("generator_expression" ("primary_expression" "call")) + ("generic_type" ("type")) + ("global_statement" ("_simple_statement" "module" "block")) + ("identifier" ("global_statement" "list_splat_pattern" "splat_type" "class_definition" "typed_default_parameter" "parameter" "pattern" "generic_type" "list_splat" "keyword_argument" "dictionary_splat_pattern" "as_pattern" "default_parameter" "aliased_import" "typed_parameter" "named_expression" "exec_statement" "attribute" "nonlocal_statement" "dotted_name" "splat_pattern" "primary_expression" "function_definition" "keyword_pattern" "member_type")) + ("if_clause" ("generator_expression" "case_clause" "list_comprehension" "set_comprehension" "dictionary_comprehension")) + ("if_statement" ("block" "module" "_compound_statement")) + ("import_from_statement" ("_simple_statement" "module" "block")) + ("import_prefix" ("relative_import")) + ("import_statement" ("_simple_statement" "module" "block")) + ("integer" ("dict_pattern" "complex_pattern" "union_pattern" "case_pattern" "primary_expression" "keyword_pattern")) + ("interpolation" ("string")) + ("keyword_argument" ("argument_list")) + ("keyword_pattern" ("case_pattern")) + ("keyword_separator" ("parameter")) + ("lambda" ("expression")) + ("lambda_parameters" ("lambda")) + ("list" ("primary_expression")) + ("list_comprehension" ("primary_expression")) + ("list_pattern" ("dict_pattern" "union_pattern" "case_pattern" "keyword_pattern" "pattern")) + ("list_splat" ("parenthesized_expression" "tuple" "argument_list" "primary_expression" "parenthesized_list_splat" "list" "set")) + ("list_splat_pattern" ("typed_parameter" "pattern" "parameter")) + ("match_statement" ("block" "module" "_compound_statement")) + ("member_type" ("type")) + ("named_expression" ("expression")) + ("none" ("dict_pattern" "union_pattern" "case_pattern" "primary_expression" "keyword_pattern")) + ("nonlocal_statement" ("_simple_statement" "module" "block")) + ("not_operator" ("expression")) + ("pair" ("dictionary" "dictionary_comprehension")) + ("parameter" ("lambda_parameters" "parameters")) + ("parameters" ("function_definition")) + ("parenthesized_expression" ("parenthesized_expression" "primary_expression" "parenthesized_list_splat" "argument_list")) + ("parenthesized_list_splat" ("list" "set" "tuple")) + ("pass_statement" ("_simple_statement" "module" "block")) + ("pattern" ("for_statement" "tuple_pattern" "list_pattern" "pattern_list" "assignment" "augmented_assignment" "for_in_clause")) + ("pattern_list" ("for_statement" "interpolation" "assignment" "augmented_assignment" "format_expression" "for_in_clause")) + ("positional_separator" ("parameter")) + ("primary_expression" ("expression" "comparison_operator" "unary_operator" "call" "await" "attribute" "binary_operator" "subscript")) + ("print_statement" ("_simple_statement" "module" "block")) + ("raise_statement" ("_simple_statement" "module" "block")) + ("relative_import" ("import_from_statement")) + ("return_statement" ("_simple_statement" "module" "block")) + ("set" ("primary_expression")) + ("set_comprehension" ("primary_expression")) + ("slice" ("subscript")) + ("splat_pattern" ("dict_pattern" "keyword_pattern" "union_pattern" "case_pattern")) + ("splat_type" ("type")) + ("string" ("dict_pattern" "union_pattern" "case_pattern" "concatenated_string" "primary_expression" "exec_statement" "keyword_pattern")) + ("string_content" ("string")) + ("string_end" ("string")) + ("string_start" ("string")) + ("subscript" ("primary_expression" "list_splat_pattern" "pattern" "list_splat" "dictionary_splat_pattern")) + ("true" ("dict_pattern" "union_pattern" "case_pattern" "primary_expression" "keyword_pattern")) + ("try_statement" ("block" "module" "_compound_statement")) + ("tuple" ("primary_expression")) + ("tuple_pattern" ("dict_pattern" "default_parameter" "union_pattern" "case_pattern" "parameter" "pattern" "keyword_pattern")) + ("type" ("typed_parameter" "typed_default_parameter" "type_alias_statement" "function_definition" "assignment" "type_parameter" "constrained_type" "union_type" "member_type")) + ("type_alias_statement" ("_simple_statement" "module" "block")) + ("type_conversion" ("format_expression" "interpolation")) + ("type_parameter" ("class_definition" "generic_type" "function_definition")) + ("typed_default_parameter" ("parameter")) + ("typed_parameter" ("parameter")) + ("unary_operator" ("primary_expression")) + ("union_pattern" ("dict_pattern" "keyword_pattern" "union_pattern" "case_pattern")) + ("union_type" ("type")) + ("while_statement" ("block" "module" "_compound_statement")) + ("wildcard_import" ("import_from_statement")) + ("with_clause" ("with_statement")) + ("with_item" ("with_clause")) + ("with_statement" ("block" "module" "_compound_statement")) + ("yield" ("parenthesized_expression" "tuple" "interpolation" "expression_statement" "assignment" "augmented_assignment" "format_expression" "list" "set")) + ) +) ;; END Inverse production rules for python ;; START All node types in python -(defconst combobulate-rules-python-types - '("_compound_statement" "_simple_statement" "aliased_import" "argument_list" "as_pattern" "as_pattern_target" "assert_statement" "assignment" "attribute" "augmented_assignment" "await" "binary_operator" "block" "boolean_operator" "break_statement" "call" "case_clause" "case_pattern" "chevron" "class_definition" "class_pattern" "comment" "comparison_operator" "complex_pattern" "concatenated_string" "conditional_expression" "constrained_type" "continue_statement" "decorated_definition" "decorator" "default_parameter" "delete_statement" "dict_pattern" "dictionary" "dictionary_comprehension" "dictionary_splat" "dictionary_splat_pattern" "dotted_name" "elif_clause" "ellipsis" "else_clause" "escape_interpolation" "escape_sequence" "except_clause" "except_group_clause" "exec_statement" "expression" "expression_list" "expression_statement" "false" "finally_clause" "float" "for_in_clause" "for_statement" "format_expression" "format_specifier" "function_definition" "future_import_statement" "generator_expression" "generic_type" "global_statement" "identifier" "if_clause" "if_statement" "import_from_statement" "import_prefix" "import_statement" "integer" "interpolation" "keyword_argument" "keyword_pattern" "keyword_separator" "lambda" "lambda_parameters" "line_continuation" "list" "list_comprehension" "list_pattern" "list_splat" "list_splat_pattern" "match_statement" "member_type" "module" "named_expression" "none" "nonlocal_statement" "not_operator" "pair" "parameter" "parameters" "parenthesized_expression" "parenthesized_list_splat" "pass_statement" "pattern" "pattern_list" "positional_separator" "primary_expression" "print_statement" "raise_statement" "relative_import" "return_statement" "set" "set_comprehension" "slice" "splat_pattern" "splat_type" "string" "string_content" "string_end" "string_start" "subscript" "true" "try_statement" "tuple" "tuple_pattern" "type" "type_alias_statement" "type_conversion" "type_parameter" "typed_default_parameter" "typed_parameter" "unary_operator" "union_pattern" "union_type" "while_statement" "wildcard_import" "with_clause" "with_item" "with_statement" "yield") - ) +(defconst combobulate-rules-python-types + '("_compound_statement" "_simple_statement" "aliased_import" "argument_list" "as_pattern" "as_pattern_target" "assert_statement" "assignment" "attribute" "augmented_assignment" "await" "binary_operator" "block" "boolean_operator" "break_statement" "call" "case_clause" "case_pattern" "chevron" "class_definition" "class_pattern" "comment" "comparison_operator" "complex_pattern" "concatenated_string" "conditional_expression" "constrained_type" "continue_statement" "decorated_definition" "decorator" "default_parameter" "delete_statement" "dict_pattern" "dictionary" "dictionary_comprehension" "dictionary_splat" "dictionary_splat_pattern" "dotted_name" "elif_clause" "ellipsis" "else_clause" "escape_interpolation" "escape_sequence" "except_clause" "except_group_clause" "exec_statement" "expression" "expression_list" "expression_statement" "false" "finally_clause" "float" "for_in_clause" "for_statement" "format_expression" "format_specifier" "function_definition" "future_import_statement" "generator_expression" "generic_type" "global_statement" "identifier" "if_clause" "if_statement" "import_from_statement" "import_prefix" "import_statement" "integer" "interpolation" "keyword_argument" "keyword_pattern" "keyword_separator" "lambda" "lambda_parameters" "line_continuation" "list" "list_comprehension" "list_pattern" "list_splat" "list_splat_pattern" "match_statement" "member_type" "module" "named_expression" "none" "nonlocal_statement" "not_operator" "pair" "parameter" "parameters" "parenthesized_expression" "parenthesized_list_splat" "pass_statement" "pattern" "pattern_list" "positional_separator" "primary_expression" "print_statement" "raise_statement" "relative_import" "return_statement" "set" "set_comprehension" "slice" "splat_pattern" "splat_type" "string" "string_content" "string_end" "string_start" "subscript" "true" "try_statement" "tuple" "tuple_pattern" "type" "type_alias_statement" "type_conversion" "type_parameter" "typed_default_parameter" "typed_parameter" "unary_operator" "union_pattern" "union_type" "while_statement" "wildcard_import" "with_clause" "with_item" "with_statement" "yield") +) ;; END All node types in python +;; START All supertypes in python +(defconst combobulate-rules-python-supertypes + '("_compound_statement" "_simple_statement" "expression" "parameter" "pattern" "primary_expression") +) +;; END All supertypes in python ;; START Production rules for c -(defconst combobulate-rules-c - '(("_abstract_declarator" (:*unnamed* ("abstract_function_declarator" "abstract_pointer_declarator" "abstract_array_declarator" "abstract_parenthesized_declarator"))) - ("_declarator" (:*unnamed* ("parenthesized_declarator" "attributed_declarator" "function_declarator" "identifier" "pointer_declarator" "array_declarator"))) - ("_expression" (:*unnamed* ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("_field_declarator" (:*unnamed* ("parenthesized_declarator" "attributed_declarator" "function_declarator" "array_declarator" "pointer_declarator" "field_identifier"))) - ("_statement" (:*unnamed* ("continue_statement" "for_statement" "seh_leave_statement" "if_statement" "do_statement" "seh_try_statement" "return_statement" "compound_statement" "case_statement" "while_statement" "attributed_statement" "expression_statement" "switch_statement" "break_statement" "goto_statement" "labeled_statement"))) - ("_type_declarator" (:*unnamed* ("type_identifier" "parenthesized_declarator" "attributed_declarator" "function_declarator" "array_declarator" "pointer_declarator" "primitive_type"))) - ("_type_specifier" (:*unnamed* ("type_identifier" "primitive_type" "enum_specifier" "sized_type_specifier" "macro_type_specifier" "struct_specifier" "union_specifier"))) - ("abstract_array_declarator" (:*unnamed* ("type_qualifier") :declarator ("abstract_function_declarator" "abstract_pointer_declarator" "abstract_array_declarator" "abstract_parenthesized_declarator") :size ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("abstract_function_declarator" (:declarator ("abstract_function_declarator" "abstract_pointer_declarator" "abstract_array_declarator" "abstract_parenthesized_declarator") :parameters ("parameter_list"))) - ("abstract_parenthesized_declarator" (:*unnamed* ("abstract_function_declarator" "abstract_pointer_declarator" "abstract_array_declarator" "abstract_parenthesized_declarator"))) - ("abstract_pointer_declarator" (:*unnamed* ("type_qualifier") :declarator ("abstract_function_declarator" "abstract_pointer_declarator" "abstract_array_declarator" "abstract_parenthesized_declarator"))) - ("alignof_expression" (:type ("type_descriptor"))) - ("argument_list" (:*unnamed* ("offsetof_expression" "identifier" "preproc_defined" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "compound_statement" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("array_declarator" (:*unnamed* ("type_qualifier") :declarator ("type_identifier" "parenthesized_declarator" "attributed_declarator" "function_declarator" "identifier" "pointer_declarator" "primitive_type" "field_identifier" "array_declarator") :size ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("assignment_expression" (:left ("identifier" "call_expression" "pointer_expression" "parenthesized_expression" "field_expression" "subscript_expression") :operator nil :right ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("attribute" (:*unnamed* ("argument_list") :name ("identifier") :prefix ("identifier"))) - ("attribute_declaration" (:*unnamed* ("attribute"))) - ("attribute_specifier" (:*unnamed* ("argument_list"))) - ("attributed_declarator" (:*unnamed* ("type_identifier" "parenthesized_declarator" "attributed_declarator" "function_declarator" "identifier" "pointer_declarator" "primitive_type" "field_identifier" "array_declarator" "attribute_declaration"))) - ("attributed_statement" (:*unnamed* ("continue_statement" "for_statement" "seh_leave_statement" "if_statement" "do_statement" "seh_try_statement" "return_statement" "attribute_declaration" "compound_statement" "case_statement" "while_statement" "attributed_statement" "expression_statement" "switch_statement" "break_statement" "goto_statement" "labeled_statement"))) - ("binary_expression" (:left ("offsetof_expression" "identifier" "preproc_defined" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression") :operator nil :right ("offsetof_expression" "identifier" "preproc_defined" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("bitfield_clause" (:*unnamed* ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("call_expression" (:arguments ("argument_list") :function ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("case_statement" (:*unnamed* ("continue_statement" "for_statement" "seh_leave_statement" "if_statement" "do_statement" "seh_try_statement" "declaration" "return_statement" "compound_statement" "type_definition" "while_statement" "attributed_statement" "expression_statement" "switch_statement" "break_statement" "goto_statement" "labeled_statement") :value ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("cast_expression" (:type ("type_descriptor") :value ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("char_literal" (:*unnamed* ("escape_sequence" "character"))) - ("comma_expression" (:left ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression") :right ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "comma_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("compound_literal_expression" (:type ("type_descriptor") :value ("initializer_list"))) - ("compound_statement" (:*unnamed* ("continue_statement" "preproc_if" "seh_leave_statement" "if_statement" "do_statement" "union_specifier" "return_statement" "compound_statement" "preproc_ifdef" "case_statement" "type_identifier" "attributed_statement" "switch_statement" "break_statement" "macro_type_specifier" "struct_specifier" "preproc_call" "labeled_statement" "linkage_specification" "preproc_def" "preproc_function_def" "function_definition" "enum_specifier" "for_statement" "seh_try_statement" "declaration" "type_definition" "while_statement" "primitive_type" "expression_statement" "preproc_include" "goto_statement" "sized_type_specifier"))) - ("concatenated_string" (:*unnamed* ("string_literal" "identifier"))) - ("conditional_expression" (:alternative ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression") :condition ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression") :consequence ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("declaration" (:*unnamed* ("attribute_specifier" "ms_declspec_modifier" "storage_class_specifier" "attribute_declaration" "type_qualifier") :declarator ("parenthesized_declarator" "attributed_declarator" "function_declarator" "identifier" "pointer_declarator" "gnu_asm_expression" "array_declarator" "init_declarator") :type ("type_identifier" "primitive_type" "enum_specifier" "sized_type_specifier" "macro_type_specifier" "struct_specifier" "union_specifier"))) - ("declaration_list" (:*unnamed* ("continue_statement" "preproc_if" "seh_leave_statement" "if_statement" "do_statement" "union_specifier" "return_statement" "compound_statement" "preproc_ifdef" "case_statement" "type_identifier" "attributed_statement" "switch_statement" "break_statement" "macro_type_specifier" "struct_specifier" "preproc_call" "labeled_statement" "linkage_specification" "preproc_def" "preproc_function_def" "function_definition" "enum_specifier" "for_statement" "seh_try_statement" "declaration" "type_definition" "while_statement" "primitive_type" "expression_statement" "preproc_include" "goto_statement" "sized_type_specifier"))) - ("do_statement" (:body ("continue_statement" "for_statement" "seh_leave_statement" "if_statement" "do_statement" "seh_try_statement" "return_statement" "compound_statement" "case_statement" "while_statement" "attributed_statement" "expression_statement" "switch_statement" "break_statement" "goto_statement" "labeled_statement") :condition ("parenthesized_expression"))) - ("else_clause" (:*unnamed* ("continue_statement" "for_statement" "seh_leave_statement" "if_statement" "do_statement" "seh_try_statement" "return_statement" "compound_statement" "case_statement" "while_statement" "attributed_statement" "expression_statement" "switch_statement" "break_statement" "goto_statement" "labeled_statement"))) - ("enum_specifier" (:*unnamed* ("attribute_specifier") :body ("enumerator_list") :name ("type_identifier") :underlying_type ("primitive_type"))) - ("enumerator" (:name ("identifier") :value ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("enumerator_list" (:*unnamed* ("enumerator"))) - ("expression_statement" (:*unnamed* ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "comma_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("field_declaration" (:*unnamed* ("attribute_specifier" "ms_declspec_modifier" "storage_class_specifier" "bitfield_clause" "attribute_declaration" "type_qualifier") :declarator ("parenthesized_declarator" "attributed_declarator" "function_declarator" "array_declarator" "pointer_declarator" "field_identifier") :type ("type_identifier" "primitive_type" "enum_specifier" "sized_type_specifier" "macro_type_specifier" "struct_specifier" "union_specifier"))) - ("field_declaration_list" (:*unnamed* ("preproc_function_def" "preproc_if" "field_declaration" "preproc_ifdef" "preproc_def" "preproc_call"))) - ("field_designator" (:*unnamed* ("field_identifier"))) - ("field_expression" (:argument ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression") :field ("field_identifier") :operator nil)) - ("for_statement" (:body ("continue_statement" "for_statement" "seh_leave_statement" "if_statement" "do_statement" "seh_try_statement" "return_statement" "compound_statement" "case_statement" "while_statement" "attributed_statement" "expression_statement" "switch_statement" "break_statement" "goto_statement" "labeled_statement") :condition ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "comma_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression") :initializer ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "declaration" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "comma_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression") :update ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "comma_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("function_declarator" (:*unnamed* ("attribute_specifier" "gnu_asm_expression") :declarator ("type_identifier" "parenthesized_declarator" "attributed_declarator" "function_declarator" "identifier" "pointer_declarator" "primitive_type" "field_identifier" "array_declarator") :parameters ("parameter_list"))) - ("function_definition" (:*unnamed* ("attribute_specifier" "ms_declspec_modifier" "declaration" "attribute_declaration" "storage_class_specifier" "type_qualifier" "ms_call_modifier") :body ("compound_statement") :declarator ("parenthesized_declarator" "attributed_declarator" "function_declarator" "identifier" "pointer_declarator" "array_declarator") :type ("type_identifier" "primitive_type" "enum_specifier" "sized_type_specifier" "macro_type_specifier" "struct_specifier" "union_specifier"))) - ("generic_expression" (:*unnamed* ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "type_descriptor" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("gnu_asm_clobber_list" (:register ("string_literal"))) - ("gnu_asm_expression" (:*unnamed* ("gnu_asm_qualifier") :assembly_code ("string_literal" "concatenated_string") :clobbers ("gnu_asm_clobber_list") :goto_labels ("gnu_asm_goto_list") :input_operands ("gnu_asm_input_operand_list") :output_operands ("gnu_asm_output_operand_list"))) - ("gnu_asm_goto_list" (:label ("identifier"))) - ("gnu_asm_input_operand" (:constraint ("string_literal") :symbol ("identifier") :value ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("gnu_asm_input_operand_list" (:operand ("gnu_asm_input_operand"))) - ("gnu_asm_output_operand" (:constraint ("string_literal") :symbol ("identifier") :value ("identifier"))) - ("gnu_asm_output_operand_list" (:operand ("gnu_asm_output_operand"))) - ("goto_statement" (:label ("statement_identifier"))) - ("if_statement" (:alternative ("else_clause") :condition ("parenthesized_expression") :consequence ("continue_statement" "for_statement" "seh_leave_statement" "if_statement" "do_statement" "seh_try_statement" "return_statement" "compound_statement" "case_statement" "while_statement" "attributed_statement" "expression_statement" "switch_statement" "break_statement" "goto_statement" "labeled_statement"))) - ("init_declarator" (:declarator ("parenthesized_declarator" "attributed_declarator" "function_declarator" "identifier" "pointer_declarator" "array_declarator") :value ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "initializer_list" "field_expression" "unary_expression"))) - ("initializer_list" (:*unnamed* ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "initializer_pair" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "initializer_list" "field_expression" "unary_expression"))) - ("initializer_pair" (:designator ("field_designator" "subscript_designator") :value ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "initializer_list" "field_expression" "unary_expression"))) - ("labeled_statement" (:*unnamed* ("continue_statement" "for_statement" "seh_leave_statement" "if_statement" "do_statement" "seh_try_statement" "return_statement" "compound_statement" "case_statement" "while_statement" "attributed_statement" "expression_statement" "switch_statement" "break_statement" "goto_statement" "labeled_statement") :label ("statement_identifier"))) - ("linkage_specification" (:body ("declaration" "function_definition" "declaration_list") :value ("string_literal"))) - ("macro_type_specifier" (:name ("identifier") :type ("type_descriptor"))) - ("ms_based_modifier" (:*unnamed* ("argument_list"))) - ("ms_declspec_modifier" (:*unnamed* ("identifier"))) - ("ms_pointer_modifier" (:*unnamed* ("ms_unaligned_ptr_modifier" "ms_signed_ptr_modifier" "ms_unsigned_ptr_modifier" "ms_restrict_modifier"))) - ("offsetof_expression" (:member ("field_identifier") :type ("type_descriptor"))) - ("parameter_declaration" (:*unnamed* ("attribute_specifier" "ms_declspec_modifier" "storage_class_specifier" "attribute_declaration" "type_qualifier") :declarator ("parenthesized_declarator" "attributed_declarator" "function_declarator" "abstract_pointer_declarator" "abstract_parenthesized_declarator" "identifier" "pointer_declarator" "abstract_array_declarator" "abstract_function_declarator" "array_declarator") :type ("type_identifier" "primitive_type" "enum_specifier" "sized_type_specifier" "macro_type_specifier" "struct_specifier" "union_specifier"))) - ("parameter_list" (:*unnamed* ("variadic_parameter" "identifier" "parameter_declaration"))) - ("parenthesized_declarator" (:*unnamed* ("type_identifier" "parenthesized_declarator" "attributed_declarator" "function_declarator" "identifier" "pointer_declarator" "primitive_type" "field_identifier" "array_declarator"))) - ("parenthesized_expression" (:*unnamed* ("offsetof_expression" "identifier" "preproc_defined" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "comma_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("pointer_declarator" (:*unnamed* ("ms_pointer_modifier" "type_qualifier" "ms_based_modifier") :declarator ("type_identifier" "parenthesized_declarator" "attributed_declarator" "function_declarator" "identifier" "pointer_declarator" "primitive_type" "field_identifier" "array_declarator"))) - ("pointer_expression" (:argument ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression") :operator nil)) - ("preproc_call" (:argument ("preproc_arg") :directive ("preproc_directive"))) - ("preproc_def" (:name ("identifier") :value ("preproc_arg"))) - ("preproc_defined" (:*unnamed* ("identifier"))) - ("preproc_elif" (:*unnamed* ("continue_statement" "preproc_if" "seh_leave_statement" "if_statement" "do_statement" "union_specifier" "return_statement" "compound_statement" "preproc_ifdef" "case_statement" "type_identifier" "attributed_statement" "field_declaration" "switch_statement" "break_statement" "macro_type_specifier" "struct_specifier" "preproc_call" "labeled_statement" "linkage_specification" "preproc_def" "preproc_function_def" "function_definition" "enum_specifier" "for_statement" "seh_try_statement" "declaration" "type_definition" "while_statement" "primitive_type" "expression_statement" "preproc_include" "goto_statement" "sized_type_specifier") :alternative ("preproc_else" "preproc_elif") :condition ("identifier" "preproc_defined" "number_literal" "char_literal" "parenthesized_expression" "binary_expression" "call_expression" "unary_expression"))) - ("preproc_elifdef" (:*unnamed* ("continue_statement" "preproc_if" "seh_leave_statement" "if_statement" "do_statement" "union_specifier" "return_statement" "compound_statement" "preproc_ifdef" "case_statement" "type_identifier" "attributed_statement" "switch_statement" "break_statement" "macro_type_specifier" "struct_specifier" "preproc_call" "labeled_statement" "linkage_specification" "preproc_def" "preproc_function_def" "function_definition" "enum_specifier" "for_statement" "seh_try_statement" "declaration" "type_definition" "while_statement" "primitive_type" "expression_statement" "preproc_include" "goto_statement" "sized_type_specifier") :alternative ("preproc_else" "preproc_elif") :name ("identifier"))) - ("preproc_else" (:*unnamed* ("continue_statement" "preproc_if" "seh_leave_statement" "if_statement" "do_statement" "union_specifier" "return_statement" "compound_statement" "preproc_ifdef" "case_statement" "type_identifier" "attributed_statement" "field_declaration" "switch_statement" "break_statement" "macro_type_specifier" "struct_specifier" "preproc_call" "labeled_statement" "linkage_specification" "preproc_def" "preproc_function_def" "function_definition" "enum_specifier" "for_statement" "seh_try_statement" "declaration" "type_definition" "while_statement" "primitive_type" "expression_statement" "preproc_include" "goto_statement" "sized_type_specifier"))) - ("preproc_function_def" (:name ("identifier") :parameters ("preproc_params") :value ("preproc_arg"))) - ("preproc_if" (:*unnamed* ("continue_statement" "preproc_if" "seh_leave_statement" "if_statement" "do_statement" "union_specifier" "return_statement" "compound_statement" "preproc_ifdef" "case_statement" "type_identifier" "attributed_statement" "field_declaration" "switch_statement" "break_statement" "macro_type_specifier" "struct_specifier" "preproc_call" "labeled_statement" "linkage_specification" "preproc_def" "preproc_function_def" "function_definition" "enum_specifier" "for_statement" "seh_try_statement" "declaration" "type_definition" "while_statement" "primitive_type" "expression_statement" "preproc_include" "goto_statement" "sized_type_specifier") :alternative ("preproc_else" "preproc_elif") :condition ("identifier" "preproc_defined" "number_literal" "char_literal" "parenthesized_expression" "binary_expression" "call_expression" "unary_expression"))) - ("preproc_ifdef" (:*unnamed* ("continue_statement" "preproc_if" "seh_leave_statement" "if_statement" "do_statement" "union_specifier" "return_statement" "compound_statement" "preproc_ifdef" "case_statement" "type_identifier" "attributed_statement" "field_declaration" "switch_statement" "break_statement" "macro_type_specifier" "struct_specifier" "preproc_call" "labeled_statement" "linkage_specification" "preproc_def" "preproc_function_def" "function_definition" "enum_specifier" "for_statement" "seh_try_statement" "declaration" "type_definition" "while_statement" "primitive_type" "expression_statement" "preproc_include" "goto_statement" "sized_type_specifier") :alternative ("preproc_else" "preproc_elif" "preproc_elifdef") :name ("identifier"))) - ("preproc_include" (:path ("string_literal" "identifier" "call_expression" "system_lib_string"))) - ("preproc_params" (:*unnamed* ("identifier"))) - ("return_statement" (:*unnamed* ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "comma_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("seh_except_clause" (:body ("compound_statement") :filter ("parenthesized_expression"))) - ("seh_finally_clause" (:body ("compound_statement"))) - ("seh_try_statement" (:*unnamed* ("seh_finally_clause" "seh_except_clause") :body ("compound_statement"))) - ("sized_type_specifier" (:type ("primitive_type" "type_identifier"))) - ("sizeof_expression" (:type ("type_descriptor") :value ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("string_literal" (:*unnamed* ("string_content" "escape_sequence"))) - ("struct_specifier" (:*unnamed* ("attribute_specifier" "ms_declspec_modifier") :body ("field_declaration_list") :name ("type_identifier"))) - ("subscript_designator" (:*unnamed* ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("subscript_expression" (:argument ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression") :index ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression"))) - ("switch_statement" (:body ("compound_statement") :condition ("parenthesized_expression"))) - ("translation_unit" (:*unnamed* ("preproc_function_def" "continue_statement" "function_definition" "preproc_if" "enum_specifier" "for_statement" "if_statement" "union_specifier" "do_statement" "declaration" "return_statement" "compound_statement" "preproc_ifdef" "case_statement" "type_identifier" "type_definition" "while_statement" "primitive_type" "attributed_statement" "expression_statement" "preproc_include" "break_statement" "macro_type_specifier" "struct_specifier" "preproc_call" "switch_statement" "goto_statement" "labeled_statement" "linkage_specification" "preproc_def" "sized_type_specifier"))) - ("type_definition" (:*unnamed* ("attribute_specifier" "type_qualifier") :declarator ("type_identifier" "parenthesized_declarator" "attributed_declarator" "function_declarator" "array_declarator" "pointer_declarator" "primitive_type") :type ("type_identifier" "primitive_type" "enum_specifier" "sized_type_specifier" "macro_type_specifier" "struct_specifier" "union_specifier"))) - ("type_descriptor" (:*unnamed* ("type_qualifier") :declarator ("abstract_function_declarator" "abstract_pointer_declarator" "abstract_array_declarator" "abstract_parenthesized_declarator") :type ("type_identifier" "primitive_type" "enum_specifier" "sized_type_specifier" "macro_type_specifier" "struct_specifier" "union_specifier"))) - ("unary_expression" (:argument ("offsetof_expression" "identifier" "preproc_defined" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression") :operator nil)) - ("union_specifier" (:*unnamed* ("attribute_specifier" "ms_declspec_modifier") :body ("field_declaration_list") :name ("type_identifier"))) - ("update_expression" (:argument ("offsetof_expression" "identifier" "char_literal" "parenthesized_expression" "pointer_expression" "compound_literal_expression" "binary_expression" "alignof_expression" "cast_expression" "call_expression" "generic_expression" "conditional_expression" "subscript_expression" "assignment_expression" "false" "number_literal" "gnu_asm_expression" "update_expression" "true" "sizeof_expression" "concatenated_string" "null" "string_literal" "field_expression" "unary_expression") :operator nil)) - ("while_statement" (:body ("continue_statement" "for_statement" "seh_leave_statement" "if_statement" "do_statement" "seh_try_statement" "return_statement" "compound_statement" "case_statement" "while_statement" "attributed_statement" "expression_statement" "switch_statement" "break_statement" "goto_statement" "labeled_statement") :condition ("parenthesized_expression"))) - ("character" (:*unnamed* nil)) - ("comment" (:*unnamed* nil)) - ("escape_sequence" (:*unnamed* nil)) - ("false" (:*unnamed* nil)) - ("field_identifier" (:*unnamed* nil)) - ("identifier" (:*unnamed* nil)) - ("ms_restrict_modifier" (:*unnamed* nil)) - ("ms_signed_ptr_modifier" (:*unnamed* nil)) - ("ms_unsigned_ptr_modifier" (:*unnamed* nil)) - ("number_literal" (:*unnamed* nil)) - ("preproc_arg" (:*unnamed* nil)) - ("preproc_directive" (:*unnamed* nil)) - ("primitive_type" (:*unnamed* nil)) - ("statement_identifier" (:*unnamed* nil)) - ("string_content" (:*unnamed* nil)) - ("system_lib_string" (:*unnamed* nil)) - ("true" (:*unnamed* nil)) - ("type_identifier" (:*unnamed* nil)) - )) +(defconst combobulate-rules-c + '(("_abstract_declarator" (:*unnamed* ("abstract_array_declarator" "abstract_pointer_declarator" "abstract_function_declarator" "abstract_parenthesized_declarator"))) + ("_declarator" (:*unnamed* ("identifier" "array_declarator" "pointer_declarator" "function_declarator" "attributed_declarator" "parenthesized_declarator"))) + ("_expression" (:*unnamed* ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("_field_declarator" (:*unnamed* ("field_identifier" "array_declarator" "pointer_declarator" "function_declarator" "attributed_declarator" "parenthesized_declarator"))) + ("_statement" (:*unnamed* ("break_statement" "expression_statement" "do_statement" "if_statement" "continue_statement" "goto_statement" "switch_statement" "compound_statement" "for_statement" "case_statement" "while_statement" "labeled_statement" "return_statement" "seh_leave_statement" "seh_try_statement" "attributed_statement"))) + ("_type_declarator" (:*unnamed* ("type_identifier" "array_declarator" "primitive_type" "pointer_declarator" "function_declarator" "attributed_declarator" "parenthesized_declarator"))) + ("_type_specifier" (:*unnamed* ("enum_specifier" "sized_type_specifier" "type_identifier" "union_specifier" "macro_type_specifier" "primitive_type" "struct_specifier"))) + ("abstract_array_declarator" (:*unnamed* ("type_qualifier") :declarator ("abstract_array_declarator" "abstract_pointer_declarator" "abstract_function_declarator" "abstract_parenthesized_declarator") :size ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("abstract_function_declarator" (:*unnamed* nil :declarator ("abstract_array_declarator" "abstract_pointer_declarator" "abstract_function_declarator" "abstract_parenthesized_declarator") :parameters ("parameter_list"))) + ("abstract_parenthesized_declarator" (:*unnamed* ("abstract_array_declarator" "abstract_pointer_declarator" "abstract_function_declarator" "abstract_parenthesized_declarator"))) + ("abstract_pointer_declarator" (:*unnamed* ("type_qualifier") :declarator ("abstract_array_declarator" "abstract_pointer_declarator" "abstract_function_declarator" "abstract_parenthesized_declarator"))) + ("alignof_expression" (:*unnamed* nil :type ("type_descriptor"))) + ("argument_list" (:*unnamed* ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "compound_statement" "binary_expression" "alignof_expression" "preproc_defined" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("array_declarator" (:*unnamed* ("type_qualifier") :declarator ("type_identifier" "primitive_type" "pointer_declarator" "attributed_declarator" "identifier" "array_declarator" "function_declarator" "field_identifier" "parenthesized_declarator") :size ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("assignment_expression" (:*unnamed* nil :left ("parenthesized_expression" "identifier" "pointer_expression" "call_expression" "field_expression" "subscript_expression") :operator nil :right ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("attribute" (:*unnamed* ("argument_list") :name ("identifier") :prefix ("identifier"))) + ("attribute_declaration" (:*unnamed* ("attribute"))) + ("attribute_specifier" (:*unnamed* ("argument_list"))) + ("attributed_declarator" (:*unnamed* ("type_identifier" "primitive_type" "pointer_declarator" "attributed_declarator" "identifier" "attribute_declaration" "array_declarator" "function_declarator" "field_identifier" "parenthesized_declarator"))) + ("attributed_statement" (:*unnamed* ("break_statement" "expression_statement" "do_statement" "if_statement" "continue_statement" "goto_statement" "switch_statement" "compound_statement" "for_statement" "case_statement" "while_statement" "labeled_statement" "return_statement" "seh_leave_statement" "seh_try_statement" "attribute_declaration" "attributed_statement"))) + ("binary_expression" (:*unnamed* nil :left ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "preproc_defined" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null") :operator nil :right ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "preproc_defined" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("bitfield_clause" (:*unnamed* ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("break_statement" (:*unnamed* nil)) + ("call_expression" (:*unnamed* nil :arguments ("argument_list") :function ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("case_statement" (:*unnamed* ("break_statement" "expression_statement" "do_statement" "if_statement" "continue_statement" "goto_statement" "switch_statement" "compound_statement" "declaration" "type_definition" "for_statement" "while_statement" "labeled_statement" "return_statement" "seh_leave_statement" "seh_try_statement" "attributed_statement") :value ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("cast_expression" (:*unnamed* nil :type ("type_descriptor") :value ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("char_literal" (:*unnamed* ("character" "escape_sequence"))) + ("comma_expression" (:*unnamed* nil :left ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null") :right ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "comma_expression" "field_expression" "null"))) + ("compound_literal_expression" (:*unnamed* nil :type ("type_descriptor") :value ("initializer_list"))) + ("compound_statement" (:*unnamed* ("break_statement" "union_specifier" "preproc_function_def" "preproc_ifdef" "do_statement" "continue_statement" "type_identifier" "for_statement" "preproc_if" "return_statement" "enum_specifier" "seh_leave_statement" "preproc_def" "seh_try_statement" "attributed_statement" "preproc_call" "primitive_type" "expression_statement" "if_statement" "preproc_include" "goto_statement" "switch_statement" "macro_type_specifier" "compound_statement" "declaration" "linkage_specification" "type_definition" "sized_type_specifier" "case_statement" "while_statement" "function_definition" "labeled_statement" "struct_specifier"))) + ("concatenated_string" (:*unnamed* ("identifier" "string_literal"))) + ("conditional_expression" (:*unnamed* nil :alternative ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null") :condition ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null") :consequence ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("continue_statement" (:*unnamed* nil)) + ("declaration" (:*unnamed* ("attribute_declaration" "attribute_specifier" "type_qualifier" "ms_declspec_modifier" "storage_class_specifier") :declarator ("pointer_declarator" "init_declarator" "attributed_declarator" "gnu_asm_expression" "identifier" "array_declarator" "function_declarator" "parenthesized_declarator") :type ("enum_specifier" "sized_type_specifier" "type_identifier" "union_specifier" "macro_type_specifier" "primitive_type" "struct_specifier"))) + ("declaration_list" (:*unnamed* ("break_statement" "union_specifier" "preproc_function_def" "preproc_ifdef" "do_statement" "continue_statement" "type_identifier" "for_statement" "preproc_if" "return_statement" "enum_specifier" "seh_leave_statement" "preproc_def" "seh_try_statement" "attributed_statement" "preproc_call" "primitive_type" "expression_statement" "if_statement" "preproc_include" "goto_statement" "switch_statement" "macro_type_specifier" "compound_statement" "declaration" "linkage_specification" "type_definition" "sized_type_specifier" "case_statement" "while_statement" "function_definition" "labeled_statement" "struct_specifier"))) + ("do_statement" (:*unnamed* nil :body ("break_statement" "expression_statement" "do_statement" "if_statement" "continue_statement" "goto_statement" "switch_statement" "compound_statement" "for_statement" "case_statement" "while_statement" "labeled_statement" "return_statement" "seh_leave_statement" "seh_try_statement" "attributed_statement") :condition ("parenthesized_expression"))) + ("else_clause" (:*unnamed* ("break_statement" "expression_statement" "do_statement" "if_statement" "continue_statement" "goto_statement" "switch_statement" "compound_statement" "for_statement" "case_statement" "while_statement" "labeled_statement" "return_statement" "seh_leave_statement" "seh_try_statement" "attributed_statement"))) + ("enum_specifier" (:*unnamed* ("attribute_specifier") :body ("enumerator_list") :name ("type_identifier") :underlying_type ("primitive_type"))) + ("enumerator" (:*unnamed* nil :name ("identifier") :value ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("enumerator_list" (:*unnamed* ("enumerator"))) + ("expression_statement" (:*unnamed* ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "comma_expression" "field_expression" "null"))) + ("field_declaration" (:*unnamed* ("attribute_declaration" "bitfield_clause" "attribute_specifier" "type_qualifier" "ms_declspec_modifier" "storage_class_specifier") :declarator ("field_identifier" "array_declarator" "pointer_declarator" "function_declarator" "attributed_declarator" "parenthesized_declarator") :type ("enum_specifier" "sized_type_specifier" "type_identifier" "union_specifier" "macro_type_specifier" "primitive_type" "struct_specifier"))) + ("field_declaration_list" (:*unnamed* ("preproc_def" "field_declaration" "preproc_function_def" "preproc_ifdef" "preproc_call" "preproc_if"))) + ("field_designator" (:*unnamed* ("field_identifier"))) + ("field_expression" (:*unnamed* nil :argument ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null") :field ("field_identifier") :operator nil)) + ("for_statement" (:*unnamed* nil :body ("break_statement" "expression_statement" "do_statement" "if_statement" "continue_statement" "goto_statement" "switch_statement" "compound_statement" "for_statement" "case_statement" "while_statement" "labeled_statement" "return_statement" "seh_leave_statement" "seh_try_statement" "attributed_statement") :condition ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "comma_expression" "field_expression" "null") :initializer ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "declaration" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "comma_expression" "field_expression" "null") :update ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "comma_expression" "field_expression" "null"))) + ("function_declarator" (:*unnamed* ("attribute_specifier" "gnu_asm_expression") :declarator ("type_identifier" "primitive_type" "pointer_declarator" "attributed_declarator" "identifier" "array_declarator" "function_declarator" "field_identifier" "parenthesized_declarator") :parameters ("parameter_list"))) + ("function_definition" (:*unnamed* ("ms_call_modifier" "attribute_declaration" "attribute_specifier" "type_qualifier" "declaration" "ms_declspec_modifier" "storage_class_specifier") :body ("compound_statement") :declarator ("identifier" "array_declarator" "pointer_declarator" "function_declarator" "attributed_declarator" "parenthesized_declarator") :type ("enum_specifier" "sized_type_specifier" "type_identifier" "union_specifier" "macro_type_specifier" "primitive_type" "struct_specifier"))) + ("generic_expression" (:*unnamed* ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "type_descriptor" "string_literal" "identifier" "field_expression" "null"))) + ("gnu_asm_clobber_list" (:*unnamed* nil :register ("string_literal"))) + ("gnu_asm_expression" (:*unnamed* ("gnu_asm_qualifier") :assembly_code ("concatenated_string" "string_literal") :clobbers ("gnu_asm_clobber_list") :goto_labels ("gnu_asm_goto_list") :input_operands ("gnu_asm_input_operand_list") :output_operands ("gnu_asm_output_operand_list"))) + ("gnu_asm_goto_list" (:*unnamed* nil :label ("identifier"))) + ("gnu_asm_input_operand" (:*unnamed* nil :constraint ("string_literal") :symbol ("identifier") :value ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("gnu_asm_input_operand_list" (:*unnamed* nil :operand ("gnu_asm_input_operand"))) + ("gnu_asm_output_operand" (:*unnamed* nil :constraint ("string_literal") :symbol ("identifier") :value ("identifier"))) + ("gnu_asm_output_operand_list" (:*unnamed* nil :operand ("gnu_asm_output_operand"))) + ("gnu_asm_qualifier" (:*unnamed* nil)) + ("goto_statement" (:*unnamed* nil :label ("statement_identifier"))) + ("if_statement" (:*unnamed* nil :alternative ("else_clause") :condition ("parenthesized_expression") :consequence ("break_statement" "expression_statement" "do_statement" "if_statement" "continue_statement" "goto_statement" "switch_statement" "compound_statement" "for_statement" "case_statement" "while_statement" "labeled_statement" "return_statement" "seh_leave_statement" "seh_try_statement" "attributed_statement"))) + ("init_declarator" (:*unnamed* nil :declarator ("identifier" "array_declarator" "pointer_declarator" "function_declarator" "attributed_declarator" "parenthesized_declarator") :value ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "initializer_list" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("initializer_list" (:*unnamed* ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "initializer_pair" "binary_expression" "initializer_list" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("initializer_pair" (:*unnamed* nil :designator ("field_designator" "subscript_designator") :value ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "initializer_list" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("labeled_statement" (:*unnamed* ("break_statement" "expression_statement" "do_statement" "if_statement" "continue_statement" "goto_statement" "switch_statement" "compound_statement" "for_statement" "case_statement" "while_statement" "labeled_statement" "return_statement" "seh_leave_statement" "seh_try_statement" "attributed_statement") :label ("statement_identifier"))) + ("linkage_specification" (:*unnamed* nil :body ("function_definition" "declaration" "declaration_list") :value ("string_literal"))) + ("macro_type_specifier" (:*unnamed* nil :name ("identifier") :type ("type_descriptor"))) + ("ms_based_modifier" (:*unnamed* ("argument_list"))) + ("ms_call_modifier" (:*unnamed* nil)) + ("ms_declspec_modifier" (:*unnamed* ("identifier"))) + ("ms_pointer_modifier" (:*unnamed* ("ms_unsigned_ptr_modifier" "ms_restrict_modifier" "ms_unaligned_ptr_modifier" "ms_signed_ptr_modifier"))) + ("ms_unaligned_ptr_modifier" (:*unnamed* nil)) + ("null" (:*unnamed* nil)) + ("offsetof_expression" (:*unnamed* nil :member ("field_identifier") :type ("type_descriptor"))) + ("parameter_declaration" (:*unnamed* ("attribute_declaration" "attribute_specifier" "type_qualifier" "ms_declspec_modifier" "storage_class_specifier") :declarator ("pointer_declarator" "attributed_declarator" "abstract_function_declarator" "abstract_array_declarator" "identifier" "array_declarator" "abstract_parenthesized_declarator" "function_declarator" "abstract_pointer_declarator" "parenthesized_declarator") :type ("enum_specifier" "sized_type_specifier" "type_identifier" "union_specifier" "macro_type_specifier" "primitive_type" "struct_specifier"))) + ("parameter_list" (:*unnamed* ("identifier" "variadic_parameter" "parameter_declaration"))) + ("parenthesized_declarator" (:*unnamed* ("type_identifier" "primitive_type" "pointer_declarator" "attributed_declarator" "identifier" "array_declarator" "function_declarator" "field_identifier" "parenthesized_declarator"))) + ("parenthesized_expression" (:*unnamed* ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "preproc_defined" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "comma_expression" "field_expression" "null"))) + ("pointer_declarator" (:*unnamed* ("type_qualifier" "ms_based_modifier" "ms_pointer_modifier") :declarator ("type_identifier" "primitive_type" "pointer_declarator" "attributed_declarator" "identifier" "array_declarator" "function_declarator" "field_identifier" "parenthesized_declarator"))) + ("pointer_expression" (:*unnamed* nil :argument ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null") :operator nil)) + ("preproc_call" (:*unnamed* nil :argument ("preproc_arg") :directive ("preproc_directive"))) + ("preproc_def" (:*unnamed* nil :name ("identifier") :value ("preproc_arg"))) + ("preproc_defined" (:*unnamed* ("identifier"))) + ("preproc_elif" (:*unnamed* ("break_statement" "union_specifier" "preproc_function_def" "preproc_ifdef" "do_statement" "continue_statement" "type_identifier" "for_statement" "preproc_if" "return_statement" "enum_specifier" "seh_leave_statement" "preproc_def" "seh_try_statement" "attributed_statement" "preproc_call" "primitive_type" "expression_statement" "if_statement" "preproc_include" "goto_statement" "switch_statement" "macro_type_specifier" "compound_statement" "declaration" "linkage_specification" "type_definition" "sized_type_specifier" "case_statement" "while_statement" "function_definition" "labeled_statement" "field_declaration" "struct_specifier") :alternative ("preproc_else" "preproc_elif") :condition ("parenthesized_expression" "char_literal" "call_expression" "number_literal" "unary_expression" "identifier" "binary_expression" "preproc_defined"))) + ("preproc_elifdef" (:*unnamed* ("break_statement" "union_specifier" "preproc_function_def" "preproc_ifdef" "do_statement" "continue_statement" "type_identifier" "for_statement" "preproc_if" "return_statement" "enum_specifier" "seh_leave_statement" "preproc_def" "seh_try_statement" "attributed_statement" "preproc_call" "primitive_type" "expression_statement" "if_statement" "preproc_include" "goto_statement" "switch_statement" "macro_type_specifier" "compound_statement" "declaration" "linkage_specification" "type_definition" "sized_type_specifier" "case_statement" "while_statement" "function_definition" "labeled_statement" "struct_specifier") :alternative ("preproc_else" "preproc_elif") :name ("identifier"))) + ("preproc_else" (:*unnamed* ("break_statement" "union_specifier" "preproc_function_def" "preproc_ifdef" "do_statement" "continue_statement" "type_identifier" "for_statement" "preproc_if" "return_statement" "enum_specifier" "seh_leave_statement" "preproc_def" "seh_try_statement" "attributed_statement" "preproc_call" "primitive_type" "expression_statement" "if_statement" "preproc_include" "goto_statement" "switch_statement" "macro_type_specifier" "compound_statement" "declaration" "linkage_specification" "type_definition" "sized_type_specifier" "case_statement" "while_statement" "function_definition" "labeled_statement" "field_declaration" "struct_specifier"))) + ("preproc_function_def" (:*unnamed* nil :name ("identifier") :parameters ("preproc_params") :value ("preproc_arg"))) + ("preproc_if" (:*unnamed* ("break_statement" "union_specifier" "preproc_function_def" "preproc_ifdef" "do_statement" "continue_statement" "type_identifier" "for_statement" "preproc_if" "return_statement" "enum_specifier" "seh_leave_statement" "preproc_def" "seh_try_statement" "attributed_statement" "preproc_call" "primitive_type" "expression_statement" "if_statement" "preproc_include" "goto_statement" "switch_statement" "macro_type_specifier" "compound_statement" "declaration" "linkage_specification" "type_definition" "sized_type_specifier" "case_statement" "while_statement" "function_definition" "labeled_statement" "field_declaration" "struct_specifier") :alternative ("preproc_else" "preproc_elif") :condition ("parenthesized_expression" "char_literal" "call_expression" "number_literal" "unary_expression" "identifier" "binary_expression" "preproc_defined"))) + ("preproc_ifdef" (:*unnamed* ("break_statement" "union_specifier" "preproc_function_def" "preproc_ifdef" "do_statement" "continue_statement" "type_identifier" "for_statement" "preproc_if" "return_statement" "enum_specifier" "seh_leave_statement" "preproc_def" "seh_try_statement" "attributed_statement" "preproc_call" "primitive_type" "expression_statement" "if_statement" "preproc_include" "goto_statement" "switch_statement" "macro_type_specifier" "compound_statement" "declaration" "linkage_specification" "type_definition" "sized_type_specifier" "case_statement" "while_statement" "function_definition" "labeled_statement" "field_declaration" "struct_specifier") :alternative ("preproc_elifdef" "preproc_else" "preproc_elif") :name ("identifier"))) + ("preproc_include" (:*unnamed* nil :path ("identifier" "system_lib_string" "call_expression" "string_literal"))) + ("preproc_params" (:*unnamed* ("identifier"))) + ("return_statement" (:*unnamed* ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "comma_expression" "field_expression" "null"))) + ("seh_except_clause" (:*unnamed* nil :body ("compound_statement") :filter ("parenthesized_expression"))) + ("seh_finally_clause" (:*unnamed* nil :body ("compound_statement"))) + ("seh_leave_statement" (:*unnamed* nil)) + ("seh_try_statement" (:*unnamed* ("seh_finally_clause" "seh_except_clause") :body ("compound_statement"))) + ("sized_type_specifier" (:*unnamed* nil :type ("primitive_type" "type_identifier"))) + ("sizeof_expression" (:*unnamed* nil :type ("type_descriptor") :value ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("storage_class_specifier" (:*unnamed* nil)) + ("string_literal" (:*unnamed* ("string_content" "escape_sequence"))) + ("struct_specifier" (:*unnamed* ("attribute_specifier" "ms_declspec_modifier") :body ("field_declaration_list") :name ("type_identifier"))) + ("subscript_designator" (:*unnamed* ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("subscript_expression" (:*unnamed* nil :argument ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null") :index ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null"))) + ("switch_statement" (:*unnamed* nil :body ("compound_statement") :condition ("parenthesized_expression"))) + ("translation_unit" (:*unnamed* ("break_statement" "union_specifier" "primitive_type" "preproc_function_def" "preproc_ifdef" "expression_statement" "do_statement" "if_statement" "preproc_include" "continue_statement" "goto_statement" "switch_statement" "macro_type_specifier" "compound_statement" "declaration" "linkage_specification" "type_definition" "sized_type_specifier" "type_identifier" "for_statement" "case_statement" "preproc_if" "while_statement" "function_definition" "enum_specifier" "labeled_statement" "return_statement" "preproc_def" "attributed_statement" "preproc_call" "struct_specifier"))) + ("type_definition" (:*unnamed* ("attribute_specifier" "type_qualifier") :declarator ("type_identifier" "array_declarator" "primitive_type" "pointer_declarator" "function_declarator" "attributed_declarator" "parenthesized_declarator") :type ("enum_specifier" "sized_type_specifier" "type_identifier" "union_specifier" "macro_type_specifier" "primitive_type" "struct_specifier"))) + ("type_descriptor" (:*unnamed* ("type_qualifier") :declarator ("abstract_array_declarator" "abstract_pointer_declarator" "abstract_function_declarator" "abstract_parenthesized_declarator") :type ("enum_specifier" "sized_type_specifier" "type_identifier" "union_specifier" "macro_type_specifier" "primitive_type" "struct_specifier"))) + ("type_qualifier" (:*unnamed* nil)) + ("unary_expression" (:*unnamed* nil :argument ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "preproc_defined" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null") :operator nil)) + ("union_specifier" (:*unnamed* ("attribute_specifier" "ms_declspec_modifier") :body ("field_declaration_list") :name ("type_identifier"))) + ("update_expression" (:*unnamed* nil :argument ("false" "cast_expression" "pointer_expression" "update_expression" "sizeof_expression" "number_literal" "compound_literal_expression" "assignment_expression" "gnu_asm_expression" "generic_expression" "binary_expression" "alignof_expression" "subscript_expression" "parenthesized_expression" "char_literal" "offsetof_expression" "call_expression" "concatenated_string" "true" "conditional_expression" "unary_expression" "string_literal" "identifier" "field_expression" "null") :operator nil)) + ("variadic_parameter" (:*unnamed* nil)) + ("while_statement" (:*unnamed* nil :body ("break_statement" "expression_statement" "do_statement" "if_statement" "continue_statement" "goto_statement" "switch_statement" "compound_statement" "for_statement" "case_statement" "while_statement" "labeled_statement" "return_statement" "seh_leave_statement" "seh_try_statement" "attributed_statement") :condition ("parenthesized_expression"))) + ("character" (:*unnamed* nil)) + ("comment" (:*unnamed* nil)) + ("escape_sequence" (:*unnamed* nil)) + ("false" (:*unnamed* nil)) + ("field_identifier" (:*unnamed* nil)) + ("identifier" (:*unnamed* nil)) + ("ms_restrict_modifier" (:*unnamed* nil)) + ("ms_signed_ptr_modifier" (:*unnamed* nil)) + ("ms_unsigned_ptr_modifier" (:*unnamed* nil)) + ("number_literal" (:*unnamed* nil)) + ("preproc_arg" (:*unnamed* nil)) + ("preproc_directive" (:*unnamed* nil)) + ("primitive_type" (:*unnamed* nil)) + ("statement_identifier" (:*unnamed* nil)) + ("string_content" (:*unnamed* nil)) + ("system_lib_string" (:*unnamed* nil)) + ("true" (:*unnamed* nil)) + ("type_identifier" (:*unnamed* nil)) +)) ;; END Production rules for c ;; START Inverse production rules for c -(defconst combobulate-rules-c-inverse - '(("abstract_array_declarator" ("abstract_pointer_declarator" "abstract_parenthesized_declarator" "abstract_array_declarator" "abstract_function_declarator" "_abstract_declarator" "type_descriptor" "parameter_declaration")) - ("abstract_function_declarator" ("abstract_pointer_declarator" "abstract_parenthesized_declarator" "abstract_array_declarator" "abstract_function_declarator" "_abstract_declarator" "type_descriptor" "parameter_declaration")) - ("abstract_parenthesized_declarator" ("abstract_pointer_declarator" "abstract_parenthesized_declarator" "abstract_array_declarator" "abstract_function_declarator" "_abstract_declarator" "type_descriptor" "parameter_declaration")) - ("abstract_pointer_declarator" ("abstract_pointer_declarator" "abstract_parenthesized_declarator" "abstract_array_declarator" "abstract_function_declarator" "_abstract_declarator" "type_descriptor" "parameter_declaration")) - ("alignof_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("argument_list" ("attribute_specifier" "attribute" "call_expression" "ms_based_modifier")) - ("array_declarator" ("type_definition" "attributed_declarator" "function_definition" "function_declarator" "parenthesized_declarator" "pointer_declarator" "field_declaration" "_type_declarator" "_field_declarator" "_declarator" "array_declarator" "declaration" "init_declarator" "parameter_declaration")) - ("assignment_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("attribute" ("attribute_declaration")) - ("attribute_declaration" ("attributed_declarator" "function_definition" "attributed_statement" "field_declaration" "declaration" "parameter_declaration")) - ("attribute_specifier" ("type_definition" "function_definition" "function_declarator" "enum_specifier" "field_declaration" "struct_specifier" "union_specifier" "declaration" "parameter_declaration")) - ("attributed_declarator" ("type_definition" "attributed_declarator" "function_definition" "function_declarator" "parenthesized_declarator" "pointer_declarator" "field_declaration" "_type_declarator" "_field_declarator" "_declarator" "array_declarator" "declaration" "init_declarator" "parameter_declaration")) - ("attributed_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("binary_expression" ("gnu_asm_input_operand" "preproc_if" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "preproc_elif" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("bitfield_clause" ("field_declaration")) - ("break_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("call_expression" ("gnu_asm_input_operand" "preproc_if" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "preproc_elif" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "preproc_include" "update_expression" "initializer_list" "unary_expression")) - ("case_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef")) - ("cast_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("char_literal" ("gnu_asm_input_operand" "preproc_if" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "preproc_elif" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("character" ("char_literal")) - ("comma_expression" ("parenthesized_expression" "for_statement" "expression_statement" "comma_expression" "return_statement")) - ("compound_literal_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("compound_statement" ("preproc_if" "if_statement" "do_statement" "compound_statement" "preproc_ifdef" "case_statement" "preproc_else" "preproc_elifdef" "attributed_statement" "switch_statement" "seh_except_clause" "else_clause" "labeled_statement" "seh_finally_clause" "function_definition" "declaration_list" "for_statement" "seh_try_statement" "_statement" "argument_list" "translation_unit" "preproc_elif" "while_statement")) - ("concatenated_string" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "gnu_asm_expression" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("conditional_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("continue_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("declaration" ("translation_unit" "preproc_elif" "function_definition" "preproc_elifdef" "preproc_else" "declaration_list" "preproc_if" "for_statement" "compound_statement" "linkage_specification" "preproc_ifdef" "case_statement")) - ("declaration_list" ("linkage_specification")) - ("do_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("else_clause" ("if_statement")) - ("enum_specifier" ("type_definition" "translation_unit" "preproc_elif" "function_definition" "preproc_elifdef" "preproc_else" "declaration_list" "preproc_if" "_type_specifier" "field_declaration" "preproc_ifdef" "declaration" "compound_statement" "type_descriptor" "parameter_declaration")) - ("enumerator" ("enumerator_list")) - ("enumerator_list" ("enum_specifier")) - ("escape_sequence" ("string_literal" "char_literal")) - ("expression_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("false" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("field_declaration" ("preproc_else" "preproc_elif" "preproc_if" "field_declaration_list" "preproc_ifdef")) - ("field_declaration_list" ("struct_specifier" "union_specifier")) - ("field_designator" ("initializer_pair")) - ("field_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("field_identifier" ("attributed_declarator" "offsetof_expression" "function_declarator" "parenthesized_declarator" "pointer_declarator" "field_declaration" "_field_declarator" "array_declarator" "field_designator" "field_expression")) - ("for_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("function_declarator" ("type_definition" "attributed_declarator" "function_definition" "function_declarator" "parenthesized_declarator" "pointer_declarator" "field_declaration" "_type_declarator" "_field_declarator" "_declarator" "array_declarator" "declaration" "init_declarator" "parameter_declaration")) - ("function_definition" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "compound_statement" "linkage_specification" "preproc_ifdef")) - ("generic_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("gnu_asm_clobber_list" ("gnu_asm_expression")) - ("gnu_asm_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "function_declarator" "pointer_expression" "for_statement" "declaration" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("gnu_asm_goto_list" ("gnu_asm_expression")) - ("gnu_asm_input_operand" ("gnu_asm_input_operand_list")) - ("gnu_asm_input_operand_list" ("gnu_asm_expression")) - ("gnu_asm_output_operand" ("gnu_asm_output_operand_list")) - ("gnu_asm_output_operand_list" ("gnu_asm_expression")) - ("gnu_asm_qualifier" ("gnu_asm_expression")) - ("goto_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("identifier" ("gnu_asm_input_operand" "preproc_defined" "gnu_asm_output_operand" "preproc_if" "parenthesized_expression" "attribute" "_declarator" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "preproc_params" "return_statement" "preproc_ifdef" "case_statement" "ms_declspec_modifier" "preproc_elifdef" "abstract_array_declarator" "macro_type_specifier" "sizeof_expression" "concatenated_string" "parameter_list" "field_expression" "_expression" "preproc_def" "subscript_designator" "preproc_function_def" "attributed_declarator" "function_definition" "function_declarator" "pointer_expression" "for_statement" "declaration" "call_expression" "init_declarator" "parameter_declaration" "argument_list" "assignment_expression" "subscript_expression" "gnu_asm_goto_list" "preproc_elif" "parenthesized_declarator" "bitfield_clause" "enumerator" "pointer_declarator" "expression_statement" "comma_expression" "preproc_include" "update_expression" "initializer_list" "unary_expression")) - ("if_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("init_declarator" ("declaration")) - ("initializer_list" ("init_declarator" "compound_literal_expression" "initializer_pair" "initializer_list")) - ("initializer_pair" ("initializer_list")) - ("labeled_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("linkage_specification" ("translation_unit" "preproc_else" "preproc_elif" "preproc_elifdef" "preproc_if" "declaration_list" "compound_statement" "preproc_ifdef")) - ("macro_type_specifier" ("type_definition" "translation_unit" "preproc_elif" "function_definition" "preproc_elifdef" "preproc_else" "declaration_list" "preproc_if" "_type_specifier" "field_declaration" "preproc_ifdef" "declaration" "compound_statement" "type_descriptor" "parameter_declaration")) - ("ms_based_modifier" ("pointer_declarator")) - ("ms_call_modifier" ("function_definition")) - ("ms_declspec_modifier" ("function_definition" "field_declaration" "struct_specifier" "union_specifier" "declaration" "parameter_declaration")) - ("ms_pointer_modifier" ("pointer_declarator")) - ("ms_restrict_modifier" ("ms_pointer_modifier")) - ("ms_signed_ptr_modifier" ("ms_pointer_modifier")) - ("ms_unaligned_ptr_modifier" ("ms_pointer_modifier")) - ("ms_unsigned_ptr_modifier" ("ms_pointer_modifier")) - ("null" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("number_literal" ("gnu_asm_input_operand" "preproc_if" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "preproc_elif" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("offsetof_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("parameter_declaration" ("parameter_list")) - ("parameter_list" ("abstract_function_declarator" "function_declarator")) - ("parenthesized_declarator" ("type_definition" "attributed_declarator" "function_definition" "function_declarator" "parenthesized_declarator" "pointer_declarator" "field_declaration" "_type_declarator" "_field_declarator" "_declarator" "array_declarator" "declaration" "init_declarator" "parameter_declaration")) - ("parenthesized_expression" ("gnu_asm_input_operand" "preproc_if" "parenthesized_expression" "if_statement" "do_statement" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "switch_statement" "abstract_array_declarator" "seh_except_clause" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "preproc_elif" "while_statement" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("pointer_declarator" ("type_definition" "attributed_declarator" "function_definition" "function_declarator" "parenthesized_declarator" "pointer_declarator" "field_declaration" "_type_declarator" "_field_declarator" "_declarator" "array_declarator" "declaration" "init_declarator" "parameter_declaration")) - ("pointer_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("preproc_arg" ("preproc_function_def" "preproc_def" "preproc_call")) - ("preproc_call" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "field_declaration_list" "compound_statement" "preproc_ifdef")) - ("preproc_def" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "field_declaration_list" "compound_statement" "preproc_ifdef")) - ("preproc_defined" ("preproc_elif" "preproc_if" "parenthesized_expression" "binary_expression" "argument_list" "unary_expression")) - ("preproc_directive" ("preproc_call")) - ("preproc_elif" ("preproc_ifdef" "preproc_elif" "preproc_elifdef" "preproc_if")) - ("preproc_elifdef" ("preproc_ifdef")) - ("preproc_else" ("preproc_ifdef" "preproc_elif" "preproc_elifdef" "preproc_if")) - ("preproc_function_def" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "field_declaration_list" "compound_statement" "preproc_ifdef")) - ("preproc_if" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "field_declaration_list" "compound_statement" "preproc_ifdef")) - ("preproc_ifdef" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "field_declaration_list" "compound_statement" "preproc_ifdef")) - ("preproc_include" ("translation_unit" "preproc_else" "preproc_elif" "preproc_elifdef" "preproc_if" "declaration_list" "compound_statement" "preproc_ifdef")) - ("preproc_params" ("preproc_function_def")) - ("primitive_type" ("preproc_if" "_type_specifier" "_type_declarator" "array_declarator" "compound_statement" "type_descriptor" "preproc_ifdef" "preproc_else" "preproc_elifdef" "field_declaration" "attributed_declarator" "function_definition" "function_declarator" "declaration_list" "enum_specifier" "declaration" "parameter_declaration" "type_definition" "translation_unit" "preproc_elif" "parenthesized_declarator" "pointer_declarator" "sized_type_specifier")) - ("return_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("seh_except_clause" ("seh_try_statement")) - ("seh_finally_clause" ("seh_try_statement")) - ("seh_leave_statement" ("preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("seh_try_statement" ("preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("sized_type_specifier" ("type_definition" "translation_unit" "preproc_elif" "function_definition" "preproc_elifdef" "preproc_else" "declaration_list" "preproc_if" "_type_specifier" "field_declaration" "preproc_ifdef" "declaration" "compound_statement" "type_descriptor" "parameter_declaration")) - ("sizeof_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("statement_identifier" ("labeled_statement" "goto_statement")) - ("storage_class_specifier" ("field_declaration" "declaration" "function_definition" "parameter_declaration")) - ("string_content" ("string_literal")) - ("string_literal" ("gnu_asm_input_operand" "gnu_asm_output_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "concatenated_string" "linkage_specification" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "gnu_asm_clobber_list" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "gnu_asm_expression" "expression_statement" "comma_expression" "preproc_include" "update_expression" "initializer_list" "unary_expression")) - ("struct_specifier" ("type_definition" "translation_unit" "preproc_elif" "function_definition" "preproc_elifdef" "preproc_else" "declaration_list" "preproc_if" "_type_specifier" "field_declaration" "preproc_ifdef" "declaration" "compound_statement" "type_descriptor" "parameter_declaration")) - ("subscript_designator" ("initializer_pair")) - ("subscript_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("switch_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ("system_lib_string" ("preproc_include")) - ("true" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("type_definition" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "compound_statement" "preproc_ifdef" "case_statement")) - ("type_descriptor" ("offsetof_expression" "compound_literal_expression" "macro_type_specifier" "sizeof_expression" "alignof_expression" "cast_expression" "generic_expression")) - ("type_identifier" ("preproc_if" "_type_specifier" "_type_declarator" "union_specifier" "array_declarator" "compound_statement" "type_descriptor" "preproc_ifdef" "preproc_else" "preproc_elifdef" "field_declaration" "struct_specifier" "attributed_declarator" "function_definition" "function_declarator" "declaration_list" "enum_specifier" "declaration" "parameter_declaration" "type_definition" "translation_unit" "preproc_elif" "parenthesized_declarator" "pointer_declarator" "sized_type_specifier")) - ("type_qualifier" ("type_definition" "function_definition" "abstract_pointer_declarator" "pointer_declarator" "field_declaration" "abstract_array_declarator" "declaration" "array_declarator" "type_descriptor" "parameter_declaration")) - ("unary_expression" ("gnu_asm_input_operand" "preproc_if" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "preproc_elif" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("union_specifier" ("type_definition" "translation_unit" "preproc_elif" "function_definition" "preproc_elifdef" "preproc_else" "declaration_list" "preproc_if" "_type_specifier" "field_declaration" "preproc_ifdef" "declaration" "compound_statement" "type_descriptor" "parameter_declaration")) - ("update_expression" ("gnu_asm_input_operand" "parenthesized_expression" "array_declarator" "binary_expression" "cast_expression" "initializer_pair" "generic_expression" "conditional_expression" "return_statement" "case_statement" "abstract_array_declarator" "sizeof_expression" "field_expression" "_expression" "subscript_designator" "pointer_expression" "for_statement" "call_expression" "init_declarator" "argument_list" "assignment_expression" "subscript_expression" "bitfield_clause" "enumerator" "expression_statement" "comma_expression" "update_expression" "initializer_list" "unary_expression")) - ("variadic_parameter" ("parameter_list")) - ("while_statement" ("translation_unit" "preproc_elif" "preproc_else" "preproc_elifdef" "preproc_if" "declaration_list" "while_statement" "attributed_statement" "for_statement" "if_statement" "do_statement" "else_clause" "_statement" "compound_statement" "labeled_statement" "preproc_ifdef" "case_statement")) - ) - ) +(defconst combobulate-rules-c-inverse + '(("abstract_array_declarator" ("parameter_declaration" "type_descriptor" "abstract_function_declarator" "abstract_array_declarator" "_abstract_declarator" "abstract_parenthesized_declarator" "abstract_pointer_declarator")) + ("abstract_function_declarator" ("parameter_declaration" "type_descriptor" "abstract_function_declarator" "abstract_array_declarator" "_abstract_declarator" "abstract_parenthesized_declarator" "abstract_pointer_declarator")) + ("abstract_parenthesized_declarator" ("parameter_declaration" "type_descriptor" "abstract_function_declarator" "abstract_array_declarator" "_abstract_declarator" "abstract_parenthesized_declarator" "abstract_pointer_declarator")) + ("abstract_pointer_declarator" ("parameter_declaration" "type_descriptor" "abstract_function_declarator" "abstract_array_declarator" "_abstract_declarator" "abstract_parenthesized_declarator" "abstract_pointer_declarator")) + ("alignof_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("argument_list" ("attribute" "call_expression" "attribute_specifier" "ms_based_modifier")) + ("array_declarator" ("_field_declarator" "parameter_declaration" "type_definition" "_declarator" "pointer_declarator" "init_declarator" "attributed_declarator" "_type_declarator" "function_definition" "array_declarator" "field_declaration" "function_declarator" "declaration" "parenthesized_declarator")) + ("assignment_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("attribute" ("attribute_declaration")) + ("attribute_declaration" ("parameter_declaration" "attributed_declarator" "function_definition" "field_declaration" "attributed_statement" "declaration")) + ("attribute_specifier" ("union_specifier" "parameter_declaration" "function_definition" "enum_specifier" "field_declaration" "function_declarator" "struct_specifier" "declaration" "type_definition")) + ("attributed_declarator" ("_field_declarator" "parameter_declaration" "type_definition" "_declarator" "pointer_declarator" "init_declarator" "attributed_declarator" "_type_declarator" "function_definition" "array_declarator" "field_declaration" "function_declarator" "declaration" "parenthesized_declarator")) + ("attributed_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("binary_expression" ("pointer_expression" "update_expression" "sizeof_expression" "preproc_elif" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "preproc_if" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("bitfield_clause" ("field_declaration")) + ("break_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("call_expression" ("pointer_expression" "update_expression" "sizeof_expression" "preproc_elif" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "preproc_if" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "preproc_include" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("case_statement" ("_statement" "for_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("cast_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("char_literal" ("pointer_expression" "update_expression" "sizeof_expression" "preproc_elif" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "preproc_if" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("character" ("char_literal")) + ("comma_expression" ("parenthesized_expression" "for_statement" "expression_statement" "comma_expression" "return_statement")) + ("compound_literal_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("compound_statement" ("preproc_elif" "preproc_ifdef" "translation_unit" "do_statement" "preproc_elifdef" "for_statement" "preproc_if" "seh_try_statement" "declaration_list" "attributed_statement" "else_clause" "seh_finally_clause" "argument_list" "preproc_else" "if_statement" "switch_statement" "compound_statement" "_statement" "case_statement" "seh_except_clause" "while_statement" "function_definition" "labeled_statement")) + ("concatenated_string" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "gnu_asm_expression" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("conditional_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("continue_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("declaration" ("for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "preproc_if" "function_definition" "preproc_elifdef" "compound_statement" "declaration_list" "linkage_specification")) + ("declaration_list" ("linkage_specification")) + ("do_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("else_clause" ("if_statement")) + ("enum_specifier" ("parameter_declaration" "preproc_elif" "preproc_else" "_type_specifier" "preproc_ifdef" "translation_unit" "preproc_if" "type_descriptor" "function_definition" "preproc_elifdef" "field_declaration" "declaration_list" "compound_statement" "declaration" "type_definition")) + ("enumerator" ("enumerator_list")) + ("enumerator_list" ("enum_specifier")) + ("escape_sequence" ("char_literal" "string_literal")) + ("expression_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("false" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("field_declaration" ("preproc_else" "preproc_elif" "preproc_ifdef" "preproc_if" "field_declaration_list")) + ("field_declaration_list" ("union_specifier" "struct_specifier")) + ("field_designator" ("initializer_pair")) + ("field_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("field_identifier" ("_field_declarator" "offsetof_expression" "pointer_declarator" "attributed_declarator" "field_expression" "array_declarator" "field_declaration" "field_designator" "function_declarator" "parenthesized_declarator")) + ("for_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("function_declarator" ("_field_declarator" "parameter_declaration" "type_definition" "_declarator" "pointer_declarator" "init_declarator" "attributed_declarator" "_type_declarator" "function_definition" "array_declarator" "field_declaration" "function_declarator" "declaration" "parenthesized_declarator")) + ("function_definition" ("preproc_else" "preproc_elif" "preproc_ifdef" "translation_unit" "preproc_if" "preproc_elifdef" "compound_statement" "declaration_list" "linkage_specification")) + ("generic_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("gnu_asm_clobber_list" ("gnu_asm_expression")) + ("gnu_asm_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "function_declarator" "subscript_expression" "declaration" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("gnu_asm_goto_list" ("gnu_asm_expression")) + ("gnu_asm_input_operand" ("gnu_asm_input_operand_list")) + ("gnu_asm_input_operand_list" ("gnu_asm_expression")) + ("gnu_asm_output_operand" ("gnu_asm_output_operand_list")) + ("gnu_asm_output_operand_list" ("gnu_asm_expression")) + ("gnu_asm_qualifier" ("gnu_asm_expression")) + ("goto_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("identifier" ("pointer_expression" "update_expression" "sizeof_expression" "preproc_elif" "preproc_function_def" "gnu_asm_goto_list" "preproc_ifdef" "init_declarator" "attributed_declarator" "initializer_pair" "preproc_elifdef" "gnu_asm_output_operand" "binary_expression" "preproc_defined" "subscript_designator" "parenthesized_declarator" "parenthesized_expression" "call_expression" "for_statement" "parameter_declaration" "_declarator" "concatenated_string" "preproc_params" "preproc_if" "ms_declspec_modifier" "enumerator" "abstract_array_declarator" "return_statement" "preproc_def" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "parameter_list" "expression_statement" "assignment_expression" "generic_expression" "preproc_include" "macro_type_specifier" "attribute" "initializer_list" "function_declarator" "subscript_expression" "declaration" "_expression" "case_statement" "pointer_declarator" "conditional_expression" "unary_expression" "function_definition" "comma_expression")) + ("if_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("init_declarator" ("declaration")) + ("initializer_list" ("init_declarator" "compound_literal_expression" "initializer_pair" "initializer_list")) + ("initializer_pair" ("initializer_list")) + ("labeled_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("linkage_specification" ("preproc_else" "preproc_elif" "preproc_ifdef" "translation_unit" "preproc_if" "preproc_elifdef" "compound_statement" "declaration_list")) + ("macro_type_specifier" ("parameter_declaration" "preproc_elif" "preproc_else" "_type_specifier" "preproc_ifdef" "translation_unit" "preproc_if" "type_descriptor" "function_definition" "preproc_elifdef" "field_declaration" "declaration_list" "compound_statement" "declaration" "type_definition")) + ("ms_based_modifier" ("pointer_declarator")) + ("ms_call_modifier" ("function_definition")) + ("ms_declspec_modifier" ("union_specifier" "parameter_declaration" "function_definition" "field_declaration" "struct_specifier" "declaration")) + ("ms_pointer_modifier" ("pointer_declarator")) + ("ms_restrict_modifier" ("ms_pointer_modifier")) + ("ms_signed_ptr_modifier" ("ms_pointer_modifier")) + ("ms_unaligned_ptr_modifier" ("ms_pointer_modifier")) + ("ms_unsigned_ptr_modifier" ("ms_pointer_modifier")) + ("null" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("number_literal" ("pointer_expression" "update_expression" "sizeof_expression" "preproc_elif" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "preproc_if" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("offsetof_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("parameter_declaration" ("parameter_list")) + ("parameter_list" ("function_declarator" "abstract_function_declarator")) + ("parenthesized_declarator" ("_field_declarator" "parameter_declaration" "type_definition" "_declarator" "pointer_declarator" "init_declarator" "attributed_declarator" "_type_declarator" "function_definition" "array_declarator" "field_declaration" "function_declarator" "declaration" "parenthesized_declarator")) + ("parenthesized_expression" ("pointer_expression" "update_expression" "sizeof_expression" "preproc_elif" "init_declarator" "do_statement" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "preproc_if" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "if_statement" "generic_expression" "switch_statement" "initializer_list" "subscript_expression" "_expression" "case_statement" "seh_except_clause" "conditional_expression" "unary_expression" "while_statement" "comma_expression")) + ("pointer_declarator" ("_field_declarator" "parameter_declaration" "type_definition" "_declarator" "pointer_declarator" "init_declarator" "attributed_declarator" "_type_declarator" "function_definition" "array_declarator" "field_declaration" "function_declarator" "declaration" "parenthesized_declarator")) + ("pointer_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("preproc_arg" ("preproc_function_def" "preproc_def" "preproc_call")) + ("preproc_call" ("preproc_else" "preproc_elif" "preproc_ifdef" "translation_unit" "preproc_if" "preproc_elifdef" "compound_statement" "declaration_list" "field_declaration_list")) + ("preproc_def" ("preproc_else" "preproc_elif" "preproc_ifdef" "translation_unit" "preproc_if" "preproc_elifdef" "compound_statement" "declaration_list" "field_declaration_list")) + ("preproc_defined" ("parenthesized_expression" "argument_list" "preproc_elif" "preproc_if" "unary_expression" "binary_expression")) + ("preproc_directive" ("preproc_call")) + ("preproc_elif" ("preproc_elifdef" "preproc_ifdef" "preproc_if" "preproc_elif")) + ("preproc_elifdef" ("preproc_ifdef")) + ("preproc_else" ("preproc_elifdef" "preproc_ifdef" "preproc_if" "preproc_elif")) + ("preproc_function_def" ("preproc_else" "preproc_elif" "preproc_ifdef" "translation_unit" "preproc_if" "preproc_elifdef" "compound_statement" "declaration_list" "field_declaration_list")) + ("preproc_if" ("preproc_else" "preproc_elif" "preproc_ifdef" "translation_unit" "preproc_if" "preproc_elifdef" "compound_statement" "declaration_list" "field_declaration_list")) + ("preproc_ifdef" ("preproc_else" "preproc_elif" "preproc_ifdef" "translation_unit" "preproc_if" "preproc_elifdef" "compound_statement" "declaration_list" "field_declaration_list")) + ("preproc_include" ("preproc_else" "preproc_elif" "preproc_ifdef" "translation_unit" "preproc_if" "preproc_elifdef" "compound_statement" "declaration_list")) + ("preproc_params" ("preproc_function_def")) + ("primitive_type" ("preproc_elif" "_type_specifier" "preproc_ifdef" "translation_unit" "attributed_declarator" "preproc_elifdef" "parenthesized_declarator" "parameter_declaration" "type_descriptor" "preproc_if" "_type_declarator" "enum_specifier" "array_declarator" "declaration_list" "preproc_else" "compound_statement" "function_declarator" "declaration" "type_definition" "sized_type_specifier" "pointer_declarator" "function_definition" "field_declaration")) + ("return_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("seh_except_clause" ("seh_try_statement")) + ("seh_finally_clause" ("seh_try_statement")) + ("seh_leave_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("seh_try_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("sized_type_specifier" ("parameter_declaration" "preproc_elif" "preproc_else" "_type_specifier" "preproc_ifdef" "translation_unit" "preproc_if" "type_descriptor" "function_definition" "preproc_elifdef" "field_declaration" "declaration_list" "compound_statement" "declaration" "type_definition")) + ("sizeof_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("statement_identifier" ("labeled_statement" "goto_statement")) + ("storage_class_specifier" ("function_definition" "parameter_declaration" "declaration" "field_declaration")) + ("string_content" ("string_literal")) + ("string_literal" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "gnu_asm_expression" "initializer_pair" "gnu_asm_output_operand" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "concatenated_string" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "preproc_include" "initializer_list" "gnu_asm_clobber_list" "subscript_expression" "linkage_specification" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("struct_specifier" ("parameter_declaration" "preproc_elif" "preproc_else" "_type_specifier" "preproc_ifdef" "translation_unit" "preproc_if" "type_descriptor" "function_definition" "preproc_elifdef" "field_declaration" "declaration_list" "compound_statement" "declaration" "type_definition")) + ("subscript_designator" ("initializer_pair")) + ("subscript_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("switch_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ("system_lib_string" ("preproc_include")) + ("true" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("type_definition" ("preproc_else" "preproc_elif" "case_statement" "preproc_ifdef" "translation_unit" "preproc_if" "preproc_elifdef" "compound_statement" "declaration_list")) + ("type_descriptor" ("cast_expression" "offsetof_expression" "sizeof_expression" "compound_literal_expression" "generic_expression" "macro_type_specifier" "alignof_expression")) + ("type_identifier" ("union_specifier" "preproc_elif" "_type_specifier" "preproc_ifdef" "translation_unit" "attributed_declarator" "preproc_elifdef" "parenthesized_declarator" "parameter_declaration" "type_descriptor" "preproc_if" "_type_declarator" "enum_specifier" "array_declarator" "declaration_list" "preproc_else" "compound_statement" "function_declarator" "declaration" "type_definition" "sized_type_specifier" "pointer_declarator" "function_definition" "field_declaration" "struct_specifier")) + ("type_qualifier" ("parameter_declaration" "pointer_declarator" "type_descriptor" "function_definition" "abstract_array_declarator" "array_declarator" "field_declaration" "abstract_pointer_declarator" "declaration" "type_definition")) + ("unary_expression" ("pointer_expression" "update_expression" "sizeof_expression" "preproc_elif" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "preproc_if" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("union_specifier" ("parameter_declaration" "preproc_elif" "preproc_else" "_type_specifier" "preproc_ifdef" "translation_unit" "preproc_if" "type_descriptor" "function_definition" "preproc_elifdef" "field_declaration" "declaration_list" "compound_statement" "declaration" "type_definition")) + ("update_expression" ("pointer_expression" "update_expression" "sizeof_expression" "init_declarator" "initializer_pair" "binary_expression" "subscript_designator" "parenthesized_expression" "call_expression" "for_statement" "enumerator" "abstract_array_declarator" "return_statement" "field_expression" "array_declarator" "gnu_asm_input_operand" "bitfield_clause" "cast_expression" "argument_list" "expression_statement" "assignment_expression" "generic_expression" "initializer_list" "subscript_expression" "_expression" "case_statement" "conditional_expression" "unary_expression" "comma_expression")) + ("variadic_parameter" ("parameter_list")) + ("while_statement" ("_statement" "for_statement" "case_statement" "preproc_elif" "preproc_else" "preproc_ifdef" "translation_unit" "do_statement" "if_statement" "preproc_if" "while_statement" "labeled_statement" "preproc_elifdef" "compound_statement" "declaration_list" "attributed_statement" "else_clause")) + ) +) ;; END Inverse production rules for c ;; START All node types in c -(defconst combobulate-rules-c-types - '("_abstract_declarator" "_declarator" "_expression" "_field_declarator" "_statement" "_type_declarator" "_type_specifier" "abstract_array_declarator" "abstract_function_declarator" "abstract_parenthesized_declarator" "abstract_pointer_declarator" "alignof_expression" "argument_list" "array_declarator" "assignment_expression" "attribute" "attribute_declaration" "attribute_specifier" "attributed_declarator" "attributed_statement" "binary_expression" "bitfield_clause" "break_statement" "call_expression" "case_statement" "cast_expression" "char_literal" "character" "comma_expression" "comment" "compound_literal_expression" "compound_statement" "concatenated_string" "conditional_expression" "continue_statement" "declaration" "declaration_list" "do_statement" "else_clause" "enum_specifier" "enumerator" "enumerator_list" "escape_sequence" "expression_statement" "false" "field_declaration" "field_declaration_list" "field_designator" "field_expression" "field_identifier" "for_statement" "function_declarator" "function_definition" "generic_expression" "gnu_asm_clobber_list" "gnu_asm_expression" "gnu_asm_goto_list" "gnu_asm_input_operand" "gnu_asm_input_operand_list" "gnu_asm_output_operand" "gnu_asm_output_operand_list" "gnu_asm_qualifier" "goto_statement" "identifier" "if_statement" "init_declarator" "initializer_list" "initializer_pair" "labeled_statement" "linkage_specification" "macro_type_specifier" "ms_based_modifier" "ms_call_modifier" "ms_declspec_modifier" "ms_pointer_modifier" "ms_restrict_modifier" "ms_signed_ptr_modifier" "ms_unaligned_ptr_modifier" "ms_unsigned_ptr_modifier" "null" "number_literal" "offsetof_expression" "parameter_declaration" "parameter_list" "parenthesized_declarator" "parenthesized_expression" "pointer_declarator" "pointer_expression" "preproc_arg" "preproc_call" "preproc_def" "preproc_defined" "preproc_directive" "preproc_elif" "preproc_elifdef" "preproc_else" "preproc_function_def" "preproc_if" "preproc_ifdef" "preproc_include" "preproc_params" "primitive_type" "return_statement" "seh_except_clause" "seh_finally_clause" "seh_leave_statement" "seh_try_statement" "sized_type_specifier" "sizeof_expression" "statement_identifier" "storage_class_specifier" "string_content" "string_literal" "struct_specifier" "subscript_designator" "subscript_expression" "switch_statement" "system_lib_string" "translation_unit" "true" "type_definition" "type_descriptor" "type_identifier" "type_qualifier" "unary_expression" "union_specifier" "update_expression" "variadic_parameter" "while_statement") - ) +(defconst combobulate-rules-c-types + '("_abstract_declarator" "_declarator" "_expression" "_field_declarator" "_statement" "_type_declarator" "_type_specifier" "abstract_array_declarator" "abstract_function_declarator" "abstract_parenthesized_declarator" "abstract_pointer_declarator" "alignof_expression" "argument_list" "array_declarator" "assignment_expression" "attribute" "attribute_declaration" "attribute_specifier" "attributed_declarator" "attributed_statement" "binary_expression" "bitfield_clause" "break_statement" "call_expression" "case_statement" "cast_expression" "char_literal" "character" "comma_expression" "comment" "compound_literal_expression" "compound_statement" "concatenated_string" "conditional_expression" "continue_statement" "declaration" "declaration_list" "do_statement" "else_clause" "enum_specifier" "enumerator" "enumerator_list" "escape_sequence" "expression_statement" "false" "field_declaration" "field_declaration_list" "field_designator" "field_expression" "field_identifier" "for_statement" "function_declarator" "function_definition" "generic_expression" "gnu_asm_clobber_list" "gnu_asm_expression" "gnu_asm_goto_list" "gnu_asm_input_operand" "gnu_asm_input_operand_list" "gnu_asm_output_operand" "gnu_asm_output_operand_list" "gnu_asm_qualifier" "goto_statement" "identifier" "if_statement" "init_declarator" "initializer_list" "initializer_pair" "labeled_statement" "linkage_specification" "macro_type_specifier" "ms_based_modifier" "ms_call_modifier" "ms_declspec_modifier" "ms_pointer_modifier" "ms_restrict_modifier" "ms_signed_ptr_modifier" "ms_unaligned_ptr_modifier" "ms_unsigned_ptr_modifier" "null" "number_literal" "offsetof_expression" "parameter_declaration" "parameter_list" "parenthesized_declarator" "parenthesized_expression" "pointer_declarator" "pointer_expression" "preproc_arg" "preproc_call" "preproc_def" "preproc_defined" "preproc_directive" "preproc_elif" "preproc_elifdef" "preproc_else" "preproc_function_def" "preproc_if" "preproc_ifdef" "preproc_include" "preproc_params" "primitive_type" "return_statement" "seh_except_clause" "seh_finally_clause" "seh_leave_statement" "seh_try_statement" "sized_type_specifier" "sizeof_expression" "statement_identifier" "storage_class_specifier" "string_content" "string_literal" "struct_specifier" "subscript_designator" "subscript_expression" "switch_statement" "system_lib_string" "translation_unit" "true" "type_definition" "type_descriptor" "type_identifier" "type_qualifier" "unary_expression" "union_specifier" "update_expression" "variadic_parameter" "while_statement") +) ;; END All node types in c +;; START All supertypes in c +(defconst combobulate-rules-c-supertypes + '("_abstract_declarator" "_declarator" "_expression" "_field_declarator" "_statement" "_type_declarator" "_type_specifier") +) +;; END All supertypes in c ;; START Production rules for html -(defconst combobulate-rules-html - '(("attribute" (:*unnamed* ("attribute_name" "quoted_attribute_value" "attribute_value"))) - ("element" (:*unnamed* ("element" "doctype" "style_element" "self_closing_tag" "end_tag" "script_element" "entity" "erroneous_end_tag" "text" "start_tag"))) - ("end_tag" (:*unnamed* ("tag_name"))) - ("erroneous_end_tag" (:*unnamed* ("erroneous_end_tag_name"))) - ("fragment" (:*unnamed* ("element" "doctype" "style_element" "entity" "erroneous_end_tag" "text" "script_element"))) - ("quoted_attribute_value" (:*unnamed* ("attribute_value"))) - ("script_element" (:*unnamed* ("raw_text" "start_tag" "end_tag"))) - ("self_closing_tag" (:*unnamed* ("attribute" "tag_name"))) - ("start_tag" (:*unnamed* ("attribute" "tag_name"))) - ("style_element" (:*unnamed* ("raw_text" "start_tag" "end_tag"))) - ("attribute_name" (:*unnamed* nil)) - ("attribute_value" (:*unnamed* nil)) - ("comment" (:*unnamed* nil)) - ("entity" (:*unnamed* nil)) - ("erroneous_end_tag_name" (:*unnamed* nil)) - ("raw_text" (:*unnamed* nil)) - ("tag_name" (:*unnamed* nil)) - ("text" (:*unnamed* nil)) - )) +(defconst combobulate-rules-html + '(("attribute" (:*unnamed* ("attribute_name" "attribute_value" "quoted_attribute_value"))) + ("doctype" (:*unnamed* nil)) + ("element" (:*unnamed* ("doctype" "self_closing_tag" "script_element" "entity" "start_tag" "end_tag" "element" "style_element" "erroneous_end_tag" "text"))) + ("end_tag" (:*unnamed* ("tag_name"))) + ("erroneous_end_tag" (:*unnamed* ("erroneous_end_tag_name"))) + ("fragment" (:*unnamed* ("doctype" "style_element" "entity" "erroneous_end_tag" "script_element" "text" "element"))) + ("quoted_attribute_value" (:*unnamed* ("attribute_value"))) + ("script_element" (:*unnamed* ("raw_text" "start_tag" "end_tag"))) + ("self_closing_tag" (:*unnamed* ("attribute" "tag_name"))) + ("start_tag" (:*unnamed* ("attribute" "tag_name"))) + ("style_element" (:*unnamed* ("raw_text" "start_tag" "end_tag"))) + ("attribute_name" (:*unnamed* nil)) + ("attribute_value" (:*unnamed* nil)) + ("comment" (:*unnamed* nil)) + ("entity" (:*unnamed* nil)) + ("erroneous_end_tag_name" (:*unnamed* nil)) + ("raw_text" (:*unnamed* nil)) + ("tag_name" (:*unnamed* nil)) + ("text" (:*unnamed* nil)) +)) ;; END Production rules for html ;; START Inverse production rules for html -(defconst combobulate-rules-html-inverse - '(("attribute" ("self_closing_tag" "start_tag")) - ("attribute_name" ("attribute")) - ("attribute_value" ("attribute" "quoted_attribute_value")) - ("doctype" ("fragment" "element")) - ("element" ("fragment" "element")) - ("end_tag" ("element" "style_element" "script_element")) - ("entity" ("fragment" "element")) - ("erroneous_end_tag" ("fragment" "element")) - ("erroneous_end_tag_name" ("erroneous_end_tag")) - ("quoted_attribute_value" ("attribute")) - ("raw_text" ("style_element" "script_element")) - ("script_element" ("fragment" "element")) - ("self_closing_tag" ("element")) - ("start_tag" ("element" "style_element" "script_element")) - ("style_element" ("fragment" "element")) - ("tag_name" ("self_closing_tag" "start_tag" "end_tag")) - ("text" ("fragment" "element")) - ) - ) +(defconst combobulate-rules-html-inverse + '(("attribute" ("self_closing_tag" "start_tag")) + ("attribute_name" ("attribute")) + ("attribute_value" ("attribute" "quoted_attribute_value")) + ("doctype" ("fragment" "element")) + ("element" ("fragment" "element")) + ("end_tag" ("style_element" "element" "script_element")) + ("entity" ("fragment" "element")) + ("erroneous_end_tag" ("fragment" "element")) + ("erroneous_end_tag_name" ("erroneous_end_tag")) + ("quoted_attribute_value" ("attribute")) + ("raw_text" ("style_element" "script_element")) + ("script_element" ("fragment" "element")) + ("self_closing_tag" ("element")) + ("start_tag" ("style_element" "element" "script_element")) + ("style_element" ("fragment" "element")) + ("tag_name" ("self_closing_tag" "start_tag" "end_tag")) + ("text" ("fragment" "element")) + ) +) ;; END Inverse production rules for html ;; START All node types in html -(defconst combobulate-rules-html-types - '("attribute" "attribute_name" "attribute_value" "comment" "doctype" "element" "end_tag" "entity" "erroneous_end_tag" "erroneous_end_tag_name" "fragment" "quoted_attribute_value" "raw_text" "script_element" "self_closing_tag" "start_tag" "style_element" "tag_name" "text") - ) +(defconst combobulate-rules-html-types + '("attribute" "attribute_name" "attribute_value" "comment" "doctype" "element" "end_tag" "entity" "erroneous_end_tag" "erroneous_end_tag_name" "fragment" "quoted_attribute_value" "raw_text" "script_element" "self_closing_tag" "start_tag" "style_element" "tag_name" "text") +) ;; END All node types in html +;; START All supertypes in html +(defconst combobulate-rules-html-supertypes + nil +) +;; END All supertypes in html ;; START Production rules for toml -(defconst combobulate-rules-toml - '(("array" (:*unnamed* ("array" "string" "boolean" "local_date" "float" "local_time" "offset_date_time" "integer" "inline_table" "local_date_time"))) - ("document" (:*unnamed* ("table_array_element" "pair" "table"))) - ("dotted_key" (:*unnamed* ("bare_key" "quoted_key" "dotted_key"))) - ("inline_table" (:*unnamed* ("pair"))) - ("pair" (:*unnamed* ("array" "string" "boolean" "local_date" "float" "quoted_key" "local_time" "dotted_key" "offset_date_time" "integer" "bare_key" "inline_table" "local_date_time"))) - ("quoted_key" (:*unnamed* ("escape_sequence"))) - ("string" (:*unnamed* ("escape_sequence"))) - ("table" (:*unnamed* ("bare_key" "pair" "dotted_key" "quoted_key"))) - ("table_array_element" (:*unnamed* ("bare_key" "pair" "dotted_key" "quoted_key"))) - ("bare_key" (:*unnamed* nil)) - ("boolean" (:*unnamed* nil)) - ("comment" (:*unnamed* nil)) - ("escape_sequence" (:*unnamed* nil)) - ("local_date" (:*unnamed* nil)) - ("local_date_time" (:*unnamed* nil)) - ("local_time" (:*unnamed* nil)) - ("offset_date_time" (:*unnamed* nil)) - )) +(defconst combobulate-rules-toml + '(("array" (:*unnamed* ("local_date_time" "float" "offset_date_time" "string" "boolean" "inline_table" "array" "integer" "local_date" "local_time"))) + ("document" (:*unnamed* ("table_array_element" "pair" "table"))) + ("dotted_key" (:*unnamed* ("dotted_key" "bare_key" "quoted_key"))) + ("float" (:*unnamed* nil)) + ("inline_table" (:*unnamed* ("pair"))) + ("integer" (:*unnamed* nil)) + ("pair" (:*unnamed* ("local_date_time" "quoted_key" "float" "offset_date_time" "string" "boolean" "dotted_key" "inline_table" "bare_key" "array" "integer" "local_date" "local_time"))) + ("quoted_key" (:*unnamed* ("escape_sequence"))) + ("string" (:*unnamed* ("escape_sequence"))) + ("table" (:*unnamed* ("dotted_key" "pair" "bare_key" "quoted_key"))) + ("table_array_element" (:*unnamed* ("dotted_key" "pair" "bare_key" "quoted_key"))) + ("bare_key" (:*unnamed* nil)) + ("boolean" (:*unnamed* nil)) + ("comment" (:*unnamed* nil)) + ("escape_sequence" (:*unnamed* nil)) + ("local_date" (:*unnamed* nil)) + ("local_date_time" (:*unnamed* nil)) + ("local_time" (:*unnamed* nil)) + ("offset_date_time" (:*unnamed* nil)) +)) ;; END Production rules for toml ;; START Inverse production rules for toml -(defconst combobulate-rules-toml-inverse - '(("array" ("array" "pair")) - ("bare_key" ("table_array_element" "pair" "table" "dotted_key")) - ("boolean" ("array" "pair")) - ("dotted_key" ("table_array_element" "pair" "table" "dotted_key")) - ("escape_sequence" ("quoted_key" "string")) - ("float" ("array" "pair")) - ("inline_table" ("array" "pair")) - ("integer" ("array" "pair")) - ("local_date" ("array" "pair")) - ("local_date_time" ("array" "pair")) - ("local_time" ("array" "pair")) - ("offset_date_time" ("array" "pair")) - ("pair" ("inline_table" "document" "table" "table_array_element")) - ("quoted_key" ("table_array_element" "pair" "table" "dotted_key")) - ("string" ("array" "pair")) - ("table" ("document")) - ("table_array_element" ("document")) - ) - ) +(defconst combobulate-rules-toml-inverse + '(("array" ("array" "pair")) + ("bare_key" ("dotted_key" "table_array_element" "pair" "table")) + ("boolean" ("array" "pair")) + ("dotted_key" ("dotted_key" "table_array_element" "pair" "table")) + ("escape_sequence" ("string" "quoted_key")) + ("float" ("array" "pair")) + ("inline_table" ("array" "pair")) + ("integer" ("array" "pair")) + ("local_date" ("array" "pair")) + ("local_date_time" ("array" "pair")) + ("local_time" ("array" "pair")) + ("offset_date_time" ("array" "pair")) + ("pair" ("document" "inline_table" "table_array_element" "table")) + ("quoted_key" ("dotted_key" "table_array_element" "pair" "table")) + ("string" ("array" "pair")) + ("table" ("document")) + ("table_array_element" ("document")) + ) +) ;; END Inverse production rules for toml ;; START All node types in toml -(defconst combobulate-rules-toml-types - '("array" "bare_key" "boolean" "comment" "document" "dotted_key" "escape_sequence" "float" "inline_table" "integer" "local_date" "local_date_time" "local_time" "offset_date_time" "pair" "quoted_key" "string" "table" "table_array_element") - ) +(defconst combobulate-rules-toml-types + '("array" "bare_key" "boolean" "comment" "document" "dotted_key" "escape_sequence" "float" "inline_table" "integer" "local_date" "local_date_time" "local_time" "offset_date_time" "pair" "quoted_key" "string" "table" "table_array_element") +) ;; END All node types in toml +;; START All supertypes in toml +(defconst combobulate-rules-toml-supertypes + nil +) +;; END All supertypes in toml ;; START Production rules for json -(defconst combobulate-rules-json - '(("_value" (:*unnamed* ("array" "false" "string" "null" "number" "true" "object"))) - ("array" (:*unnamed* ("array" "false" "string" "null" "number" "true" "object"))) - ("document" (:*unnamed* ("array" "false" "string" "null" "number" "true" "object"))) - ("object" (:*unnamed* ("pair"))) - ("pair" (:key ("number" "string") :value ("array" "false" "string" "null" "number" "true" "object"))) - ("string" (:*unnamed* ("string_content"))) - ("string_content" (:*unnamed* ("escape_sequence"))) - ("comment" (:*unnamed* nil)) - ("escape_sequence" (:*unnamed* nil)) - ("false" (:*unnamed* nil)) - ("null" (:*unnamed* nil)) - ("number" (:*unnamed* nil)) - ("true" (:*unnamed* nil)) - )) +(defconst combobulate-rules-json + '(("_value" (:*unnamed* ("false" "object" "null" "array" "true" "string" "number"))) + ("array" (:*unnamed* ("false" "object" "null" "array" "true" "string" "number"))) + ("document" (:*unnamed* ("false" "object" "null" "array" "true" "string" "number"))) + ("object" (:*unnamed* ("pair"))) + ("pair" (:*unnamed* nil :key ("string" "number") :value ("false" "object" "null" "array" "true" "string" "number"))) + ("string" (:*unnamed* ("string_content"))) + ("string_content" (:*unnamed* ("escape_sequence"))) + ("comment" (:*unnamed* nil)) + ("escape_sequence" (:*unnamed* nil)) + ("false" (:*unnamed* nil)) + ("null" (:*unnamed* nil)) + ("number" (:*unnamed* nil)) + ("true" (:*unnamed* nil)) +)) ;; END Production rules for json ;; START Inverse production rules for json -(defconst combobulate-rules-json-inverse - '(("array" ("array" "_value" "document" "pair")) - ("escape_sequence" ("string_content")) - ("false" ("array" "_value" "document" "pair")) - ("null" ("array" "_value" "document" "pair")) - ("number" ("array" "_value" "document" "pair")) - ("object" ("array" "_value" "document" "pair")) - ("pair" ("object")) - ("string" ("array" "_value" "document" "pair")) - ("string_content" ("string")) - ("true" ("array" "_value" "document" "pair")) - ) - ) +(defconst combobulate-rules-json-inverse + '(("array" ("_value" "pair" "array" "document")) + ("escape_sequence" ("string_content")) + ("false" ("_value" "pair" "array" "document")) + ("null" ("_value" "pair" "array" "document")) + ("number" ("_value" "pair" "array" "document")) + ("object" ("_value" "pair" "array" "document")) + ("pair" ("object")) + ("string" ("_value" "pair" "array" "document")) + ("string_content" ("string")) + ("true" ("_value" "pair" "array" "document")) + ) +) ;; END Inverse production rules for json ;; START All node types in json -(defconst combobulate-rules-json-types - '("_value" "array" "comment" "document" "escape_sequence" "false" "null" "number" "object" "pair" "string" "string_content" "true") - ) +(defconst combobulate-rules-json-types + '("_value" "array" "comment" "document" "escape_sequence" "false" "null" "number" "object" "pair" "string" "string_content" "true") +) ;; END All node types in json +;; START All supertypes in json +(defconst combobulate-rules-json-supertypes + '("_value") +) +;; END All supertypes in json ;; START Auto-generated list of all languages -(defconst combobulate-rules-languages - '(c css go html javascript json jsx python toml tsx typescript yaml) - "A list of all the languages that have production rules.") +(defconst combobulate-rules-languages + '(c css go html javascript json jsx python toml tsx typescript yaml) + "A list of all the languages that have production rules.") ;; END Auto-generated list of all languages -;; START Auto-generated alist of all languages and their production rules -(defconst combobulate-rules-alist - `((c ,combobulate-rules-c) - (css ,combobulate-rules-css) - (go ,combobulate-rules-go) - (html ,combobulate-rules-html) - (javascript ,combobulate-rules-javascript) - (json ,combobulate-rules-json) - (jsx ,combobulate-rules-jsx) - (python ,combobulate-rules-python) - (toml ,combobulate-rules-toml) - (tsx ,combobulate-rules-tsx) - (typescript ,combobulate-rules-typescript) - (yaml ,combobulate-rules-yaml) - )) +(defconst combobulate-rules-alist + `((c ,combobulate-rules-c) + (css ,combobulate-rules-css) + (go ,combobulate-rules-go) + (html ,combobulate-rules-html) + (javascript ,combobulate-rules-javascript) + (json ,combobulate-rules-json) + (jsx ,combobulate-rules-jsx) + (python ,combobulate-rules-python) + (toml ,combobulate-rules-toml) + (tsx ,combobulate-rules-tsx) + (typescript ,combobulate-rules-typescript) + (yaml ,combobulate-rules-yaml) + )) -(defconst combobulate-rules-inverse-alist - `((c ,combobulate-rules-c-inverse) - (css ,combobulate-rules-css-inverse) - (go ,combobulate-rules-go-inverse) - (html ,combobulate-rules-html-inverse) - (javascript ,combobulate-rules-javascript-inverse) - (json ,combobulate-rules-json-inverse) - (jsx ,combobulate-rules-jsx-inverse) - (python ,combobulate-rules-python-inverse) - (toml ,combobulate-rules-toml-inverse) - (tsx ,combobulate-rules-tsx-inverse) - (typescript ,combobulate-rules-typescript-inverse) - (yaml ,combobulate-rules-yaml-inverse) - )) +(defconst combobulate-rules-inverse-alist + `((c ,combobulate-rules-c-inverse) + (css ,combobulate-rules-css-inverse) + (go ,combobulate-rules-go-inverse) + (html ,combobulate-rules-html-inverse) + (javascript ,combobulate-rules-javascript-inverse) + (json ,combobulate-rules-json-inverse) + (jsx ,combobulate-rules-jsx-inverse) + (python ,combobulate-rules-python-inverse) + (toml ,combobulate-rules-toml-inverse) + (tsx ,combobulate-rules-tsx-inverse) + (typescript ,combobulate-rules-typescript-inverse) + (yaml ,combobulate-rules-yaml-inverse) + )) -(defconst combobulate-rules-types-alist - `((c ,combobulate-rules-c-types) - (css ,combobulate-rules-css-types) - (go ,combobulate-rules-go-types) - (html ,combobulate-rules-html-types) - (javascript ,combobulate-rules-javascript-types) - (json ,combobulate-rules-json-types) - (jsx ,combobulate-rules-jsx-types) - (python ,combobulate-rules-python-types) - (toml ,combobulate-rules-toml-types) - (tsx ,combobulate-rules-tsx-types) - (typescript ,combobulate-rules-typescript-types) - (yaml ,combobulate-rules-yaml-types) - )) -;; END Auto-generated alist of all languages and their production rules +(defconst combobulate-rules-types-alist + `((c ,combobulate-rules-c-types) + (css ,combobulate-rules-css-types) + (go ,combobulate-rules-go-types) + (html ,combobulate-rules-html-types) + (javascript ,combobulate-rules-javascript-types) + (json ,combobulate-rules-json-types) + (jsx ,combobulate-rules-jsx-types) + (python ,combobulate-rules-python-types) + (toml ,combobulate-rules-toml-types) + (tsx ,combobulate-rules-tsx-types) + (typescript ,combobulate-rules-typescript-types) + (yaml ,combobulate-rules-yaml-types) + )) + +(defconst combobulate-rules-supertypes-alist + `((c ,combobulate-rules-c-supertypes) + (css ,combobulate-rules-css-supertypes) + (go ,combobulate-rules-go-supertypes) + (html ,combobulate-rules-html-supertypes) + (javascript ,combobulate-rules-javascript-supertypes) + (json ,combobulate-rules-json-supertypes) + (jsx ,combobulate-rules-jsx-supertypes) + (python ,combobulate-rules-python-supertypes) + (toml ,combobulate-rules-toml-supertypes) + (tsx ,combobulate-rules-tsx-supertypes) + (typescript ,combobulate-rules-typescript-supertypes) + (yaml ,combobulate-rules-yaml-supertypes) + )) (provide 'combobulate-rules) diff --git a/combobulate-settings.el b/combobulate-settings.el index 5afc544..8547c02 100644 --- a/combobulate-settings.el +++ b/combobulate-settings.el @@ -203,6 +203,15 @@ vector or an escaped string." "Face for active indicators, like the indentation display." :group 'combobulate-faces) +(defface combobulate-error-indicator-face '((t + (:box + (:line-width + (1 . 1) + :color "FireBrick2" :style flat-button) + :foreground "FireBrick1" :background "FireBrick4"))) + "Face for error indicators, like the indentation display." + :group 'combobulate-faces) + (defface combobulate-tree-branch-face '((t (:foreground "slate gray"))) "Face for the branches and guides in the display tree." :group 'combobulate-faces) @@ -351,6 +360,14 @@ languages like YAML and Python.") (defvar combobulate-envelope-symbol-prefix "combobulate-envelop-" "Prefix to use for symbol functions and variables for envelopes.") +(defvar-local combobulate-envelope-procedure-shorthand-alist nil + "Alist of shorthand symbols for envelope procedures. + +Each entry must be an alist with the key being the shorthand +symbol and the value being a valid combobulate procedure. + +Shorthands are used in lieu of inlining the procedure in the +`:nodes' property for an envelope. It is local to a language.") (defvar-local combobulate-manipulation-envelopes nil "Code generators that wrap -- envelop -- nodes") diff --git a/combobulate-yaml.el b/combobulate-yaml.el index 5afab17..e7c6b9e 100644 --- a/combobulate-yaml.el +++ b/combobulate-yaml.el @@ -97,7 +97,7 @@ :selector (:choose node :match-children t)))) (setq combobulate-navigation-default-procedures - '(:activation-nodes ((:nodes ("block_sequence" "block_node" "block_mapping_pair")))))) + '((:activation-nodes ((:nodes ("block_sequence" "block_node" "block_mapping_pair"))))))) (provide 'combobulate-yaml) ;;; combobulate-yaml.el ends here diff --git a/combobulate.el b/combobulate.el index df1dd32..5533daa 100644 --- a/combobulate.el +++ b/combobulate.el @@ -162,6 +162,11 @@ created." (hack-local-variables) ;; install the highlighter rules (combobulate-highlight-install parser-lang) + ;; `combobulate-navigation-default-nodes' draws its nodes from + ;; `combobulate-navigation-default-procedures'. + (setq-local combobulate-navigation-default-nodes + (combobulate-procedure-collect-activation-nodes + combobulate-navigation-default-procedures)) ;; this should come after the funcall to `setup-fn' as we need ;; the procedures setup and ready before we continue. (when combobulate-key-prefix diff --git a/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@1~after].tsx b/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@1~after].tsx index 3e529ab..c6f99a6 100644 --- a/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@1~after].tsx +++ b/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@1~after].tsx @@ -1,10 +1,9 @@ -// -*- combobulate-test-point-overlays: ((1 outline 205) (2 outline 220) (3 outline 242) (4 outline 256)); eval: (combobulate-test-fixture-mode t); -*- +// -*- combobulate-test-point-overlays: ((1 outline 221) (2 outline 236) (3 outline 258) (4 outline 266) (5 outline 287)); eval: (combobulate-test-fixture-mode t); -*- const test = () => ( - quux baz - {1 + 2} - {3 + 4} + quux baz + {1 + 2} This is a test field {3 + 4} ) diff --git a/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@2~after].tsx b/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@2~after].tsx index fc11043..beb057b 100644 --- a/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@2~after].tsx +++ b/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@2~after].tsx @@ -1,10 +1,9 @@ -// -*- combobulate-test-point-overlays: ((1 outline 205) (2 outline 220) (3 outline 242) (4 outline 256)); eval: (combobulate-test-fixture-mode t); -*- +// -*- combobulate-test-point-overlays: ((1 outline 221) (2 outline 236) (3 outline 258) (4 outline 266) (5 outline 287)); eval: (combobulate-test-fixture-mode t); -*- const test = () => ( - baz {1 + 2} - quux - {3 + 4} + baz {1 + 2} + quux This is a test field {3 + 4} ) diff --git a/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@3~after].tsx b/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@3~after].tsx index b06cbaf..4070dee 100644 --- a/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@3~after].tsx +++ b/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@3~after].tsx @@ -1,10 +1,9 @@ -// -*- combobulate-test-point-overlays: ((1 outline 205) (2 outline 220) (3 outline 242) (4 outline 256)); eval: (combobulate-test-fixture-mode t); -*- +// -*- combobulate-test-point-overlays: ((1 outline 221) (2 outline 236) (3 outline 258) (4 outline 266) (5 outline 287)); eval: (combobulate-test-fixture-mode t); -*- const test = () => ( - baz quux - {3 + 4} - {1 + 2} + baz quux + This is a test field {1 + 2} {3 + 4} ) diff --git a/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@4~after].tsx b/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@4~after].tsx index 7506552..b521981 100644 --- a/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@4~after].tsx +++ b/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@4~after].tsx @@ -1,10 +1,9 @@ -// -*- combobulate-test-point-overlays: ((1 outline 205) (2 outline 220) (3 outline 242) (4 outline 256)); eval: (combobulate-test-fixture-mode t); -*- +// -*- combobulate-test-point-overlays: ((1 outline 221) (2 outline 236) (3 outline 258) (4 outline 266) (5 outline 287)); eval: (combobulate-test-fixture-mode t); -*- const test = () => ( - baz quux - {1 + 2} - {3 + 4} + baz quux + {1 + 2} {3 + 4} This is a test field ) diff --git a/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@5~after].tsx b/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@5~after].tsx new file mode 100644 index 0000000..27f0511 --- /dev/null +++ b/tests/fixture-deltas/combobulate-drag-down/component-jsx.tsx[@5~after].tsx @@ -0,0 +1,9 @@ +// -*- combobulate-test-point-overlays: ((1 outline 221) (2 outline 236) (3 outline 258) (4 outline 266) (5 outline 287)); eval: (combobulate-test-fixture-mode t); -*- + +const test = () => ( + + + baz quux + {1 + 2} This is a test field {3 + 4} + + ) diff --git a/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@1~after].tsx b/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@1~after].tsx index 7506552..27f0511 100644 --- a/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@1~after].tsx +++ b/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@1~after].tsx @@ -1,10 +1,9 @@ -// -*- combobulate-test-point-overlays: ((1 outline 205) (2 outline 220) (3 outline 242) (4 outline 256)); eval: (combobulate-test-fixture-mode t); -*- +// -*- combobulate-test-point-overlays: ((1 outline 221) (2 outline 236) (3 outline 258) (4 outline 266) (5 outline 287)); eval: (combobulate-test-fixture-mode t); -*- const test = () => ( - baz quux - {1 + 2} - {3 + 4} + baz quux + {1 + 2} This is a test field {3 + 4} ) diff --git a/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@2~after].tsx b/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@2~after].tsx index 3e529ab..c6f99a6 100644 --- a/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@2~after].tsx +++ b/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@2~after].tsx @@ -1,10 +1,9 @@ -// -*- combobulate-test-point-overlays: ((1 outline 205) (2 outline 220) (3 outline 242) (4 outline 256)); eval: (combobulate-test-fixture-mode t); -*- +// -*- combobulate-test-point-overlays: ((1 outline 221) (2 outline 236) (3 outline 258) (4 outline 266) (5 outline 287)); eval: (combobulate-test-fixture-mode t); -*- const test = () => ( - quux baz - {1 + 2} - {3 + 4} + quux baz + {1 + 2} This is a test field {3 + 4} ) diff --git a/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@3~after].tsx b/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@3~after].tsx index fc11043..beb057b 100644 --- a/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@3~after].tsx +++ b/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@3~after].tsx @@ -1,10 +1,9 @@ -// -*- combobulate-test-point-overlays: ((1 outline 205) (2 outline 220) (3 outline 242) (4 outline 256)); eval: (combobulate-test-fixture-mode t); -*- +// -*- combobulate-test-point-overlays: ((1 outline 221) (2 outline 236) (3 outline 258) (4 outline 266) (5 outline 287)); eval: (combobulate-test-fixture-mode t); -*- const test = () => ( - baz {1 + 2} - quux - {3 + 4} + baz {1 + 2} + quux This is a test field {3 + 4} ) diff --git a/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@4~after].tsx b/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@4~after].tsx index b06cbaf..4070dee 100644 --- a/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@4~after].tsx +++ b/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@4~after].tsx @@ -1,10 +1,9 @@ -// -*- combobulate-test-point-overlays: ((1 outline 205) (2 outline 220) (3 outline 242) (4 outline 256)); eval: (combobulate-test-fixture-mode t); -*- +// -*- combobulate-test-point-overlays: ((1 outline 221) (2 outline 236) (3 outline 258) (4 outline 266) (5 outline 287)); eval: (combobulate-test-fixture-mode t); -*- const test = () => ( - baz quux - {3 + 4} - {1 + 2} + baz quux + This is a test field {1 + 2} {3 + 4} ) diff --git a/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@5~after].tsx b/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@5~after].tsx new file mode 100644 index 0000000..b521981 --- /dev/null +++ b/tests/fixture-deltas/combobulate-drag-up/component-jsx.tsx[@5~after].tsx @@ -0,0 +1,9 @@ +// -*- combobulate-test-point-overlays: ((1 outline 221) (2 outline 236) (3 outline 258) (4 outline 266) (5 outline 287)); eval: (combobulate-test-fixture-mode t); -*- + +const test = () => ( + + + baz quux + {1 + 2} {3 + 4} This is a test field + + ) diff --git a/tests/fixtures/down/if-statements.tsx b/tests/fixtures/down/if-statements.tsx new file mode 100644 index 0000000..0b2ea22 --- /dev/null +++ b/tests/fixtures/down/if-statements.tsx @@ -0,0 +1,11 @@ +// -*- combobulate-test-point-overlays: ((1 outline 251) (2 outline 257) (3 outline 261) (4 outline 271) (5 outline 277) (6 outline 284) (7 outline 292) (8 outline 306) (9 outline 307) (10 outline 311)); eval: (combobulate-test-fixture-mode t); -*- + +() => { + if (true) { + return ( +
+ {

Foo

} +
+ ) + } +} diff --git a/tests/fixtures/down/jsx-with-attributes.tsx b/tests/fixtures/down/jsx-with-attributes.tsx index bae88b0..0cf0050 100644 --- a/tests/fixtures/down/jsx-with-attributes.tsx +++ b/tests/fixtures/down/jsx-with-attributes.tsx @@ -1,4 +1,4 @@ -// -*- combobulate-test-point-overlays: ((1 outline 250) (2 outline 256) (3 outline 262) (4 outline 268) (5 outline 272) (6 outline 279) (7 outline 285) (8 outline 297) (9 outline 318) (10 outline 319)); eval: (combobulate-test-fixture-mode t); -*- +// -*- combobulate-test-point-overlays: ((1 outline 220) (2 outline 232) (3 outline 253) (4 outline 254) (5 outline 258) (6 outline 266)); eval: (combobulate-test-fixture-mode t); -*- const Foo = () => { return ( diff --git a/tests/fixtures/down/module-statements.tsx b/tests/fixtures/down/module-statements.tsx index a9c8ad9..7aa27e5 100644 --- a/tests/fixtures/down/module-statements.tsx +++ b/tests/fixtures/down/module-statements.tsx @@ -1,4 +1,4 @@ -// -*- combobulate-test-point-overlays: ((1 outline 250) (2 outline 256) (3 outline 260) (4 outline 264) (5 outline 275) (6 outline 278) (7 outline 284) (8 outline 289) (9 outline 315) (10 outline 317)); eval: (combobulate-test-fixture-mode t); -*- +// -*- combobulate-test-point-overlays: ((1 outline 201) (2 outline 207) (3 outline 211) (4 outline 215) (5 outline 226) (6 outline 229) (7 outline 235)); eval: (combobulate-test-fixture-mode t); -*- class Foo { constructor() { this.foo = 1; diff --git a/tests/fixtures/sibling/component-jsx.tsx b/tests/fixtures/sibling/component-jsx.tsx index 7506552..27f0511 100644 --- a/tests/fixtures/sibling/component-jsx.tsx +++ b/tests/fixtures/sibling/component-jsx.tsx @@ -1,10 +1,9 @@ -// -*- combobulate-test-point-overlays: ((1 outline 205) (2 outline 220) (3 outline 242) (4 outline 256)); eval: (combobulate-test-fixture-mode t); -*- +// -*- combobulate-test-point-overlays: ((1 outline 221) (2 outline 236) (3 outline 258) (4 outline 266) (5 outline 287)); eval: (combobulate-test-fixture-mode t); -*- const test = () => ( - baz quux - {1 + 2} - {3 + 4} + baz quux + {1 + 2} This is a test field {3 + 4} ) diff --git a/tests/test-combobulate-drag-down.gen.el b/tests/test-combobulate-drag-down.gen.el index 1606ca1..43d1e0e 100644 --- a/tests/test-combobulate-drag-down.gen.el +++ b/tests/test-combobulate-drag-down.gen.el @@ -38,6 +38,17 @@ (ert-deftest combobulate-test-tsx-combobulate-drag-down--component-jsx-4 () + "Test `combobulate' with `fixtures/sibling/component-jsx.tsx' in `tsx-ts-mode' mode." + (combobulate-test + (:language tsx :mode tsx-ts-mode :fixture "fixtures/sibling/component-jsx.tsx") + :tags + '(combobulate tsx tsx-ts-mode combobulate-drag-down) + (combobulate-test-go-to-marker 4) + (combobulate-drag-down) + (combobulate-compare-action-with-fixture-delta "./fixture-deltas/combobulate-drag-down/component-jsx.tsx[@4~after].tsx"))) + + +(ert-deftest combobulate-test-tsx-combobulate-drag-down--component-jsx-5 () "Test `combobulate' with `fixtures/sibling/component-jsx.tsx' in `tsx-ts-mode' mode." (combobulate-test (:language tsx :mode tsx-ts-mode :fixture "fixtures/sibling/component-jsx.tsx") @@ -45,9 +56,9 @@ '(combobulate tsx tsx-ts-mode combobulate-drag-down) (should-error (progn - (combobulate-test-go-to-marker 4) + (combobulate-test-go-to-marker 5) (combobulate-drag-down) - (combobulate-compare-action-with-fixture-delta "./fixture-deltas/combobulate-drag-down/component-jsx.tsx[@4~after].tsx"))))) + (combobulate-compare-action-with-fixture-delta "./fixture-deltas/combobulate-drag-down/component-jsx.tsx[@5~after].tsx"))))) (ert-deftest combobulate-test-css-combobulate-drag-down--css-declaration-1 () diff --git a/tests/test-combobulate-drag-up.gen.el b/tests/test-combobulate-drag-up.gen.el index ca979c3..e302173 100644 --- a/tests/test-combobulate-drag-up.gen.el +++ b/tests/test-combobulate-drag-up.gen.el @@ -4,6 +4,17 @@ (require 'combobulate-test-prelude) +(ert-deftest combobulate-test-tsx-combobulate-drag-up--component-jsx-5 () + "Test `combobulate' with `fixtures/sibling/component-jsx.tsx' in `tsx-ts-mode' mode." + (combobulate-test + (:language tsx :mode tsx-ts-mode :fixture "fixtures/sibling/component-jsx.tsx") + :tags + '(combobulate tsx tsx-ts-mode combobulate-drag-up) + (combobulate-test-go-to-marker 5) + (combobulate-drag-up) + (combobulate-compare-action-with-fixture-delta "./fixture-deltas/combobulate-drag-up/component-jsx.tsx[@5~after].tsx"))) + + (ert-deftest combobulate-test-tsx-combobulate-drag-up--component-jsx-4 () "Test `combobulate' with `fixtures/sibling/component-jsx.tsx' in `tsx-ts-mode' mode." (combobulate-test diff --git a/tests/test-combobulate-navigate-down.gen.el b/tests/test-combobulate-navigate-down.gen.el index 9227115..e73519e 100644 --- a/tests/test-combobulate-navigate-down.gen.el +++ b/tests/test-combobulate-navigate-down.gen.el @@ -84,10 +84,10 @@ (combobulate-test-assert-at-marker 5))) -(ert-deftest combobulate-test-tsx-combobulate-navigate-down--jsx-with-attributes-10 () - "Test `combobulate' with `fixtures/down/jsx-with-attributes.tsx' in `tsx-ts-mode' mode." +(ert-deftest combobulate-test-tsx-combobulate-navigate-down--if-statements-10 () + "Test `combobulate' with `fixtures/down/if-statements.tsx' in `tsx-ts-mode' mode." (combobulate-test - (:language tsx :mode tsx-ts-mode :fixture "fixtures/down/jsx-with-attributes.tsx") + (:language tsx :mode tsx-ts-mode :fixture "fixtures/down/if-statements.tsx") :tags '(combobulate tsx tsx-ts-mode combobulate-navigate-down) (combobulate-test-go-to-marker 1) @@ -119,7 +119,30 @@ (combobulate-test-assert-at-marker 10))) -(ert-deftest combobulate-test-tsx-combobulate-navigate-down--module-statements-10 () +(ert-deftest combobulate-test-tsx-combobulate-navigate-down--jsx-with-attributes-6 () + "Test `combobulate' with `fixtures/down/jsx-with-attributes.tsx' in `tsx-ts-mode' mode." + (combobulate-test + (:language tsx :mode tsx-ts-mode :fixture "fixtures/down/jsx-with-attributes.tsx") + :tags + '(combobulate tsx tsx-ts-mode combobulate-navigate-down) + (combobulate-test-go-to-marker 1) + (combobulate-navigate-down) + (combobulate-test-assert-at-marker 2) + (combobulate-test-go-to-marker 2) + (combobulate-navigate-down) + (combobulate-test-assert-at-marker 3) + (combobulate-test-go-to-marker 3) + (combobulate-navigate-down) + (combobulate-test-assert-at-marker 4) + (combobulate-test-go-to-marker 4) + (combobulate-navigate-down) + (combobulate-test-assert-at-marker 5) + (combobulate-test-go-to-marker 5) + (combobulate-navigate-down) + (combobulate-test-assert-at-marker 6))) + + +(ert-deftest combobulate-test-tsx-combobulate-navigate-down--module-statements-7 () "Test `combobulate' with `fixtures/down/module-statements.tsx' in `tsx-ts-mode' mode." (combobulate-test (:language tsx :mode tsx-ts-mode :fixture "fixtures/down/module-statements.tsx") @@ -142,16 +165,7 @@ (combobulate-test-assert-at-marker 6) (combobulate-test-go-to-marker 6) (combobulate-navigate-down) - (combobulate-test-assert-at-marker 7) - (combobulate-test-go-to-marker 7) - (combobulate-navigate-down) - (combobulate-test-assert-at-marker 8) - (combobulate-test-go-to-marker 8) - (combobulate-navigate-down) - (combobulate-test-assert-at-marker 9) - (combobulate-test-go-to-marker 9) - (combobulate-navigate-down) - (combobulate-test-assert-at-marker 10))) + (combobulate-test-assert-at-marker 7))) (ert-deftest combobulate-test-tsx-combobulate-navigate-down--nested-jsx-8 () diff --git a/tests/test-combobulate-navigate-next.gen.el b/tests/test-combobulate-navigate-next.gen.el index 8f59546..69105dc 100644 --- a/tests/test-combobulate-navigate-next.gen.el +++ b/tests/test-combobulate-navigate-next.gen.el @@ -4,21 +4,24 @@ (require 'combobulate-test-prelude) -(ert-deftest combobulate-test-tsx-combobulate-navigate-next--component-jsx-4 () +(ert-deftest combobulate-test-tsx-combobulate-navigate-next--component-jsx-5 () "Test `combobulate' with `fixtures/sibling/component-jsx.tsx' in `tsx-ts-mode' mode." (combobulate-test (:language tsx :mode tsx-ts-mode :fixture "fixtures/sibling/component-jsx.tsx") :tags '(combobulate tsx tsx-ts-mode combobulate-navigate-next) - (should-error - (progn - (combobulate-navigate-next))) - (should-error - (progn - (combobulate-navigate-next))) - (should-error - (progn - (combobulate-navigate-next))))) + (combobulate-test-go-to-marker 1) + (combobulate-navigate-next) + (combobulate-test-assert-at-marker 2) + (combobulate-test-go-to-marker 2) + (combobulate-navigate-next) + (combobulate-test-assert-at-marker 3) + (combobulate-test-go-to-marker 3) + (combobulate-navigate-next) + (combobulate-test-assert-at-marker 4) + (combobulate-test-go-to-marker 4) + (combobulate-navigate-next) + (combobulate-test-assert-at-marker 5))) (ert-deftest combobulate-test-css-combobulate-navigate-next--css-declaration-4 () diff --git a/tests/test-combobulate-navigate-previous.gen.el b/tests/test-combobulate-navigate-previous.gen.el index 921bf8e..645cc42 100644 --- a/tests/test-combobulate-navigate-previous.gen.el +++ b/tests/test-combobulate-navigate-previous.gen.el @@ -10,12 +10,15 @@ (:language tsx :mode tsx-ts-mode :fixture "fixtures/sibling/component-jsx.tsx") :tags '(combobulate tsx tsx-ts-mode combobulate-navigate-previous) - (should-error - (progn - (combobulate-navigate-previous))) - (should-error - (progn - (combobulate-navigate-previous))) + (combobulate-test-go-to-marker 4) + (combobulate-navigate-previous) + (combobulate-test-assert-at-marker 3) + (combobulate-test-go-to-marker 3) + (combobulate-navigate-previous) + (combobulate-test-assert-at-marker 2) + (combobulate-test-go-to-marker 2) + (combobulate-navigate-previous) + (combobulate-test-assert-at-marker 1) (combobulate-test-go-to-marker 1) (combobulate-navigate-previous) (combobulate-test-assert-at-marker 1))) diff --git a/tests/test-edit-procedure.el b/tests/test-edit-procedure.el index ea516bc..65ba1d2 100644 --- a/tests/test-edit-procedure.el +++ b/tests/test-edit-procedure.el @@ -277,13 +277,15 @@ (combobulate-test (:language tsx :mode tsx-ts-mode) (should-not (seq-difference (combobulate-procedure-expand-rules '("statement" (rule "statement"))) - '("statement" "statement_block" "while_statement" "switch_statement" - "if_statement" "do_statement" "throw_statement" "for_statement" - "export_statement" "debugger_statement" "return_statement" - "labeled_statement" "continue_statement" "with_statement" - "import_statement" "try_statement" "for_in_statement" - "declaration" "empty_statement" "expression_statement" - "break_statement"))))) + '("statement" "break_statement" "import_statement" "expression_statement" "do_statement" + "with_statement" "if_statement" "continue_statement" "switch_statement" "try_statement" + "ambient_declaration" "import_alias" "class_declaration" "type_alias_declaration" + "interface_declaration" "function_signature" "variable_declaration" + "generator_function_declaration" "internal_module" "enum_declaration" + "module" "lexical_declaration" "abstract_class_declaration" "function_declaration" + "empty_statement" "for_statement" "debugger_statement" "export_statement" + "statement_block" "throw_statement" "while_statement" "return_statement" + "labeled_statement" "for_in_statement"))))) (ert-deftest combobulate-procedure-expand-rules-irule () @@ -299,11 +301,14 @@ (combobulate-test (:language tsx :mode tsx-ts-mode) (should-not (seq-difference (combobulate-procedure-expand-rules '((exclude (rule "statement") "declaration" "expression_statement"))) - '("statement_block" "while_statement" "switch_statement" "if_statement" - "do_statement" "throw_statement" "for_statement" "export_statement" - "debugger_statement" "return_statement" "labeled_statement" "continue_statement" - "with_statement" "import_statement" "try_statement" "for_in_statement" - "empty_statement" "break_statement"))))) + '("break_statement" "import_statement" "do_statement" "with_statement" + "if_statement" "continue_statement" "switch_statement" "try_statement" + "ambient_declaration" "import_alias" "class_declaration" "type_alias_declaration" + "interface_declaration" "function_signature" "variable_declaration" "generator_function_declaration" + "internal_module" "enum_declaration" "module" "lexical_declaration" "abstract_class_declaration" + "function_declaration" "empty_statement" "for_statement" "debugger_statement" "export_statement" + "statement_block" "throw_statement" "while_statement" "return_statement" "labeled_statement" + "for_in_statement"))))) (ert-deftest combobulate-procedure-expand-rules-exclude-symmetry () :tags '(combobulate procedure)