@mgamil/mapx 0.2.4

package/queries/lua/symbols.scm

@@ -0,0 +1,29 @@
+; Lua Symbol Extraction Queries
+
+; Named function definitions: function foo() end
+(function_definition
+  name: [
+    (identifier) @symbol.name
+    (dot_index_expression (identifier) @symbol.name)
+  ]) @symbol.kind_function
+
+; Method definitions: function Class:method() end
+(function_definition
+  name: (method_index_expression
+    method: (identifier) @symbol.name)) @symbol.kind_method
+
+; Local function definitions: local function foo() end
+(local_function
+  name: (identifier) @symbol.name) @symbol.kind_function
+
+; Variable assignments (module-level tables as classes/modules)
+(variable_assignment
+  (variable_list
+    (variable (identifier) @symbol.name))) @symbol.kind_constant
+
+; Local variable declarations
+(local_variable_declaration
+  (variable_list
+    (variable (identifier) @symbol.name))) @symbol.kind_constant
+
+; Table constructors used as "classes" — captured via assignment above

package/queries/pascal/references.scm

@@ -0,0 +1,29 @@
+; Pascal Reference Extraction Queries
+
+; Uses clause (imports): uses SysUtils, Classes;
+(uses_clause
+  (identifier) @ref.target_import) @ref.type_import
+
+; Procedure/function calls
+(call_expression
+  name: (identifier) @ref.target_call) @ref.type_call
+
+; Method calls: obj.Method()
+(call_expression
+  name: (member_expression
+    (identifier) @ref.target_call)) @ref.type_call
+
+; Class inheritance: TFoo = class(TBar)
+(class_declaration
+  (class_heritage
+    (identifier) @ref.target_extends)) @ref.type_extends
+
+; Interface implementation
+(class_declaration
+  (class_heritage
+    (identifier) @ref.target_implements)) @ref.type_implements
+
+; Constructor calls: TFoo.Create
+(call_expression
+  name: (member_expression
+    object: (identifier) @ref.target_instantiation)) @ref.type_instantiation

package/queries/pascal/symbols.scm

@@ -0,0 +1,45 @@
+; Pascal Symbol Extraction Queries
+
+; Procedure declarations
+(procedure_declaration
+  name: (identifier) @symbol.name) @symbol.kind_function
+
+; Function declarations
+(function_declaration
+  name: (identifier) @symbol.name) @symbol.kind_function
+
+; Class/object type declarations
+(class_declaration
+  name: (identifier) @symbol.name) @symbol.kind_class
+
+; Record type declarations
+(record_declaration
+  name: (identifier) @symbol.name) @symbol.kind_struct
+
+; Interface declarations
+(interface_declaration
+  name: (identifier) @symbol.name) @symbol.kind_interface
+
+; Method declarations (procedures/functions inside a class)
+(method_declaration
+  name: (identifier) @symbol.name) @symbol.kind_method
+
+; Constant declarations
+(constant_declaration
+  name: (identifier) @symbol.name) @symbol.kind_constant
+
+; Type alias declarations
+(type_declaration
+  name: (identifier) @symbol.name) @symbol.kind_constant
+
+; Unit declaration (module equivalent)
+(unit_declaration
+  name: (identifier) @symbol.name) @symbol.kind_module
+
+; Variable declarations
+(variable_declaration
+  name: (identifier) @symbol.name) @symbol.kind_property
+
+; Enum type declarations
+(enum_type
+  (identifier) @symbol.name) @symbol.kind_enum

package/queries/php/references.scm

