Scala 3 given/using resolution ambiguity in mixed-scope imports

Short answer

In Scala 3, a given that is in scope at the call site — defined locally or brought in by an import — takes precedence over one found in the companion object of the type class or the target type. The companion object is the fallback, searched only when normal scoping finds nothing. So in your scenario, the instance from the imported utility trait wins over the companion-object instance; no ambiguity error is raised between those two tiers.

Companion object vs. imported scope

Resolution happens in two conceptually distinct phases:

1. Normal scope: local definitions, enclosing scopes, and imports (including import pkg.given and wildcard imports of givens).
2. Implicit scope: companion objects of the type class and of the types appearing in the query.

Phase 1 is searched first. If exactly one candidate is found there, it is selected and phase 2 never runs. This is why a locally imported "override" instance is the idiomatic way to shadow a default instance that lives in a companion object — the same pattern Scala 2 used with implicits.

Two competing imported givens

When two imported scopes each supply a candidate for the same type, both sit in the same priority tier, and the compiler reports an ambiguous-given error rather than picking one. There is no "first import wins" rule. Your options:

• Import only the instance you want, by name: import utilA.myOrdering instead of import utilA.given.
• Pass the instance explicitly at the call site: sort(xs)(using utilB.myOrdering).
• Define a local given that delegates to the preferred instance — local definitions outrank imported ones.

Verifying on your compiler

The ambiguity error message lists the competing candidates and where they came from, which is the fastest way to confirm which tier each instance occupies. You can also probe resolution directly:

// after your imports
val picked = summon[Ordering[Foo]]
println(picked)  // object identity tells you which instance won

Check your exact version with scalac -version. The core rule (normal scope before implicit scope) has been stable across Scala 3.x, but error-message detail and edge cases around using clauses have been refined between minor releases, so treat the compiler output on your installed version as authoritative.

Uncertainty

The precedence description above reflects well-established Scala 3 semantics. What I cannot confirm without your code is whether your "imported utility trait" instance is actually a given in scope (e.g., inherited via trait mixin vs. imported via import util.given) — mixin-inherited givens and imported givens can interact differently in corner cases. If the compiler still reports ambiguity after you expect the import to shadow the companion, share the exact import statements and the full error text; that detail determines whether you're hitting a genuine same-tier conflict.