resolution

func ExtractCallSites ¶

func ExtractCallSites(filePath string, sourceCode []byte, importMap *core.ImportMap) ([]*core.CallSite, error)

ExtractCallSites extracts all function/method call sites from a Python file. It traverses the AST to find call expressions and builds CallSite objects with caller context, callee information, and arguments.

Algorithm:

1. Parse source code with tree-sitter Python parser
2. Traverse AST to find call expressions
3. For each call, extract: - Caller function/method (containing context) - Callee name (function/method being called) - Arguments (positional and keyword) - Source location (file, line, column)
4. Build CallSite objects for each call

Parameters:

• filePath: absolute path to the Python file being analyzed
• sourceCode: contents of the Python file as byte array
• importMap: import mappings for resolving qualified names

Returns:

• []CallSite: list of all call sites found in the file
• error: if parsing fails or source is invalid

Example:

Source code:
  def process_data():
      result = sanitize(data)
      db.query(result)

Extracts CallSites:
  [
    {Caller: "process_data", Callee: "sanitize", Args: ["data"]},
    {Caller: "process_data", Callee: "db.query", Args: ["result"]}
  ]

func ExtractImports ¶

func ExtractImports(filePath string, sourceCode []byte, registry *core.ModuleRegistry) (*core.ImportMap, error)

ExtractImports extracts all import statements from a Python file and builds an ImportMap. It handles four main import styles:

1. Simple imports: import module
2. From imports: from module import name
3. Aliased imports: from module import name as alias
4. Relative imports: from . import module, from .. import module

The resulting ImportMap maps local names (aliases or imported names) to their fully qualified module paths, enabling later resolution of function calls.

Algorithm:

1. Parse source code with tree-sitter Python parser
2. Traverse AST to find all import statements
3. Process each import to extract module paths and aliases
4. Resolve relative imports using module registry
5. Build ImportMap with resolved fully qualified names

Parameters:

• filePath: absolute path to the Python file being analyzed
• sourceCode: contents of the Python file as byte array
• registry: module registry for resolving module paths and relative imports

Returns:

• ImportMap: map of local names to fully qualified module paths
• error: if parsing fails or source is invalid

Example:

Source code:
  import os
  from myapp.utils import sanitize
  from myapp.db import query as db_query
  from . import helper
  from ..config import settings

Result ImportMap:
  {
    "os": "os",
    "sanitize": "myapp.utils.sanitize",
    "db_query": "myapp.db.query",
    "helper": "myapp.submodule.helper",
    "settings": "myapp.config.settings"
  }

func IsDjangoORMPattern ¶

func IsDjangoORMPattern(target string) (bool, string)

IsDjangoORMPattern checks if a call target matches Django ORM pattern. Django ORM pattern: ModelName.objects.<method>

Examples:

• "Task.objects.filter" → true
• "User.objects.get" → true
• "Annotation.objects.all" → true
• "task.save" → false (instance method, not manager)

Parameters:

• target: call target string (e.g., "Task.objects.filter")

Returns:

• true if it matches Django ORM pattern
• the method name if matched (e.g., "filter")

func IsORMPattern ¶

func IsORMPattern(target string) (bool, string, string)

IsORMPattern checks if a call target matches any known ORM pattern.

Parameters:

• target: call target string

Returns:

• true if it matches any ORM pattern
• the ORM pattern name (e.g., "Django ORM")
• the method name (e.g., "filter")

func IsSQLAlchemyORMPattern ¶

func IsSQLAlchemyORMPattern(target string) (bool, string)

IsSQLAlchemyORMPattern checks if a call target matches SQLAlchemy ORM pattern. SQLAlchemy patterns are more varied, but common ones include:

• session.query(Model).filter(...)
• db.session.query(Model).all()
• Model.query.filter_by(...)

Parameters:

• target: call target string

Returns:

• true if it matches SQLAlchemy ORM pattern
• the method name if matched

func MergeReturnTypes ¶

func MergeReturnTypes(statements []*ReturnStatement) map[string]*core.TypeInfo

MergeReturnTypes combines multiple return statements for same function. Takes the highest confidence return type.

func PrintAttributeFailureStats ¶

func PrintAttributeFailureStats()

PrintAttributeFailureStats prints detailed statistics about attribute chain failures.

func ResolveAttributePlaceholders ¶

func ResolveAttributePlaceholders(
	registry *registry.AttributeRegistry,
	typeEngine *TypeInferenceEngine,
	moduleRegistry *core.ModuleRegistry,
	codeGraph *graph.CodeGraph,
)

ResolveAttributePlaceholders resolves placeholder types in the attribute registry Placeholders are created during extraction when we can't determine the exact type:

• class:User → resolve to fully qualified class name
• call:calculate → resolve to function return type
• param:User → resolve to fully qualified class name

This is Pass 3 of the attribute extraction algorithm.

Parameters:

• registry: attribute registry with placeholder types
• typeEngine: type inference engine with return types
• moduleRegistry: module registry for resolving class names
• codeGraph: code graph for finding class definitions

func ResolveChainedCall ¶

