from pathlib import Path

from typing import Any, Dict, Optional, Tuple

import re

from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logger, warning_logger

from codegraphcontext.utils.tree_sitter_manager import execute_query

# Reference: https://github.com/tree-sitter/tree-sitter-php/blob/master/queries/tags.scm

PHP_QUERIES = {

"functions": """

(function_definition

name: (name) @name

parameters: (formal_parameters) @params

) @function_node

(method_declaration

name: (name) @name

parameters: (formal_parameters) @params

) @function_node

""",

"classes": """

(class_declaration

name: (name) @name

) @class

(interface_declaration

name: (name) @name

) @interface

(trait_declaration

name: (name) @name

) @trait

""",

"imports": """

(use_declaration) @import

""",

"calls": """

(function_call_expression

function: [

(qualified_name) @name

(name) @name

]

) @call_node

(member_call_expression

name: (name) @name

) @call_node

(scoped_call_expression

name: (name) @name

) @call_node

(object_creation_expression) @call_node

""",

"variables": """

(variable_name) @variable

""",

}

class PhpTreeSitterParser:

def __init__(self, generic_parser_wrapper: Any):

self.generic_parser_wrapper = generic_parser_wrapper

self.language_name = "php"

self.language = generic_parser_wrapper.language

self.parser = generic_parser_wrapper.parser

def parse(self, path: Path, is_dependency: bool = False, index_source: bool = False) -> Dict[str, Any]:

try:

self.index_source = index_source

with open(path, 'r', encoding='utf-8', errors='ignore') as f:

source_code = f.read()

if not source_code.strip():

warning_logger(f"Empty or whitespace-only file: {path}")

return {

"path": str(path),

"functions": [],

"classes": [],

"interfaces": [],

"traits": [],

"variables": [],

"imports": [],

"function_calls": [],

"is_dependency": is_dependency,

"lang": self.language_name,

}

tree = self.parser.parse(bytes(source_code, "utf8"))

parsed_functions = []

parsed_classes = []

parsed_interfaces = []

parsed_traits = []

parsed_variables = []

parsed_imports = []

parsed_calls = []

var_type_map = {}

for capture_name in ["functions", "classes", "imports", "variables", "calls"]:

query = PHP_QUERIES[capture_name]

results = execute_query(self.language, query, tree.root_node)

if capture_name == "functions":

parsed_functions = self._parse_functions(results, source_code, path, var_type_map)

elif capture_name == "classes":

parsed_classes, parsed_interfaces, parsed_traits = self._parse_types(results, source_code, path)

elif capture_name == "imports":

parsed_imports = self._parse_imports(results, source_code)

elif capture_name == "calls":

parsed_calls = self._parse_calls(results, source_code, var_type_map)

elif capture_name == "variables":

parsed_variables = self._parse_variables(results, source_code, path, var_type_map)

return {

"path": str(path),

"functions": parsed_functions,

"classes": parsed_classes,

"interfaces": parsed_interfaces,

"traits": parsed_traits,

"variables": parsed_variables,

"imports": parsed_imports,

"function_calls": parsed_calls,

"is_dependency": is_dependency,

"lang": self.language_name,

}

except Exception as e:

error_logger(f"Error parsing PHP file {path}: {e}")

return {

"path": str(path),

"functions": [],

"classes": [],

"interfaces": [],

"traits": [],

"variables": [],

"imports": [],

"function_calls": [],

"is_dependency": is_dependency,

"lang": self.language_name,

}

def _get_parent_context(self, node: Any) -> Tuple[Optional[str], Optional[str], Optional[int]]:

curr = node.parent

while curr:

if curr.type in ("function_definition", "method_declaration", "class_declaration", "interface_declaration", "trait_declaration"):

name_node = curr.child_by_field_name("name")

return (

self._get_node_text(name_node) if name_node else None,

curr.type,

curr.start_point[0] + 1,

)

curr = curr.parent

return None, None, None

def _get_node_text(self, node: Any) -> str:

if not node: return ""

return node.text.decode("utf-8")

def _parse_functions(self, captures: list, source_code: str, path: Path, var_type_map: dict) -> list[Dict[str, Any]]:

functions = []

seen_nodes = set()

for node, capture_name in captures:

if capture_name == "function_node":

node_id = (node.start_byte, node.end_byte, node.type)

if node_id in seen_nodes:

continue

seen_nodes.add(node_id)

try:

start_line = node.start_point[0] + 1

end_line = node.end_point[0] + 1

name_node = node.child_by_field_name("name")

if name_node:

func_name = self._get_node_text(name_node)

params_node = node.child_by_field_name("parameters")

parameters = []

if params_node:

# PHP parameters: function($a, $b)

for child in params_node.children:

if "variable_name" in child.type or "simple_parameter" in child.type:

var_node = child if "variable_name" in child.type else child.child_by_field_name("name")

type_node = child.child_by_field_name("type") if "simple_parameter" in child.type else None

if var_node:

var_name = self._get_node_text(var_node)

parameters.append(var_name)