@@ -0,0 +1,109 @@
+; PHP Reference / Dependency Extraction
+
+(require_once_expression
+  (parenthesized_expression
+    (string
+      (string_content) @ref.target_require))) @ref.type_require
+
+(require_expression
+  (parenthesized_expression
+    (string
+      (string_content) @ref.target_require))) @ref.type_require
+
+(include_once_expression
+  (parenthesized_expression
+    (string
+      (string_content) @ref.target_require))) @ref.type_require
+
+(include_expression
+  (parenthesized_expression
+    (string
+      (string_content) @ref.target_require))) @ref.type_require
+
+; F05: Namespace use clauses
+(namespace_use_clause) @ref.target_use_clause
+
+; Inheritance
+(class_declaration
+  (base_clause
+    (name) @ref.target_extends)) @ref.type_extends
+
+(class_declaration
+  (class_interface_clause
+    (name) @ref.target_implements)) @ref.type_implements
+
+; Instantiation
+(object_creation_expression
+  (name) @ref.target_instantiation) @ref.type_instantiation
+
+; Scoped calls
+(scoped_call_expression
+  scope: (name) @ref.target_call) @ref.type_call
+
+; Member calls
+(member_call_expression
+  name: (name) @ref.target_call) @ref.type_call
+
+; F06: Type-hint dependencies
+(property_promotion_parameter) @ref.target_param
+(simple_parameter) @ref.target_param
+(method_declaration return_type: (_) @ref.target_return_type)
+(function_definition return_type: (_) @ref.target_return_type)
+(property_declaration) @ref.target_property
+
+; F07: Eloquent relationships
+(member_call_expression
+  name: (name) @ref.relation_method_name
+  (#match? @ref.relation_method_name "^(hasOne|hasMany|hasOneThrough|hasManyThrough|belongsTo|belongsToMany|morphTo|morphOne|morphMany|morphToMany|morphedByMany|hasOneOfMany)$")
+  arguments: (arguments) @ref.relation_arguments
+) @ref.type_relation_call
+
+; F08: Route controller binding (statically matched)
+(scoped_call_expression
+  scope: (name) @_route_class (#eq? @_route_class "Route")
+  name: (name) @ref.route_method_name
+  arguments: (arguments) @ref.route_arguments
+) @ref.type_route_call
+
+; F08: Middleware chaining
+(member_call_expression
+  name: (name) @_mw_name (#eq? @_mw_name "middleware")
+  arguments: (arguments) @ref.middleware_arguments
+) @ref.type_middleware_call
+
+; F09: Container Bindings
+(member_call_expression
+  name: (name) @ref.binding_method_name
+  (#match? @ref.binding_method_name "^(bind|singleton|scoped|instance|alias)$")
+  arguments: (arguments) @ref.binding_arguments
+) @ref.type_binding_call
+
+; F12: Event, Job, and Notification dispatch
+(function_call_expression
+  function: (name) @_fn (#match? @_fn "^(event|dispatch|dispatch_sync)$")
+  arguments: (arguments
+    (argument
+      (object_creation_expression
+        (name) @ref.target_dispatch)))) @ref.type_dispatch
+
+(scoped_call_expression
+  scope: (name) @ref.target_dispatch_static
+  name: (name) @_dispatch_method (#match? @_dispatch_method "^(dispatch|dispatchSync|dispatchIf|dispatchUnless|dispatchAfterResponse)$")
+) @ref.type_dispatch_static_call
+
+(member_call_expression
+  name: (name) @_notify_method (#match? @_notify_method "^(notify|notifyNow)$")
+  arguments: (arguments
+    (argument
+      (object_creation_expression
+        (name) @ref.target_notify)))) @ref.type_notify
+
+(scoped_call_expression
+  scope: (name) @_notif_facade (#eq? @_notif_facade "Notification")
+  name: (name) @_send (#match? @_send "^(send|sendNow)$")
+  arguments: (arguments
+    (argument)
+    (argument
+      (object_creation_expression
+        (name) @ref.target_notify)))) @ref.type_notify_facade
+

package/queries/php/symbols.scm

@@ -0,0 +1,33 @@
+; PHP Symbol Extraction Queries
+
+(class_declaration
+  name: (name) @symbol.name) @symbol.kind_class
+
+(interface_declaration
+  name: (name) @symbol.name) @symbol.kind_interface
+
+(trait_declaration
+  name: (name) @symbol.name) @symbol.kind_trait
+
+(enum_declaration
+  name: (name) @symbol.name) @symbol.kind_enum
+
+(function_definition
+  name: (name) @symbol.name) @symbol.kind_function
+
+(method_declaration
+  name: (name) @symbol.name) @symbol.kind_method
+
+(namespace_definition
+  (namespace_name) @symbol.name) @symbol.kind_namespace
+
+(property_declaration
+  (property_element
+    (variable_name) @symbol.name)) @symbol.kind_property
+
+(const_declaration
+  (const_element
+    (name) @symbol.name)) @symbol.kind_constant
+
+(enum_case
+  (name) @symbol.name) @symbol.kind_constant

package/queries/python/references.scm

@@ -0,0 +1,50 @@
+; Python Reference Extraction Queries
+
+; import statements: import foo, import foo.bar
+(import_statement
+  [(dotted_name) (identifier)] @ref.target_import) @ref.type_import
+
+; from ... import: from foo import bar
+(import_from_statement
+  [(dotted_name) (identifier)] @ref.target_import) @ref.type_import
+
+; Class inheritance: class Foo(Base, Mixin)
+(class_definition
+  superclasses: (argument_list
+    (identifier) @ref.target_extends)) @ref.type_extends
+
+; Class inheritance with dotted name: class Foo(module.Base)
+(class_definition
+  superclasses: (argument_list
+    (attribute
+      attribute: (identifier) @ref.target_extends))) @ref.type_extends
+
+; Function calls: foo()
+(call
+  function: (identifier) @ref.target_call) @ref.type_call
+
+; Method calls: obj.method()
+(call
+  function: (attribute
+    attribute: (identifier) @ref.target_call)) @ref.type_call
+
+; Instantiation: ClassName() — uppercase identifiers in call position
+; (handled as call — GenericWasmParser treats PascalCase calls as instantiation when needed)
+
+; Decorator references: @decorator
+(decorator
+  (identifier) @ref.target_call) @ref.type_call
+
+; Decorator with dotted name: @module.decorator
+(decorator
+  (attribute
+    attribute: (identifier) @ref.target_call)) @ref.type_call
+
+; Decorator with arguments: @decorator(args)
+(decorator
+  (call
+    function: (identifier) @ref.target_call)) @ref.type_call
+
+; Type annotations in function params (when available)
+(type
+  (identifier) @ref.target_call) @ref.type_call

package/queries/python/symbols.scm

@@ -0,0 +1,21 @@
+; Python Symbol Extraction Queries
+
+; Classes
+(class_definition
+  name: (identifier) @symbol.name) @symbol.kind_class
+
+; Functions (top-level)
+(function_definition
+  name: (identifier) @symbol.name) @symbol.kind_function
+
+; Decorators (captured as metadata, not a separate symbol kind)
+; Decorator names are captured via references
+
+; Module-level constants (UPPER_CASE assignments)
+(expression_statement
+  (assignment
+    left: (identifier) @symbol.name
+    (#match? @symbol.name "^[A-Z][A-Z0-9_]*$"))) @symbol.kind_constant
+
+; Property definitions via @property decorator are auto-promoted from function
+; to method by GenericWasmParser when inside a class scope

package/queries/ruby/references.scm

@@ -0,0 +1,48 @@
+; Ruby Reference Extraction Queries
+
+; require 'foo'
+(call
+  method: (identifier) @_req
+  arguments: (argument_list (string (string_content) @ref.target_require))
+  (#eq? @_req "require")) @ref.type_require
+
+; require_relative 'foo'
+(call
+  method: (identifier) @_reqr
+  arguments: (argument_list (string (string_content) @ref.target_require))
+  (#eq? @_reqr "require_relative")) @ref.type_require
+
+; Class inheritance: class Foo < Bar
+(class
+  superclass: (scope_resolution name: (constant) @ref.target_extends)) @ref.type_extends
+
+(class
+  superclass: (constant) @ref.target_extends) @ref.type_extends
+
+; include Module
+(call
+  method: (identifier) @_include
+  arguments: (argument_list (constant) @ref.target_extends)
+  (#eq? @_include "include")) @ref.type_extends
+
+; extend Module
+(call
+  method: (identifier) @_extend
+  arguments: (argument_list (constant) @ref.target_extends)
+  (#eq? @_extend "extend")) @ref.type_extends
+
+; prepend Module
+(call
+  method: (identifier) @_prepend
+  arguments: (argument_list (constant) @ref.target_extends)
+  (#eq? @_prepend "prepend")) @ref.type_extends
+
+; Method calls: foo(), self.foo(), obj.foo()
+(call
+  method: (identifier) @ref.target_call) @ref.type_call
+
+; Instantiation: ClassName.new
+(call
+  method: (identifier) @_new
+  receiver: (constant) @ref.target_instantiation
+  (#eq? @_new "new")) @ref.type_instantiation

package/queries/ruby/symbols.scm

@@ -0,0 +1,24 @@
+; Ruby Symbol Extraction Queries
+
+; Classes
+(class name: (constant) @symbol.name) @symbol.kind_class
+
+; Modules
+(module name: (constant) @symbol.name) @symbol.kind_module
+
+; Instance methods
+(method name: (identifier) @symbol.name) @symbol.kind_method
+
+; Class/singleton methods
+(singleton_method name: (identifier) @symbol.name) @symbol.kind_method
+
+; Constants (UPPER_CASE = value)
+(assignment
+  left: (constant) @symbol.name) @symbol.kind_constant
+
+; Attribute accessors (attr_reader, attr_writer, attr_accessor generate properties)
+(call
+  method: (identifier) @_attr_method
+  arguments: (argument_list
+    (simple_symbol) @symbol.name)
+  (#match? @_attr_method "^attr_(reader|writer|accessor)$")) @symbol.kind_property

package/queries/rust/references.scm

@@ -0,0 +1,31 @@
+; Rust Reference Extraction Queries
+
+; Use declarations
+(use_declaration
+  argument: (_) @ref.target_import) @ref.type_import
+
+; Function calls
+(call_expression
+  function: (identifier) @ref.target_call) @ref.type_call
+
+; Method calls: obj.method()
+(call_expression
+  function: (field_expression
+    field: (field_identifier) @ref.target_call)) @ref.type_call
+
+; Struct instantiation: StructName { ... }
+(struct_expression
+  name: (type_identifier) @ref.target_instantiation) @ref.type_instantiation
+
+; Trait implementation: impl Trait for Type
+(impl_item
+  trait: (type_identifier) @ref.target_implements) @ref.type_implements
+
+; Path-based calls: Module::function()
+(call_expression
+  function: (scoped_identifier
+    name: (identifier) @ref.target_call)) @ref.type_call
+
+; Macro invocations: macro_name!(...)
+(macro_invocation
+  macro: (identifier) @ref.target_call) @ref.type_call

package/queries/rust/symbols.scm

@@ -0,0 +1,35 @@
+; Rust Symbol Extraction Queries
+
+; Structs
+(struct_item name: (type_identifier) @symbol.name) @symbol.kind_struct
+
+; Traits (Rust's interface equivalent)
+(trait_item name: (type_identifier) @symbol.name) @symbol.kind_interface
+
+; Enums
+(enum_item name: (type_identifier) @symbol.name) @symbol.kind_enum
+
+; Functions
+(function_item name: (identifier) @symbol.name) @symbol.kind_function
+
+; Impl blocks (captured as class to represent implementation)
+(impl_item
+  type: (type_identifier) @symbol.name) @symbol.kind_class
+
+; Const items
+(const_item name: (identifier) @symbol.name) @symbol.kind_constant
+
+; Static items
+(static_item name: (identifier) @symbol.name) @symbol.kind_constant
+
+; Type alias
+(type_item name: (type_identifier) @symbol.name) @symbol.kind_constant
+
+; Module declarations
+(mod_item name: (identifier) @symbol.name) @symbol.kind_module
+
+; Macro definitions
+(macro_definition name: (identifier) @symbol.name) @symbol.kind_function
+
+; Enum variants
+(enum_variant name: (identifier) @symbol.name) @symbol.kind_constant

package/queries/scala/references.scm

@@ -0,0 +1,30 @@
+; Scala Reference Extraction Queries
+
+; Import declarations
+(import_declaration
+  (identifier) @ref.target_import) @ref.type_import
+
+; Wildcard imports
+(import_declaration
+  (stable_identifier (identifier) @ref.target_import)) @ref.type_import
+
+; Class extends: class Foo extends Bar
+(extends_clause
+  (type_identifier) @ref.target_extends) @ref.type_extends
+
+; Trait with: class Foo extends Bar with Trait
+(extends_clause
+  (type_identifier) @ref.target_extends) @ref.type_extends
+
+; Function/method calls
+(call_expression
+  function: (identifier) @ref.target_call) @ref.type_call
+
+; Method calls on receiver: obj.method()
+(call_expression
+  function: (field_expression
+    field: (identifier) @ref.target_call)) @ref.type_call
+
+; new ClassName()
+(instance_expression
+  (type_identifier) @ref.target_instantiation) @ref.type_instantiation

package/queries/scala/symbols.scm

@@ -0,0 +1,35 @@
+; Scala Symbol Extraction Queries
+
+; Classes
+(class_definition
+  name: (identifier) @symbol.name) @symbol.kind_class
+
+; Case classes
+; TODO: Add a case-class-specific pattern (the previous query duplicated the generic class_definition capture).
+; Objects (singletons)
+(object_definition
+  name: (identifier) @symbol.name) @symbol.kind_class
+
+; Traits
+(trait_definition
+  name: (identifier) @symbol.name) @symbol.kind_interface
+
+; Functions/methods
+(function_definition
+  name: (identifier) @symbol.name) @symbol.kind_function
+
+; Val declarations (immutable)
+(val_definition
+  pattern: (identifier) @symbol.name) @symbol.kind_constant
+
+; Var declarations (mutable)
+(var_definition
+  pattern: (identifier) @symbol.name) @symbol.kind_property
+
+; Type aliases
+(type_definition
+  name: (type_identifier) @symbol.name) @symbol.kind_constant
+
+; Package declarations
+(package_clause
+  (package_identifier) @symbol.name) @symbol.kind_namespace

package/queries/svelte/references.scm

@@ -0,0 +1,20 @@
+; Svelte Reference Extraction Queries
+
+; Import statements
+(import_statement
+  source: (string (string_fragment) @ref.target_import)) @ref.type_import
+
+; Function calls
+(call_expression
+  function: (identifier) @ref.target_call) @ref.type_call
+
+; Method calls: obj.method()
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @ref.target_call)) @ref.type_call
+
+; Svelte store subscriptions and lifecycle
+(call_expression
+  function: (identifier) @_fn
+  (#match? @_fn "^(onMount|onDestroy|beforeUpdate|afterUpdate|createEventDispatcher|writable|readable|derived|get|tick)$")
+  ) @ref.type_call

package/queries/svelte/symbols.scm

@@ -0,0 +1,30 @@
+; Svelte Symbol Extraction Queries
+; Svelte SFC files contain <script> blocks using JavaScript/TypeScript AST
+
+; Functions
+(function_declaration
+  name: (identifier) @symbol.name) @symbol.kind_function
+
+; Arrow functions / const declarations (stores, handlers, reactive declarations)
+(variable_declarator
+  name: (identifier) @symbol.name
+  value: (arrow_function)) @symbol.kind_function
+
+; Class declarations
+(class_declaration
+  name: (identifier) @symbol.name) @symbol.kind_class
+
+; Method definitions (in class or object)
+(method_definition
+  name: (property_identifier) @symbol.name) @symbol.kind_method
+
+; Exported let declarations (component props in Svelte)
+(export_statement
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @symbol.name))) @symbol.kind_property
+
+; Top-level const/let declarations (reactive state)
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @symbol.name)) @symbol.kind_constant

package/queries/swift/references.scm

@@ -0,0 +1,22 @@
+; Swift Reference Extraction Queries
+
+; Import statements
+(import_declaration
+  (identifier) @ref.target_import) @ref.type_import
+
+; Function/method calls
+(call_expression
+  (simple_identifier) @ref.target_call) @ref.type_call
+
+; Method calls on receiver: obj.method()
+(call_expression
+  (navigation_expression
+    (navigation_suffix (simple_identifier) @ref.target_call))) @ref.type_call
+
+; Protocol conformance / inheritance: class Foo: Bar, Protocol
+(inheritance_specifier
+  (type_identifier) @ref.target_extends) @ref.type_extends
+
+; Instantiation: ClassName()
+(call_expression
+  (type_identifier) @ref.target_instantiation) @ref.type_instantiation

package/queries/swift/symbols.scm

@@ -0,0 +1,37 @@
+; Swift Symbol Extraction Queries
+
+; Classes
+(class_declaration
+  name: (type_identifier) @symbol.name) @symbol.kind_class
+
+; Structs
+(struct_declaration
+  name: (type_identifier) @symbol.name) @symbol.kind_struct
+
+; Protocols (Swift's interface equivalent)
+(protocol_declaration
+  name: (type_identifier) @symbol.name) @symbol.kind_interface
+
+; Enums
+(enum_declaration
+  name: (type_identifier) @symbol.name) @symbol.kind_enum
+
+; Functions (using simple_identifier for name)
+(function_declaration
+  name: (simple_identifier) @symbol.name) @symbol.kind_function
+
+; Initializers
+(init_declaration) @symbol.kind_method
+
+; Property declarations
+(property_declaration
+  (pattern
+    (simple_identifier) @symbol.name)) @symbol.kind_property
+
+; Type aliases
+(typealias_declaration
+  name: (type_identifier) @symbol.name) @symbol.kind_constant
+
+; Extensions
+(extension_declaration
+  (type_identifier) @symbol.name) @symbol.kind_class

package/queries/typescript/references.scm

@@ -0,0 +1,25 @@
+; TypeScript Reference / Dependency Extraction
+
+(import_statement
+  source: (string) @ref.target_import) @ref.type_import
+
+(import_clause
+  (named_imports
+    (import_specifier
+      name: (identifier) @ref.target_import_name))) @ref.type_import
+
+(class_declaration
+  (class_heritage
+    (extends_clause
+      (identifier) @ref.target_extends))) @ref.type_extends
+
+(class_declaration
+  (class_heritage
+    (implements_clause
+      (type_identifier) @ref.target_implements))) @ref.type_implements
+
+(new_expression
+  constructor: (identifier) @ref.target_instantiation) @ref.type_instantiation
+
+(call_expression
+  function: (identifier) @ref.target_call) @ref.type_call