func ResolveChainedCall(
	target string,
	typeEngine *TypeInferenceEngine,
	builtins *registry.BuiltinRegistry,
	moduleRegistry *core.ModuleRegistry,
	codeGraph *graph.CodeGraph,
	callerFQN string,
	currentModule string,
	callGraph *core.CallGraph,
) (string, bool, *core.TypeInfo)

ResolveChainedCall resolves a method chain by walking each step and tracking types.

Algorithm:

1. Parse chain into individual steps
2. Resolve first step: - If it's a call: resolve as function call, get return type - If it's a variable: look up type in scopes
3. For each subsequent step: - Use previous step's type to resolve method - Get method's return type from builtins or return type registry - Track confidence through the chain (multiply confidences)
4. Return final type and resolution status

Parameters:

• target: the full target string (e.g., "create_builder().append().upper()")
• typeEngine: type inference engine with scopes and return types
• builtins: builtin registry for builtin method lookups
• registry: module registry for validation
• codeGraph: code graph for function lookups
• callerFQN: FQN of the calling function (for scope lookups)
• currentModule: current module path
• callGraph: call graph for function lookups

Returns:

• targetFQN: the fully qualified name of the final call
• resolved: true if chain was successfully resolved
• typeInfo: type information for the final result

func ResolveClassInstantiation ¶

func ResolveClassInstantiation(
	callNode *sitter.Node,
	sourceCode []byte,
	modulePath string,
	importMap *core.ImportMap,
	registry *core.ModuleRegistry,
) *core.TypeInfo

ResolveClassInstantiation attempts to resolve class instantiation patterns.

func ResolveDjangoORMCall ¶

func ResolveDjangoORMCall(target string, modulePath string, registry *core.ModuleRegistry, codeGraph *graph.CodeGraph) (string, bool)

ResolveDjangoORMCall attempts to resolve a Django ORM call pattern. It constructs a synthetic FQN for the ORM method even though it doesn't exist in source code, because Django generates these methods at runtime.

Parameters:

• target: the call target (e.g., "Task.objects.filter")
• modulePath: the current module path
• registry: module registry
• codeGraph: the parsed code graph (for model validation)

Returns:

• fully qualified name for the ORM call
• true if successfully resolved as Django ORM

func ResolveORMCall ¶

func ResolveORMCall(target string, modulePath string, registry *core.ModuleRegistry, codeGraph *graph.CodeGraph) (string, bool)

ResolveORMCall attempts to resolve any ORM pattern.

Parameters:

• target: the call target
• modulePath: the current module path
• registry: module registry
• codeGraph: the parsed code graph

Returns:

• fully qualified name for the ORM call
• true if successfully resolved as any ORM pattern

func ResolveSQLAlchemyORMCall ¶

func ResolveSQLAlchemyORMCall(target string, modulePath string) (string, bool)

ResolveSQLAlchemyORMCall attempts to resolve a SQLAlchemy ORM call pattern.

Parameters:

• target: the call target
• modulePath: the current module path

Returns:

• fully qualified name for the ORM call
• true if successfully resolved as SQLAlchemy ORM

func ResolveSelfAttributeCall ¶

func ResolveSelfAttributeCall(
	target string,
	callerFQN string,
	typeEngine *TypeInferenceEngine,
	builtins *registry.BuiltinRegistry,
	callGraph *core.CallGraph,
) (string, bool, *core.TypeInfo)

ResolveSelfAttributeCall resolves self.attribute.method() patterns This is the core of Phase 3 Task 12 - using extracted attributes to resolve calls.

Algorithm:

1. Detect pattern: target starts with "self." and has 2+ dots
2. Parse: self.attr.method → attr="attr", method="method"
3. Find containing class from callerFQN
4. Lookup attribute type in AttributeRegistry
5. Resolve method on inferred type

Example:

Input: self.value.upper (caller: test_chaining.StringBuilder.process)
Steps:
  1. Parse → attr="value", method="upper"
  2. Extract class → test_chaining.StringBuilder
  3. Lookup value type → builtins.str
  4. Resolve upper on str → builtins.str.upper
Output: (builtins.str.upper, true, TypeInfo{builtins.str, 1.0, "self_attribute"})

Parameters:

• target: call target string (e.g., "self.value.upper")
• callerFQN: fully qualified name of calling function
• typeEngine: type inference engine with attribute registry
• builtins: builtin registry for method lookup
• callGraph: call graph for class lookup

Returns:

• resolvedFQN: fully qualified method name
• resolved: true if resolution succeeded
• typeInfo: inferred type information

func ValidateDjangoModel ¶

func ValidateDjangoModel(modelName string, codeGraph *graph.CodeGraph) bool

ValidateDjangoModel checks if a name is likely a Django model by examining the code graph for the class definition and checking if it inherits from django.db.models.Model or has "Model" in its name.

This is a heuristic check since we can't always definitively determine if something is a Django model without runtime information.

Parameters:

• modelName: the name to check (e.g., "Task", "User")
• codeGraph: the parsed code graph

Returns:

• true if the name is likely a Django model