tree-sitter-analyzer 1.9.17.1__py3-none-any.whl

tree_sitter_analyzer/queries/javascript.py

@@ -0,0 +1,724 @@
+#!/usr/bin/env python3
+"""
+JavaScript Language Queries
+
+Comprehensive Tree-sitter queries for JavaScript language constructs.
+Covers functions, classes, variables, imports, exports, and modern JavaScript features.
+Equivalent to Java query coverage for consistent language support.
+"""
+
+# JavaScript-specific query library
+JAVASCRIPT_QUERIES: dict[str, str] = {
+    # --- Basic Structure ---
+    "function": """
+    (function_declaration) @function
+    """,
+    "function_declaration": """
+    (function_declaration
+        name: (identifier) @function_name
+        parameters: (formal_parameters) @parameters
+        body: (statement_block) @body) @function_declaration
+    """,
+    "function_expression": """
+    (function_expression
+        name: (identifier)? @function_name
+        parameters: (formal_parameters) @parameters
+        body: (statement_block) @body) @function_expression
+    """,
+    "arrow_function": """
+    (arrow_function
+        parameters: (formal_parameters) @parameters
+        body: (_) @body) @arrow_function
+    """,
+    "method_definition": """
+    (method_definition
+        name: (property_identifier) @method_name
+        parameters: (formal_parameters) @parameters
+        body: (statement_block) @body) @method_definition
+    """,
+    "async_function": """
+    (function_declaration
+        "async" @async_keyword
+        name: (identifier) @function_name
+        parameters: (formal_parameters) @parameters
+        body: (statement_block) @body) @async_function
+    """,
+    "generator_function": """
+    (generator_function_declaration
+        name: (identifier) @function_name
+        parameters: (formal_parameters) @parameters
+        body: (statement_block) @body) @generator_function
+    """,
+    # --- Classes ---
+    "class": """
+    (class_declaration) @class
+    """,
+    "class_declaration": """
+    (class_declaration
+        name: (identifier) @class_name
+        (class_heritage)? @superclass
+        body: (class_body) @body) @class_declaration
+    """,
+    "class_expression": """
+    (class_expression
+        name: (identifier)? @class_name
+        (class_heritage)? @superclass
+        body: (class_body) @body) @class_expression
+    """,
+    "class_method": """
+    (class_body
+        (method_definition
+            name: (property_identifier) @method_name
+            parameters: (formal_parameters) @parameters
+            body: (statement_block) @body)) @class_method
+    """,
+    "constructor": """
+    (method_definition
+        name: (property_identifier) @constructor_name
+        (#match? @constructor_name "constructor")
+        parameters: (formal_parameters) @parameters
+        body: (statement_block) @body) @constructor
+    """,
+    "getter": """
+    (method_definition
+        "get" @get_keyword
+        name: (property_identifier) @getter_name
+        body: (statement_block) @body) @getter
+    """,
+    "setter": """
+    (method_definition
+        "set" @set_keyword
+        name: (property_identifier) @setter_name
+        parameters: (formal_parameters) @parameters
+        body: (statement_block) @body) @setter
+    """,
+    "static_method": """
+    (method_definition
+        "static" @static_keyword
+        name: (property_identifier) @method_name
+        parameters: (formal_parameters) @parameters
+        body: (statement_block) @body) @static_method
+    """,
+    "private_method": """
+    (method_definition
+        name: (private_property_identifier) @method_name
+        parameters: (formal_parameters) @parameters
+        body: (statement_block) @body) @private_method
+    """,
+    # --- Variables ---
+    "variable": """
+    (variable_declaration) @variable
+    """,
+    "var_declaration": """
+    (variable_declaration
+        (variable_declarator
+            name: (identifier) @variable_name
+            value: (_)? @value)) @var_declaration
+    """,
+    "let_declaration": """
+    (lexical_declaration
+        "let" @let_keyword
+        (variable_declarator
+            name: (identifier) @variable_name
+            value: (_)? @value)) @let_declaration
+    """,
+    "const_declaration": """
+    (lexical_declaration
+        "const" @const_keyword
+        (variable_declarator
+            name: (identifier) @variable_name
+            value: (_) @value)) @const_declaration
+    """,
+    "destructuring_assignment": """
+    (variable_declarator
+        name: (array_pattern) @array_destructuring
+        value: (_) @value) @destructuring_assignment
+    """,
+    "object_destructuring": """
+    (variable_declarator
+        name: (object_pattern) @object_destructuring
+        value: (_) @value) @object_destructuring
+    """,
+    # --- Imports and Exports ---
+    "import": """
+    (import_statement) @import
+    """,
+    "import_statement": """
+    (import_statement
+        source: (string) @source) @import_statement
+    """,
+    "import_default": """
+    (import_statement
+        (import_clause
+            (import_default_specifier
+                (identifier) @default_name))
+        source: (string) @source) @import_default
+    """,
+    "import_named": """
+    (import_statement
+        (import_clause
+            (named_imports
+                (import_specifier
+                    name: (identifier) @import_name
+                    alias: (identifier)? @alias)))
+        source: (string) @source) @import_named
+    """,
+    "import_namespace": """
+    (import_statement
+        (import_clause
+            (namespace_import
+                (identifier) @namespace_name))
+        source: (string) @source) @import_namespace
+    """,
+    "dynamic_import": """
+    (call_expression
+        function: (identifier) @import_function
+        (#match? @import_function "import")
+        arguments: (arguments (string) @source)) @dynamic_import
+    """,
+    "export": """
+    (export_statement) @export
+    """,
+    "export_default": """
+    (export_statement
+        "default" @default_keyword
+        declaration: (_) @declaration) @export_default
+    """,
+    "export_named": """
+    (export_statement
+        (export_clause
+            (export_specifier
+                name: (identifier) @export_name
+                alias: (identifier)? @alias))) @export_named
+    """,
+    "export_all": """
+    (export_statement
+        "*" @star
+        source: (string) @source) @export_all
+    """,
+    # --- Objects and Properties ---
+    "object": """
+    (object) @object
+    """,
+    "object_literal": """
+    (object
+        (pair
+            key: (_) @key
+            value: (_) @value)*) @object_literal
+    """,
+    "property_definition": """
+    (property_definition
+        property: (_) @property_name
+        value: (_)? @value) @property_definition
+    """,
+    "computed_property": """
+    (pair
+        key: (computed_property_name) @computed_key
+        value: (_) @value) @computed_property
+    """,
+    "shorthand_property": """
+    (shorthand_property_identifier) @shorthand_property
+    """,
+    "method_property": """
+    (pair
+        key: (_) @method_name
+        value: (function_expression) @method_function) @method_property
+    """,
+    # --- Control Flow ---
+    "if_statement": """
+    (if_statement
+        condition: (_) @condition
+        consequence: (_) @then_branch
+        alternative: (_)? @else_branch) @if_statement
+    """,
+    "for_statement": """
+    (for_statement
+        initializer: (_)? @init
+        condition: (_)? @condition
+        increment: (_)? @update
+        body: (_) @body) @for_statement
+    """,
+    "for_in_statement": """
+    (for_in_statement
+        left: (_) @variable
+        right: (_) @object
+        body: (_) @body) @for_in_statement
+    """,
+    "for_of_statement": """
+    (for_of_statement
+        left: (_) @variable
+        right: (_) @iterable
+        body: (_) @body) @for_of_statement
+    """,
+    "while_statement": """
+    (while_statement
+        condition: (_) @condition
+        body: (_) @body) @while_statement
+    """,
+    "do_statement": """
+    (do_statement
+        body: (_) @body
+        condition: (_) @condition) @do_statement
+    """,
+    "switch_statement": """
+    (switch_statement
+        discriminant: (_) @discriminant
+        body: (switch_body) @body) @switch_statement
+    """,
+    "case_clause": """
+    (switch_case
+        value: (_) @case_value
+        body: (_)* @case_body) @case_clause
+    """,
+    "default_clause": """
+    (switch_default
+        body: (_)* @default_body) @default_clause
+    """,
+    # --- Error Handling ---
+    "try_statement": """
+    (try_statement
+        body: (statement_block) @try_body
+        handler: (catch_clause)? @catch_handler
+        finalizer: (finally_clause)? @finally_block) @try_statement
+    """,
+    "catch_clause": """
+    (catch_clause
+        parameter: (identifier)? @error_parameter
+        body: (statement_block) @catch_body) @catch_clause
+    """,
+    "finally_clause": """
+    (finally_clause
+        body: (statement_block) @finally_body) @finally_clause
+    """,
+    "throw_statement": """
+    (throw_statement
+        argument: (_) @thrown_expression) @throw_statement
+    """,
+    # --- Modern JavaScript Features ---
+    "template_literal": """
+    (template_literal) @template_literal
+    """,
+    "template_substitution": """
+    (template_substitution
+        expression: (_) @substitution_expr) @template_substitution
+    """,
+    "spread_element": """
+    (spread_element
+        argument: (_) @spread_argument) @spread_element
+    """,
+    "rest_parameter": """
+    (rest_parameter
+        pattern: (identifier) @rest_name) @rest_parameter
+    """,
+    "await_expression": """
+    (await_expression
+        argument: (_) @awaited_expression) @await_expression
+    """,
+    "yield_expression": """
+    (yield_expression
+        argument: (_)? @yielded_value) @yield_expression
+    """,
+    # --- JSX (React) ---
+    "jsx_element": """
+    (jsx_element
+        open_tag: (jsx_opening_element) @open_tag
+        close_tag: (jsx_closing_element)? @close_tag) @jsx_element
+    """,
+    "jsx_self_closing": """
+    (jsx_self_closing_element
+        name: (_) @element_name) @jsx_self_closing
+    """,
+    "jsx_attribute": """
+    (jsx_attribute
+        name: (property_identifier) @attribute_name
+        value: (_)? @attribute_value) @jsx_attribute
+    """,
+    "jsx_expression": """
+    (jsx_expression
+        expression: (_) @jsx_expression_content) @jsx_expression
+    """,
+    # --- Comments and Documentation ---
+    "comment": """
+    (comment) @comment
+    """,
+    "jsdoc_comment": """
+    (comment) @jsdoc_comment
+    (#match? @jsdoc_comment "^/\\*\\*")
+    """,
+    "line_comment": """
+    (comment) @line_comment
+    (#match? @line_comment "^//")
+    """,
+    "block_comment": """
+    (comment) @block_comment
+    (#match? @block_comment "^/\\*(?!\\*)")
+    """,
+    # --- Framework-specific Patterns ---
+    "react_component": """
+    (function_declaration
+        name: (identifier) @component_name
+        (#match? @component_name "^[A-Z]")
+        body: (statement_block
+            (return_statement
+                argument: (jsx_element)))) @react_component
+    """,
+    "react_hook": """
+    (call_expression
+        function: (identifier) @hook_name
+        (#match? @hook_name "^use[A-Z]")) @react_hook
+    """,
+    "node_require": """
+    (call_expression
+        function: (identifier) @require_function
+        (#match? @require_function "require")
+        arguments: (arguments (string) @module_path)) @node_require
+    """,
+    "module_exports": """
+    (assignment_expression
+        left: (member_expression
+            object: (identifier) @module_object
+            (#match? @module_object "module")
+            property: (property_identifier) @exports_property
+            (#match? @exports_property "exports"))
+        right: (_) @exported_value) @module_exports
+    """,
+    # --- Name-only Extraction ---
+    "function_name": """
+    (function_declaration
+        name: (identifier) @function_name)
+    """,
+    "class_name": """
+    (class_declaration
+        name: (identifier) @class_name)
+    """,
+    "variable_name": """
+    (variable_declarator
+        name: (identifier) @variable_name)
+    """,
+    # --- Advanced Patterns ---
+    "closure": """
+    (function_expression
+        body: (statement_block
+            (return_statement
+                argument: (function_expression)))) @closure
+    """,
+    "callback_function": """
+    (call_expression
+        arguments: (arguments
+            (function_expression) @callback_function)) @callback_call
+    """,
+    "promise_chain": """
+    (call_expression
+        function: (member_expression
+            object: (_) @promise_object
+            property: (property_identifier) @chain_method
+            (#match? @chain_method "^(then|catch|finally)$"))) @promise_chain
+    """,
+    "event_listener": """
+    (call_expression
+        function: (member_expression
+            property: (property_identifier) @listener_method
+            (#match? @listener_method "^(addEventListener|on)$"))
+        arguments: (arguments
+            (string) @event_type
+            (function_expression) @event_handler)) @event_listener
+    """,
+    "iife": """
+    (call_expression
+        function: (function_expression) @iife_function) @iife
+    """,
+    "module_pattern": """
+    (variable_declarator
+        name: (identifier) @module_name
+        value: (call_expression
+            function: (function_expression) @module_function)) @module_pattern
+    """,
+}
+
+# Query descriptions
+JAVASCRIPT_QUERY_DESCRIPTIONS: dict[str, str] = {
+    "function": "Search JavaScript function declarations",
+    "function_declaration": "Search function declarations with details",
+    "function_expression": "Search function expressions",
+    "arrow_function": "Search arrow functions",
+    "method_definition": "Search method definitions",
+    "async_function": "Search async function declarations",
+    "generator_function": "Search generator functions",
+    "class": "Search JavaScript class declarations",
+    "class_declaration": "Search class declarations with details",
+    "class_expression": "Search class expressions",
+    "class_method": "Search class methods",
+    "constructor": "Search class constructors",
+    "getter": "Search getter methods",
+    "setter": "Search setter methods",
+    "static_method": "Search static methods",
+    "private_method": "Search private methods",
+    "variable": "Search variable declarations",
+    "var_declaration": "Search var declarations",
+    "let_declaration": "Search let declarations",
+    "const_declaration": "Search const declarations",
+    "destructuring_assignment": "Search destructuring assignments",
+    "object_destructuring": "Search object destructuring",
+    "import": "Search import statements",
+    "import_statement": "Search import statements with details",
+    "import_default": "Search default imports",
+    "import_named": "Search named imports",
+    "import_namespace": "Search namespace imports",
+    "dynamic_import": "Search dynamic imports",
+    "export": "Search export statements",
+    "export_default": "Search default exports",
+    "export_named": "Search named exports",
+    "export_all": "Search export all statements",
+    "object": "Search object literals",
+    "object_literal": "Search object literals with properties",
+    "property_definition": "Search property definitions",
+    "computed_property": "Search computed properties",
+    "shorthand_property": "Search shorthand properties",
+    "method_property": "Search method properties",
+    "if_statement": "Search if statements",
+    "for_statement": "Search for loops",
+    "for_in_statement": "Search for-in loops",
+    "for_of_statement": "Search for-of loops",
+    "while_statement": "Search while loops",
+    "do_statement": "Search do-while loops",
+    "switch_statement": "Search switch statements",
+    "case_clause": "Search switch case clauses",
+    "default_clause": "Search switch default clauses",
+    "try_statement": "Search try-catch statements",
+    "catch_clause": "Search catch clauses",
+    "finally_clause": "Search finally clauses",
+    "throw_statement": "Search throw statements",
+    "template_literal": "Search template literals",
+    "template_substitution": "Search template substitutions",
+    "spread_element": "Search spread elements",
+    "rest_parameter": "Search rest parameters",
+    "await_expression": "Search await expressions",
+    "yield_expression": "Search yield expressions",
+    "jsx_element": "Search JSX elements",
+    "jsx_self_closing": "Search self-closing JSX elements",
+    "jsx_attribute": "Search JSX attributes",
+    "jsx_expression": "Search JSX expressions",
+    "comment": "Search all comments",
+    "jsdoc_comment": "Search JSDoc comments",
+    "line_comment": "Search line comments",
+    "block_comment": "Search block comments",
+    "react_component": "Search React components",
+    "react_hook": "Search React hooks",
+    "node_require": "Search Node.js require statements",
+    "module_exports": "Search Node.js module exports",
+    "function_name": "Search function names only",
+    "class_name": "Search class names only",
+    "variable_name": "Search variable names only",
+    "closure": "Search closures",
+    "callback_function": "Search callback functions passed as arguments",
+    "promise_chain": "Search Promise chain patterns (.then, .catch, .finally)",
+    "event_listener": "Search event listener registrations",
+    "iife": "Search immediately invoked function expressions",
+    "module_pattern": "Search module patterns",
+}
+
+# Legacy query definitions for backward compatibility
+FUNCTIONS = """
+(function_declaration
+    name: (identifier) @function.name
+    parameters: (formal_parameters) @function.params
+    body: (statement_block) @function.body) @function.declaration
+
+(function_expression
+    name: (identifier)? @function.name
+    parameters: (formal_parameters) @function.params
+    body: (statement_block) @function.body) @function.expression
+
+(arrow_function
+    parameters: (formal_parameters) @function.params
+    body: (_) @function.body) @function.arrow
+
+(method_definition
+    name: (property_identifier) @function.name
+    parameters: (formal_parameters) @function.params
+    body: (statement_block) @function.body) @method.definition
+"""
+
+CLASSES = """
+(class_declaration
+    name: (identifier) @class.name
+    (class_heritage)? @class.superclass
+    body: (class_body) @class.body) @class.declaration
+"""
+
+VARIABLES = """
+(variable_declaration
+    (variable_declarator
+        name: (identifier) @variable.name
+        value: (_)? @variable.value)) @variable.declaration
+
+(lexical_declaration
+    (variable_declarator
+        name: (identifier) @variable.name
+        value: (_)? @variable.value)) @variable.lexical
+"""
+
+IMPORTS = """
+(import_statement
+    source: (string) @import.source) @import.statement
+
+(import_statement
+    (import_clause
+        (named_imports
+            (import_specifier
+                name: (identifier) @import.name
+                alias: (identifier)? @import.alias)))) @import.named
+
+(import_statement
+    (import_clause
+        (import_default_specifier
+            (identifier) @import.default))) @import.default
+
+(import_statement
+    (import_clause
+        (namespace_import
+            (identifier) @import.namespace))) @import.namespace
+"""
+
+EXPORTS = """
+(export_statement
+    declaration: (_) @export.declaration) @export.statement
+
+(export_statement
+    (export_clause
+        (export_specifier
+            name: (identifier) @export.name
+            alias: (identifier)? @export.alias))) @export.named
+"""
+
+OBJECTS = """
+(object
+    (pair
+        key: (_) @property.key
+        value: (_) @property.value)) @object.literal
+
+(property_definition
+    property: (_) @property.name
+    value: (_)? @property.value) @property.definition
+"""
+
+COMMENTS = """
+(comment) @comment
+"""
+
+# Convert to ALL_QUERIES format for dynamic loader compatibility
+ALL_QUERIES = {}
+for query_name, query_string in JAVASCRIPT_QUERIES.items():
+    description = JAVASCRIPT_QUERY_DESCRIPTIONS.get(query_name, "No description")
+    ALL_QUERIES[query_name] = {"query": query_string, "description": description}
+
+# Add legacy queries for backward compatibility
+ALL_QUERIES["functions"] = {
+    "query": FUNCTIONS,
+    "description": "Search all function declarations, expressions, and methods",
+}
+ALL_QUERIES["classes"] = {
+    "query": CLASSES,
+    "description": "Search all class declarations and expressions",
+}
+ALL_QUERIES["variables"] = {
+    "query": VARIABLES,
+    "description": "Search all variable declarations (var, let, const)",
+}
+ALL_QUERIES["imports"] = {
+    "query": IMPORTS,
+    "description": "Search all import statements and clauses",
+}
+ALL_QUERIES["exports"] = {
+    "query": EXPORTS,
+    "description": "Search all export statements",
+}
+ALL_QUERIES["objects"] = {
+    "query": OBJECTS,
+    "description": "Search object literals and property definitions",
+}
+ALL_QUERIES["comments"] = {"query": COMMENTS, "description": "Search all comments"}
+
+# Add missing method queries
+ALL_QUERIES["method"] = {
+    "query": """
+(method_definition
+    name: (property_identifier) @method_name
+    parameters: (formal_parameters) @parameters
+    body: (statement_block) @body) @method_definition
+""",
+    "description": "Search method definitions",
+}
+ALL_QUERIES["methods"] = {
+    "query": """
+(method_definition
+    name: (property_identifier) @method_name
+    parameters: (formal_parameters) @parameters
+    body: (statement_block) @body) @method_definition
+""",
+    "description": "Search method definitions",
+}
+
+
+def get_javascript_query(name: str) -> str:
+    """
+    Get the specified JavaScript query
+
+    Args:
+        name: Query name
+
+    Returns:
+        Query string
+
+    Raises:
+        ValueError: When query is not found
+    """
+    if name not in JAVASCRIPT_QUERIES:
+        available = list(JAVASCRIPT_QUERIES.keys())
+        raise ValueError(
+            f"JavaScript query '{name}' does not exist. Available: {available}"
+        )
+
+    return JAVASCRIPT_QUERIES[name]
+
+
+def get_javascript_query_description(name: str) -> str:
+    """
+    Get the description of the specified JavaScript query
+
+    Args:
+        name: Query name
+
+    Returns:
+        Query description
+    """
+    return JAVASCRIPT_QUERY_DESCRIPTIONS.get(name, "No description")
+
+
+def get_query(name: str) -> str:
+    """Get a specific query by name."""
+    if name in ALL_QUERIES:
+        return ALL_QUERIES[name]["query"]
+    raise ValueError(
+        f"Query '{name}' not found. Available queries: {list(ALL_QUERIES.keys())}"
+    )
+
+
+def get_all_queries() -> dict:
+    """Get all available queries."""
+    return ALL_QUERIES
+
+
+def list_queries() -> list:
+    """List all available query names."""
+    return list(ALL_QUERIES.keys())
+
+
+def get_available_javascript_queries() -> list[str]:
+    """
+    Get list of available JavaScript queries
+
+    Returns:
+        List of query names
+    """
+    return list(JAVASCRIPT_QUERIES.keys())