if type_node:

var_type = self._get_node_text(type_node)

# Extract actual type from union/nullable types

var_type = var_type.lstrip("?").split("|")[0].strip()

var_type_map[(func_name, var_name)] = var_type

source_text = self._get_node_text(node)

# Get class context

context_name, context_type, context_line = self._get_parent_context(node)

func_data = {

"name": func_name,

"parameters": parameters,

"line_number": start_line,

"end_line": end_line,

"path": str(path),

"lang": self.language_name,

"context": context_name,

"context_type": context_type,

"class_context": context_name if context_type and ("class" in context_type or "interface" in context_type or "trait" in context_type) else None

}

if self.index_source:

func_data["source"] = source_text

functions.append(func_data)

except Exception as e:

error_logger(f"Error parsing function in {path}: {e}")

continue

return functions

def _parse_types(self, captures: list, source_code: str, path: Path) -> Tuple[list, list, list]:

classes = []

interfaces = []

traits = []

seen_nodes = set()

for node, capture_name in captures:

if capture_name in ("class", "interface", "trait"):

node_id = (node.start_byte, node.end_byte, node.type)

if node_id in seen_nodes:

continue

seen_nodes.add(node_id)

try:

start_line = node.start_point[0] + 1

end_line = node.end_point[0] + 1

name_node = node.child_by_field_name("name")

if name_node:

type_name = self._get_node_text(name_node)

source_text = self._get_node_text(node)

bases = []

# Look for extends/implements

base_clause_node = node.child_by_field_name('base_clause') # extends

interfaces_clause_node = node.child_by_field_name('interfaces_clause') # implements

if base_clause_node:

# Children of base_clause contain identifiers

for child in base_clause_node.children:

if child.type in ('name', 'qualified_name'):

bases.append(self._get_node_text(child))

if interfaces_clause_node:

for child in interfaces_clause_node.children:

if child.type in ('name', 'qualified_name'):

bases.append(self._get_node_text(child))

type_data = {

"name": type_name,

"line_number": start_line,

"end_line": end_line,

"bases": bases,

"path": str(path),

"lang": self.language_name,

}

if self.index_source:

type_data["source"] = source_text

if capture_name == "class":

classes.append(type_data)

elif capture_name == "interface":

interfaces.append(type_data)

elif capture_name == "trait":

traits.append(type_data)

except Exception as e:

error_logger(f"Error parsing type in {path}: {e}")

continue

return classes, interfaces, traits

def _parse_variables(self, captures: list, source_code: str, path: Path, var_type_map: dict) -> list[Dict[str, Any]]:

variables = []

seen_vars = set()

for node, capture_name in captures:

if capture_name == "variable":

try:

var_name = self._get_node_text(node)

start_line = node.start_point[0] + 1

start_byte = node.start_byte

if start_byte in seen_vars:

continue

seen_vars.add(start_byte)

ctx_name, ctx_type, ctx_line = self._get_parent_context(node)

# Infer type from assignment

inferred_type = "mixed"

parent = node.parent

if parent and parent.type == 'assignment_expression':

# $var = new Class();

left = parent.child_by_field_name('left')

right = parent.child_by_field_name('right')

# Ensure we are looking at the left side variable

if left == node and right and right.type == 'object_creation_expression':

# Extract class name from right side

for child in right.children:

if child.type in ('name', 'qualified_name'):

inferred_type = self._get_node_text(child)

var_type_map[(ctx_name, var_name)] = inferred_type

break

variables.append({

"name": var_name,

"type": inferred_type,

"line_number": start_line,

"path": str(path),

"lang": self.language_name,

"context": ctx_name,

"class_context": ctx_name if ctx_type and ("class" in ctx_type or "interface" in ctx_type or "trait" in ctx_type) else None

})

except Exception as e:

continue

return variables

def _parse_imports(self, captures: list, source_code: str) -> list[dict]:

imports = []

for node, capture_name in captures:

if capture_name == "import":

try:

import_text = self._get_node_text(node)

# use Foo\Bar as Baz;

# Node usually has children: name (qualified_name), optional alias

name_node = None

alias_node = None

for child in node.children:

if child.type == "qualified_name" or child.type == "name":

name_node = child

# Alias in PHP: use X as Y; The 'as' is usually implicit structure or explicit?

# Tree sitter grammar: use_declaration -> use_clause -> (use_as_clause (qualified_name) (name))

# Assuming simple handling for now, extracting string from text

# Regex might be safer given tree complexity for `use`

import_match = re.search(r'use\s+([\w\\]+)(?:\s+as\s+(\w+))?', import_text)

if import_match:

import_path = import_match.group(1).strip()

alias = import_match.group(2).strip() if import_match.group(2) else None

import_data = {

"name": import_path,

"full_import_name": import_text,

"line_number": node.start_point[0] + 1,

"alias": alias,

"context": (None, None),

"lang": self.language_name,

"is_dependency": False,

}

imports.append(import_data)

except Exception as e:

error_logger(f"Error parsing import: {e}")

