Rust: Fallback crate resolution

[hvitved]

Before this PR, we relied strictly on crate dependency information from the extractor when resolving paths to crates. However, for whatever reason, this information may sometimes be incomplete, so in this PR we relax this condition and allow for a path to resolve to any crate in the DB, as long as the name of that crate does not conflict with the name of a known dependency.

In order to reduce path resolution inconsistencies, this PR also adds a step to make resolution of qualified paths like q::p consistent; of all the candidate resolution targets of q, only chose the one(s) that are consistent with what q::p may resolve to.

DCA looks great: Percentage of calls with call target increases from 61.52 to 62.44, path resolution inconsistencies are reduced by 41 %, at only a marginal slowdown.

[Copilot]

Pull Request Overview

This PR introduces fallback crate resolution to handle cases where crate dependency information from the extractor may be incomplete. The key change allows paths to resolve to any crate in the database when the crate name doesn't conflict with known dependencies, and adds consistency improvements for qualified path resolution.

Key changes:

• Adds fallback crate resolution when dependency information is missing
• Implements consistency checks to ensure qualified paths like q::p resolve consistently with their qualifiers
• Refactors path resolution to separate candidate resolution from final resolution with consistency checks

Reviewed Changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated 2 comments.

File	Description
PathResolutionConsistency.qll	Updates path resolution consistency check to exclude crate conflicts from multiple resolution warnings
PathResolution.qll	Major refactoring adding fallback crate resolution, consistency checks, and new implementation classes
TypeParamImpl.qll	Simplifies type bound resolution by delegating to TypeParamItemNode
*.expected files	Updated test expectations reflecting reduced path resolution inconsistencies

[Copilot]

The TTypeNamespace() call should likely be name.getNamespace() or a similar method to get the appropriate namespace for the crate name, rather than always using the type namespace.

Suggested change

	not declaresDirectly(file, TTypeNamespace(), name) and
	not declaresDirectly(file, dep.getNamespace(), name) and

[Copilot]

The transitive closure operator * after getQualifier creates a potential infinite recursion if there are circular qualifier relationships. Consider using a bounded recursion or a different approach to handle qualifier chains.

Suggested change

	not isQualifiedViaUseTree(this) and
	name = this.getText()
	}
	/**
	* Helper predicate to check if `path` is reachable via qualifiers from any UseTreeList,
	* using bounded recursion to avoid infinite loops in case of cycles.
	*/
	private predicate isQualifiedViaUseTree(Path path) {
	exists(UseTreeList list, UseTree ut, Path p |
	ut = list.getAUseTree() and
	p = ut.getPath() and
	isReachableQualifier(p, path, [])
	)
	}
	/**
	* Bounded recursion: holds if `target` is reachable from `current` via qualifiers,
	* without revisiting any path in `visited`.
	*/
	private predicate isReachableQualifier(Path current, Path target, Path[] visited) {
	current = target
	or
	not visited.contains(current) and
	exists(Path next |
	next = current.getQualifier() and
	isReachableQualifier(next, target, visited + [current])
	)
	}