Skip to content

Commit 03a444d

Browse files
hvitvedhvitved
committed
Rust: Disambiguate types inferred from trait bounds
1 parent 98d8cd1 commit 03a444d

File tree

7 files changed

+414
-133
lines changed

7 files changed

+414
-133
lines changed

‎rust/ql/lib/codeql/rust/internal/typeinference/FunctionOverloading.qll‎

Lines changed: 91 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -13,68 +13,105 @@ private import TypeMention
1313
private import TypeInference
1414
private import FunctionType
1515

16-
pragma[nomagic]
17-
private Type resolveNonTypeParameterTypeAt(TypeMention tm, TypePath path) {
18-
result = tm.getTypeAt(path) and
19-
not result instanceof TypeParameter
20-
}
16+
private signature Type resolveTypeMentionAtSig(AstNode tm, TypePath path);
2117

22-
bindingset[t1, t2]
23-
private predicate typeMentionEqual(TypeMention t1, TypeMention t2) {
24-
forex(TypePath path, Type type | resolveNonTypeParameterTypeAt(t1, path) = type |
25-
resolveNonTypeParameterTypeAt(t2, path) = type
26-
)
27-
}
18+
/**
19+
* Provides logic for identifying sibling implementations, parameterized over
20+
* how to resolve type mentions (`PreTypeMention` vs. `TypeMention`).
21+
*/
22+
private module MkSiblingImpls<resolveTypeMentionAtSig/2 resolveTypeMentionAt> {
23+
pragma[nomagic]
24+
private Type resolveNonTypeParameterTypeAt(AstNode tm, TypePath path) {
25+
result = resolveTypeMentionAt(tm, path) and
26+
not result instanceof TypeParameter
27+
}
2828

29-
pragma[nomagic]
30-
private predicate implSiblingCandidate(
31-
Impl impl, TraitItemNode trait, Type rootType, TypeMention selfTy
32-
) {
33-
trait = impl.(ImplItemNode).resolveTraitTy() and
34-
selfTy = impl.getSelfTy() and
35-
rootType = selfTy.getType()
29+
bindingset[t1, t2]
30+
private predicate typeMentionEqual(AstNode t1, AstNode t2) {
31+
forex(TypePath path, Type type | resolveNonTypeParameterTypeAt(t1, path) = type |
32+
resolveNonTypeParameterTypeAt(t2, path) = type
33+
)
34+
}
35+
36+
pragma[nomagic]
37+
private predicate implSiblingCandidate(
38+
Impl impl, TraitItemNode trait, Type rootType, AstNode selfTy
39+
) {
40+
trait = impl.(ImplItemNode).resolveTraitTy() and
41+
selfTy = impl.getSelfTy() and
42+
rootType = resolveTypeMentionAt(selfTy, TypePath::nil())
43+
}
44+
45+
pragma[nomagic]
46+
private predicate blanketImplSiblingCandidate(ImplItemNode impl, Trait trait) {
47+
impl.isBlanketImplementation() and
48+
trait = impl.resolveTraitTy()
49+
}
50+
51+
/**
52+
* Holds if `impl1` and `impl2` are a sibling implementations of `trait`. We
53+
* consider implementations to be siblings if they implement the same trait for
54+
* the same type. In that case `Self` is the same type in both implementations,
55+
* and method calls to the implementations cannot be resolved unambiguously
56+
* based only on the receiver type.
57+
*/
58+
pragma[inline]
59+
predicate implSiblings(TraitItemNode trait, Impl impl1, Impl impl2) {
60+
impl1 != impl2 and
61+
(
62+
exists(Type rootType, AstNode selfTy1, AstNode selfTy2 |
63+
implSiblingCandidate(impl1, trait, rootType, selfTy1) and
64+
implSiblingCandidate(impl2, trait, rootType, selfTy2) and
65+
// In principle the second conjunct below should be superflous, but we still
66+
// have ill-formed type mentions for types that we don't understand. For
67+
// those checking both directions restricts further. Note also that we check
68+
// syntactic equality, whereas equality up to renaming would be more
69+
// correct.
70+
typeMentionEqual(selfTy1, selfTy2) and
71+
typeMentionEqual(selfTy2, selfTy1)
72+
)
73+
or
74+
blanketImplSiblingCandidate(impl1, trait) and
75+
blanketImplSiblingCandidate(impl2, trait)
76+
)
77+
}
78+
79+
/**
80+
* Holds if `impl` is an implementation of `trait` and if another implementation
81+
* exists for the same type.
82+
*/
83+
pragma[nomagic]
84+
predicate implHasSibling(ImplItemNode impl, Trait trait) { implSiblings(trait, impl, _) }
85+
86+
pragma[nomagic]
87+
predicate implHasAmbiguousSiblingAt(ImplItemNode impl, Trait trait, TypePath path) {
88+
exists(ImplItemNode impl2, Type t1, Type t2 |
89+
implSiblings(trait, impl, impl2) and
90+
t1 = resolveTypeMentionAt(impl.getTraitPath(), path) and
91+
t2 = resolveTypeMentionAt(impl2.getTraitPath(), path) and
92+
t1 != t2
93+
|
94+
not t1 instanceof TypeParameter or
95+
not t2 instanceof TypeParameter
96+
)
97+
}
3698
}
3799

38-
pragma[nomagic]
39-
private predicate blanketImplSiblingCandidate(ImplItemNode impl, Trait trait) {
40-
impl.isBlanketImplementation() and
41-
trait = impl.resolveTraitTy()
100+
private Type resolvePreTypeMention(AstNode tm, TypePath path) {
101+
result = tm.(PreTypeMention).getTypeAt(path)
42102
}
43103

44-
/**
45-
* Holds if `impl1` and `impl2` are a sibling implementations of `trait`. We
46-
* consider implementations to be siblings if they implement the same trait for
47-
* the same type. In that case `Self` is the same type in both implementations,
48-
* and method calls to the implementations cannot be resolved unambiguously
49-
* based only on the receiver type.
50-
*/
51-
pragma[inline]
52-
private predicate implSiblings(TraitItemNode trait, Impl impl1, Impl impl2) {
53-
impl1 != impl2 and
54-
(
55-
exists(Type rootType, TypeMention selfTy1, TypeMention selfTy2 |
56-
implSiblingCandidate(impl1, trait, rootType, selfTy1) and
57-
implSiblingCandidate(impl2, trait, rootType, selfTy2) and
58-
// In principle the second conjunct below should be superflous, but we still
59-
// have ill-formed type mentions for types that we don't understand. For
60-
// those checking both directions restricts further. Note also that we check
61-
// syntactic equality, whereas equality up to renaming would be more
62-
// correct.
63-
typeMentionEqual(selfTy1, selfTy2) and
64-
typeMentionEqual(selfTy2, selfTy1)
65-
)
66-
or
67-
blanketImplSiblingCandidate(impl1, trait) and
68-
blanketImplSiblingCandidate(impl2, trait)
69-
)
104+
private module PreSiblingImpls = MkSiblingImpls<resolvePreTypeMention/2>;
105+
106+
predicate preImplHasAmbiguousSiblingAt = PreSiblingImpls::implHasAmbiguousSiblingAt/3;
107+
108+
private Type resolveTypeMention(AstNode tm, TypePath path) {
109+
result = tm.(TypeMention).getTypeAt(path)
70110
}
71111

72-
/**
73-
* Holds if `impl` is an implementation of `trait` and if another implementation
74-
* exists for the same type.
75-
*/
76-
pragma[nomagic]
77-
private predicate implHasSibling(ImplItemNode impl, Trait trait) { implSiblings(trait, impl, _) }
112+
private module SiblingImpls = MkSiblingImpls<resolveTypeMention/2>;
113+
114+
import SiblingImpls
78115

79116
/**
80117
* Holds if `f` is a function declared inside `trait`, and the type of `f` at

‎rust/ql/lib/codeql/rust/internal/typeinference/TypeInference.qll‎

Lines changed: 76 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ private newtype TTypeArgumentPosition =
3030
} or
3131
TTypeParamTypeArgumentPosition(TypeParam tp)
3232

33-
private module Input implements InputSig1<Location>, InputSig2<PreTypeMention> {
33+
private module Input1 implements InputSig1<Location> {
3434
private import Type as T
3535
private import codeql.rust.elements.internal.generated.Raw
3636
private import codeql.rust.elements.internal.generated.Synth
@@ -124,10 +124,28 @@ private module Input implements InputSig1<Location>, InputSig2<PreTypeMention> {
124124
}
125125

126126
int getTypePathLimit() { result = 10 }
127+
}
127128

128-
PreTypeMention getABaseTypeMention(Type t) { none() }
129+
private import Input1
129130

130-
PreTypeMention getATypeParameterConstraint(TypeParameter tp) {
131+
private module M1 = Make1<Location, Input1>;
132+
133+
import M1
134+
135+
predicate getTypePathLimit = Input1::getTypePathLimit/0;
136+
137+
predicate getTypeParameterId = Input1::getTypeParameterId/1;
138+
139+
class TypePath = M1::TypePath;
140+
141+
module TypePath = M1::TypePath;
142+
143+
/**
144+
* Provides shared logic for implementing `InputSig2<PreTypeMention>` and
145+
* `InputSig2<TypeMention>`.
146+
*/
147+
private module Input2Common {
148+
AstNode getATypeParameterConstraint(TypeParameter tp) {
131149
result = tp.(TypeParamTypeParameter).getTypeParam().getATypeBound().getTypeRepr() or
132150
result = tp.(SelfTypeParameter).getTrait() or
133151
result =
@@ -146,7 +164,7 @@ private module Input implements InputSig1<Location>, InputSig2<PreTypeMention> {
146164
* inference module for more information.
147165
*/
148166
predicate conditionSatisfiesConstraint(
149-
TypeAbstraction abs, PreTypeMention condition, PreTypeMention constraint, boolean transitive
167+
TypeAbstraction abs, AstNode condition, AstNode constraint, boolean transitive
150168
) {
151169
// `impl` blocks implementing traits
152170
transitive = false and
@@ -194,23 +212,64 @@ private module Input implements InputSig1<Location>, InputSig2<PreTypeMention> {
194212
)
195213
)
196214
}
215+
216+
predicate typeParameterIsFunctionallyDetermined(TypeParameter tp) {
217+
tp instanceof AssociatedTypeTypeParameter
218+
}
197219
}
198220

199-
private import Input
221+
private module PreInput2 implements InputSig2<PreTypeMention> {
222+
PreTypeMention getABaseTypeMention(Type t) { none() }
200223

201-
private module M1 = Make1<Location, Input>;
224+
PreTypeMention getATypeParameterConstraint(TypeParameter tp) {
225+
result = Input2Common::getATypeParameterConstraint(tp)
226+
}
202227

203-
import M1
228+
predicate conditionSatisfiesConstraint(
229+
TypeAbstraction abs, PreTypeMention condition, PreTypeMention constraint, boolean transitive
230+
) {
231+
Input2Common::conditionSatisfiesConstraint(abs, condition, constraint, transitive)
232+
}
204233

205-
predicate getTypePathLimit = Input::getTypePathLimit/0;
234+
predicate typeAbstractionHasAmbiguousConstraintAt(
235+
TypeAbstraction abs, Type constraint, TypePath path
236+
) {
237+
FunctionOverloading::preImplHasAmbiguousSiblingAt(abs, constraint.(TraitType).getTrait(), path)
238+
}
206239

207-
predicate getTypeParameterId = Input::getTypeParameterId/1;
240+
predicate typeParameterIsFunctionallyDetermined =
241+
Input2Common::typeParameterIsFunctionallyDetermined/1;
242+
}
208243

209-
class TypePath = M1::TypePath;
244+
/** Provides an instantiation of the shared type inference library for `PreTypeMention`s. */
245+
module PreM2 = Make2<PreTypeMention, PreInput2>;
210246

211-
module TypePath = M1::TypePath;
247+
private module Input2 implements InputSig2<TypeMention> {
248+
TypeMention getABaseTypeMention(Type t) { none() }
212249

213-
private module M2 = Make2<PreTypeMention, Input>;
250+
TypeMention getATypeParameterConstraint(TypeParameter tp) {
251+
result = Input2Common::getATypeParameterConstraint(tp)
252+
}
253+
254+
predicate conditionSatisfiesConstraint(
255+
TypeAbstraction abs, TypeMention condition, TypeMention constraint, boolean transitive
256+
) {
257+
Input2Common::conditionSatisfiesConstraint(abs, condition, constraint, transitive)
258+
}
259+
260+
predicate typeAbstractionHasAmbiguousConstraintAt(
261+
TypeAbstraction abs, Type constraint, TypePath path
262+
) {
263+
FunctionOverloading::implHasAmbiguousSiblingAt(abs, constraint.(TraitType).getTrait(), path)
264+
}
265+
266+
predicate typeParameterIsFunctionallyDetermined =
267+
Input2Common::typeParameterIsFunctionallyDetermined/1;
268+
}
269+
270+
private import Input2
271+
272+
private module M2 = Make2<TypeMention, Input2>;
214273

215274
import M2
216275

@@ -1070,25 +1129,18 @@ private module ContextTyping {
10701129
AstNode n, FunctionPosition pos, boolean hasReceiver, TypePath path
10711130
) {
10721131
result = inferCallType(n, pos, hasReceiver, path) and
1073-
not pos.isReturn()
1074-
}
1075-
1076-
pragma[nomagic]
1077-
private Type inferCallNonReturnType(
1078-
AstNode n, FunctionPosition pos, boolean hasReceiver, TypePath prefix, TypePath path
1079-
) {
1080-
result = inferCallNonReturnType(n, pos, hasReceiver, path) and
10811132
hasUnknownType(n) and
1082-
prefix = path.getAPrefix()
1133+
not pos.isReturn()
10831134
}
10841135

10851136
pragma[nomagic]
10861137
Type check(AstNode n, TypePath path) {
10871138
result = inferCallType(n, any(FunctionPosition pos | pos.isReturn()), _, path)
10881139
or
10891140
exists(FunctionPosition pos, boolean hasReceiver, TypePath prefix |
1090-
result = inferCallNonReturnType(n, pos, hasReceiver, prefix, path) and
1091-
hasUnknownTypeAt(n, prefix)
1141+
result = inferCallNonReturnType(n, pos, hasReceiver, path) and
1142+
hasUnknownTypeAt(n, prefix) and
1143+
prefix.isPrefixOf(path)
10921144
|
10931145
// Never propagate type information directly into the receiver, since its type
10941146
// must already have been known in order to resolve the call
@@ -3970,7 +4022,7 @@ private module Debug {
39704022
TypeAbstraction abs, TypeMention condition, TypeMention constraint, boolean transitive
39714023
) {
39724024
abs = getRelevantLocatable() and
3973-
Input::conditionSatisfiesConstraint(abs, condition, constraint, transitive)
4025+
Input2::conditionSatisfiesConstraint(abs, condition, constraint, transitive)
39744026
}
39754027

39764028
predicate debugInferShorthandSelfType(ShorthandSelfParameterMention self, TypePath path, Type t) {

0 commit comments

Comments
 (0)