continue

return imports

def _parse_calls(self, captures: list, source_code: str, var_type_map: dict) -> list[dict]:

calls = []

seen_calls = set()

for node, capture_name in captures:

# For object_creation_expression without @name capture on inner node, we catch the whole node as @call_node

# But the 'calls' query uses @name for function/method calls on the identifier, and @call_node for full expression.

# My query change: (object_creation_expression) @call_node

# This means for obj creation, I won't get a separate @name capture. I need to iterate @call_node captures too?

# actually execute_query returns (node, capture_name).

# Let's handle 'name' capture which gives us the function name

if capture_name == "name":

try:

call_name = self._get_node_text(node)

line_number = node.start_point[0] + 1

# Ensure we identify the full call node

call_node = node.parent

while call_node and call_node.type not in ("function_call_expression", "member_call_expression", "scoped_call_expression"):

call_node = call_node.parent

if not call_node:

continue # It might be a name inside object creation or something we handle otherwise

# Avoid duplicates

call_key = f"{call_name}_{line_number}"

if call_key in seen_calls:

continue

seen_calls.add(call_key)

# Extract arguments

args = []

args_node = call_node.child_by_field_name('arguments')

if args_node:

for arg in args_node.children:

if arg.type not in ('(', ')', ','):

args.append(self._get_node_text(arg))

full_name = call_name # Default

inferred_obj_type = None

ctx_name, ctx_type, ctx_line = self._get_parent_context(node)

if call_node.type == 'member_call_expression':

# $obj->method()

obj_node = call_node.child_by_field_name('object')

if obj_node:

receiver = self._get_node_text(obj_node)

full_name = f"{receiver}.{call_name}"

if receiver.startswith("$"):

inferred_obj_type = var_type_map.get((ctx_name, receiver))

elif call_node.type == 'scoped_call_expression':

# Class::method()

scope_node = call_node.child_by_field_name('scope')

if scope_node:

receiver = self._get_node_text(scope_node)

full_name = f"{receiver}.{call_name}"

inferred_obj_type = receiver

call_data = {

"name": call_name,

"full_name": full_name,

"line_number": line_number,

"args": args,

"inferred_obj_type": inferred_obj_type,

"context": (ctx_name, ctx_type, ctx_line),

"class_context": (ctx_name, ctx_line) if ctx_type and ("class" in ctx_type or "interface" in ctx_type or "trait" in ctx_type) else (None, None),

"lang": self.language_name,

"is_dependency": False,

}

calls.append(call_data)

except Exception as e:

error_logger(f"Error parsing call: {e}")

continue

# Handle object creation separately as capture is on the whole node

elif capture_name == "call_node" and node.type == "object_creation_expression":

try:

line_number = node.start_point[0] + 1

# Find class name (child not named 'arguments')

class_name = "Unknown"

for child in node.children:

if child.type in ('name', 'qualified_name'):

class_name = self._get_node_text(child)

break

if child.type == "variable_name": # dynamic new $class()

class_name = self._get_node_text(child)

break

call_key = f"new {class_name}_{line_number}"

if call_key in seen_calls:

continue

seen_calls.add(call_key)

args = []

args_node = node.child_by_field_name('arguments')

if args_node:

for arg in args_node.children:

if arg.type not in ('(', ')', ','):

args.append(self._get_node_text(arg))

full_name = class_name # For GraphBuilder to link to Class

ctx_name, ctx_type, ctx_line = self._get_parent_context(node)

call_data = {

"name": class_name,

"full_name": full_name, # Usually we want the class name here so GB can link to Class node

"line_number": line_number,

"args": args,

"inferred_obj_type": None,

"context": (ctx_name, ctx_type, ctx_line),

"class_context": (ctx_name, ctx_line) if ctx_type and ("class" in ctx_type or "interface" in ctx_type or "trait" in ctx_type) else (None, None),

"lang": self.language_name,

"is_dependency": False,

}

calls.append(call_data)

except Exception:

continue

return calls

def pre_scan_php(files: list[Path], parser_wrapper) -> dict:

name_to_files = {}

for path in files:

try:

with open(path, "r", encoding="utf-8", errors="ignore") as f:

content = f.read()

# Extract class, interface, trait, and function names

patterns = [

r"(?:class|interface|trait)\s+(\w+)",

r"function\s+(\w+)\s*\(",

]

for pattern in patterns:

for match in re.finditer(pattern, content):

name = match.group(1)

if name not in name_to_files:

name_to_files[name] = []

name_to_files[name].append(str(path))

# Extract namespace for FQN mapping

ns_match = re.search(r"namespace\s+([\w\\]+)", content)

if ns_match:

namespace = ns_match.group(1)

for pattern in [r"(?:class|interface|trait)\s+(\w+)"]:

for match in re.finditer(pattern, content):

fqn = f"{namespace}\\{match.group(1)}"

if fqn not in name_to_files:

name_to_files[fqn] = []

name_to_files[fqn].append(str(path))

except Exception:

pass

return name_to_files