Tracking issue: Fix remaining type mismatches in rust-analyzer repo #8961

flodiebold · 2021-05-24T09:41:40Z

We've got about 1000 type mismatches remaining when running rust-analyzer analysis-stats . on the rust-analyzer repo itself. Since the repo actually typechecks, all of these type mismatches are actually bugs or missing features. Since we want to emit type errors sooner or later, we need to get these to 0 🙂

Here's the categorization I've got so far: (all line numbers are from revision b8262099cc51065259daf10b4b23ff49ce74434f)

(708) Expected &dyn \w+Database: Requires attribute macro support for salsa (Expand attribute-like proc macros #8971)
(99) Expected &HitCounter: Caused by Inner item declared by nested macro not resolved #8930
(109) Expected .+, got !: Investigate, this should easily work? Reproducible trivially:

fn main() {
    unreachable!()
}

This only seems to happen with macros; e.g.loop {} does not result in a type mismatch.
Fixed by #8983.

Expected .+, got <.+ as FnOnce.+>::Output: Fixed by fix: Fix lowering of FnOnce() without return type #8987

crates/hir_def/src/body/lower.rs 640:20-640:22: Expected (), got <F as FnOnce<(&mut ExprCollector, Option<T>)>>::Output
crates/hir_def/src/body/lower.rs 635:23-641:17: Expected (), got <F as FnOnce<(&mut ExprCollector, Option<T>)>>::Output
crates/hir_def/src/body/lower.rs 643:20-643:41: Expected (), got <F as FnOnce<(&mut ExprCollector, Option<T>)>>::Output
crates/hir_def/src/expr.rs 268:68-268:82: Expected (), got <impl FnMut(Idx<Expr>) as FnOnce<(Idx<Expr>,)>>::Output
crates/hir_def/src/expr.rs 278:38-278:46: Expected (), got <impl FnMut(Idx<Expr>) as FnOnce<(Idx<Expr>,)>>::Output
crates/hir_def/src/expr.rs 279:39-279:47: Expected (), got <impl FnMut(Idx<Expr>) as FnOnce<(Idx<Expr>,)>>::Output
crates/hir_def/src/expr.rs 361:20-361:30: Expected (), got <impl FnMut(Idx<Expr>) as FnOnce<(Idx<Expr>,)>>::Output
crates/hir_def/src/expr.rs 359:57-362:17: Expected (), got <impl FnMut(Idx<Expr>) as FnOnce<(Idx<Expr>,)>>::Output
crates/hir_def/src/expr.rs 364:41-364:49: Expected (), got <impl FnMut(Idx<Expr>) as FnOnce<(Idx<Expr>,)>>::Output
crates/hir_def/src/expr.rs 443:36-443:43: Expected (), got <impl FnMut(Idx<Pat>) as FnOnce<(Idx<Pat>,)>>::Output
crates/hir_def/src/expr.rs 451:34-451:43: Expected (), got <impl FnMut(Idx<Pat>) as FnOnce<(Idx<Pat>,)>>::Output
crates/hir_def/src/resolver.rs 456:24-456:74: Expected (), got <dyn FnMut(Name, ScopeDef) as FnOnce<(Name, ScopeDef)>>::Output
process_names: Expected <dyn FnMut(Name, ScopeDef) as FnOnce<(Name, ScopeDef)>>::Output, got ()
crates/hir_def/src/resolver.rs 454:20-457:21: Expected (), got <dyn FnMut(Name, ScopeDef) as FnOnce<(Name, ScopeDef)>>::Output
crates/hir_def/src/resolver.rs 453:61-458:17: Expected (), got <dyn FnMut(Name, ScopeDef) as FnOnce<(Name, ScopeDef)>>::Output
crates/hir_def/src/resolver.rs 461:20-461:76: Expected (), got <dyn FnMut(Name, ScopeDef) as FnOnce<(Name, ScopeDef)>>::Output
crates/hir_def/src/resolver.rs 459:62-462:17: Expected (), got <dyn FnMut(Name, ScopeDef) as FnOnce<(Name, ScopeDef)>>::Output
crates/hir_def/src/resolver.rs 465:20-465:76: Expected (), got <dyn FnMut(Name, ScopeDef) as FnOnce<(Name, ScopeDef)>>::Output
crates/hir_def/src/resolver.rs 463:65-466:17: Expected (), got <dyn FnMut(Name, ScopeDef) as FnOnce<(Name, ScopeDef)>>::Output
process_names: Expected <dyn FnMut(Name, ScopeDef) as FnOnce<(Name, ScopeDef)>>::Output, got ()
crates/hir_def/src/path/lower/lower_use.rs 55:16-55:47: Expected (), got <dyn FnMut(ModPath, &UseTree, bool, Option<ImportAlias>) as FnOnce<(ModPath, &UseTree, bool, Option<ImportAlias>)>>::Output
lower_use_tree: Expected <dyn FnMut(ModPath, &UseTree, bool, Option<ImportAlias>) as FnOnce<(ModPath, &UseTree, bool, Option<ImportAlias>)>>::Output, got ()
crates/hir_def/src/path/lower/lower_use.rs 54:12-56:13: Expected (), got <dyn FnMut(ModPath, &UseTree, bool, Option<ImportAlias>) as FnOnce<(ModPath, &UseTree, bool, Option<ImportAlias>)>>::Output
crates/hir_def/src/path/lower/lower_use.rs 62:16-62:48: Expected (), got <dyn FnMut(ModPath, &UseTree, bool, Option<ImportAlias>) as FnOnce<(ModPath, &UseTree, bool, Option<ImportAlias>)>>::Output
lower_use_tree: Expected <dyn FnMut(ModPath, &UseTree, bool, Option<ImportAlias>) as FnOnce<(ModPath, &UseTree, bool, Option<ImportAlias>)>>::Output, got ()
crates/hir_def/src/path/lower/lower_use.rs 61:12-63:13: Expected (), got <dyn FnMut(ModPath, &UseTree, bool, Option<ImportAlias>) as FnOnce<(ModPath, &UseTree, bool, Option<ImportAlias>)>>::Output
crates/hir_def/src/path/lower/lower_use.rs 41:8-64:9: Expected (), got <dyn FnMut(ModPath, &UseTree, bool, Option<ImportAlias>) as FnOnce<(ModPath, &UseTree, bool, Option<ImportAlias>)>>::Output
crates/hir_def/src/path/lower/lower_use.rs 36:11-65:5: Expected (), got <dyn FnMut(ModPath, &UseTree, bool, Option<ImportAlias>) as FnOnce<(ModPath, &UseTree, bool, Option<ImportAlias>)>>::Output
crates/vfs-notify/src/lib.rs 217:8-217:26: Expected (), got <dyn Fn(Message) + Send as FnOnce<(Message,)>>::Output
crates/vfs-notify/src/lib.rs 216:45-218:5: Expected (), got <dyn Fn(Message) + Send as FnOnce<(Message,)>>::Output
crates/stdx/src/process.rs 45:24-45:44: Expected (), got <dyn FnMut(&str) as FnOnce<(&str,)>>::Output
crates/stdx/src/process.rs 47:24-47:44: Expected (), got <dyn FnMut(&str) as FnOnce<(&str,)>>::Output
crates/stdx/src/process.rs 44:20-48:21: Expected (), got <dyn FnMut(&str) as FnOnce<(&str,)>>::Output
crates/stdx/src/process.rs 43:71-49:17: Expected (), got <dyn FnMut(&str) as FnOnce<(&str,)>>::Output
crates/hir_expand/src/diagnostics.rs 72:8-72:34: Expected (), got <dyn FnMut(&dyn Diagnostic) as FnOnce<(&dyn Diagnostic,)>>::Output
crates/hir_expand/src/diagnostics.rs 60:44-73:5: Expected (), got <dyn FnMut(&dyn Diagnostic) as FnOnce<(&dyn Diagnostic,)>>::Output
crates/flycheck/src/lib.rs 253:8-253:33: Expected (), got <dyn Fn(Message) + Send as FnOnce<(Message,)>>::Output
crates/flycheck/src/lib.rs 252:40-254:5: Expected (), got <dyn Fn(Message) + Send as FnOnce<(Message,)>>::Output
crates/hir/src/semantics.rs 864:12-864:24: Expected (), got <dyn FnMut(Name, ScopeDef) as FnOnce<(Name, ScopeDef)>>::Output
crates/hir/src/semantics.rs 843:70-865:9: Expected (), got <dyn FnMut(Name, ScopeDef) as FnOnce<(Name, ScopeDef)>>::Output

Probably also:

crates/hir_expand/src/diagnostics.rs 107:30-107:56: Expected Box<dyn FnMut(&dyn Diagnostic), Global>, got Box<F, Global>
crates/ide/src/lib.rs 238:62-238:65: Expected &dyn Fn(PrimeCachesProgress) + Sync, got &F
crates/stdx/src/process.rs 25:29-51:9: Expected &mut dyn FnMut(bool, &mut Vec<u8, Global>, bool), got &mut |bool, {unknown}, bool| -> ()
crates/hir_expand/src/diagnostics.rs 87:26-87:38: Expected Box<dyn FnMut(&dyn Diagnostic) -> bool, Global>, got Box<F, Global>
crates/ide/src/runnables.rs 106:36-124:5: Expected &mut dyn FnMut(Either<ModuleDef, Impl>), got &mut |Either<ModuleDef, {unknown}>| -> ()
crates/project_model/src/build_data.rs 180:12-252:13: Expected &mut dyn FnMut(&str), got &mut |str| -> ()

trait impls inside bodies: feat: Make block-local trait impls work #9244

crates/hir_ty/src/lib.rs 301:16-301:37: Expected &mut dyn Folder<Interner>, got &mut FreeVarFolder<impl FnMut(BoundVar, DebruijnIndex) -> Ty<Interner>>
crates/hir_ty/src/lib.rs 328:16-328:32: Expected &mut dyn Folder<Interner>, got &mut TyFolder<impl FnMut(Ty<Interner>, DebruijnIndex) -> Ty<Interner>>
crates/hir_ty/src/lib.rs 446:42-446:61: Expected &mut dyn Folder<Interner>, got &mut ErrorReplacer
crates/mbe/src/tt_iter.rs 122:41-122:50: Expected &mut dyn TreeSink, got &mut OffsetTokenSink

HasInterner::Interner projection: Chalk HasInterner derive macro doesn't work because it expands to named constant #9562

crates/hir_ty/src/lower.rs 1011:86-1011:95: Expected &<Binders<WhereClause<Interner>> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/lower.rs 1011:68-1011:96: Expected ProgramClause<Interner>, got Binders<WhereClause<Interner>>
crates/hir_ty/src/display.rs 387:57-387:66: Expected &<Binders<Vec<Binders<WhereClause<Interner>>, Global>> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/display.rs 573:53-573:62: Expected &<Binders<Vec<Binders<WhereClause<Interner>>, Global>> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/display.rs 621:68-621:77: Expected &<Binders<WhereClause<Interner>> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/display.rs 655:53-655:62: Expected &<Binders<Vec<Binders<WhereClause<Interner>>, Global>> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/autoderef.rs 97:32-97:41: Expected &<Ty<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/autoderef.rs 108:33-108:42: Expected &<Ty<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/autoderef.rs 134:41-134:50: Expected &<ConstrainedSubst<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/autoderef.rs 172:85-172:94: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/autoderef.rs 174:61-174:70: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/chalk_ext.rs 220:44-220:53: Expected &<Binders<Vec<Binders<WhereClause<Interner>>, Global>> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/chalk_ext.rs 239:64-239:73: Expected &<Binders<WhereClause<Interner>> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/builder.rs 41:31-41:40: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/builder.rs 133:46-133:55: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/builder.rs 138:87-138:96: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/method_resolution.rs 806:43-806:52: Expected &<Ty<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/chalk_db.rs 682:44-682:53: Expected &<Binders<WhereClause<Interner>> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/chalk_db.rs 684:4-684:10: Expected Vec<Binders<WhereClause<Interner>>, Global>, got Vec<<Binders<WhereClause<Interner>> as Fold<<Binders<WhereClause<Interner>> as HasInterner>::Interner>>::Result, Global>
crates/hir_ty/src/chalk_db.rs 678:52-685:1: Expected Vec<Binders<WhereClause<Interner>>, Global>, got Vec<<Binders<WhereClause<Interner>> as Fold<<Binders<WhereClause<Interner>> as HasInterner>::Interner>>::Result, Global>
crates/hir_ty/src/chalk_db.rs 705:42-705:51: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/chalk_db.rs 717:42-717:51: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/expr.rs 1008:32-1008:41: Expected &<Binders<WhereClause<Interner>> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/unify.rs 96:18-96:27: Expected &<(Ty<Interner>, Ty<Interner>) as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/unify.rs 117:80-117:89: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/unify.rs 119:86-119:95: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/unify.rs 121:87-121:96: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/unify.rs 56:34-56:43: Expected &<Substitution<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/unify.rs 57:85-57:94: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/unify.rs 58:88-58:97: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/unify.rs 59:84-59:93: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/unify.rs 61:65-61:74: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/unify.rs 476:72-476:81: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/unify.rs 489:72-489:81: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir_ty/src/infer/unify.rs 509:18-509:27: Expected &<GenericArg<Interner> as HasInterner>::Interner, got &Interner
crates/hir/src/display.rs 240:56-240:65: Expected &<Binders<WhereClause<Interner>> as HasInterner>::Interner, got &Interner

Chalk Fold::Result projection: probably also Chalk HasInterner derive macro doesn't work because it expands to named constant #9562

crates/hir_ty/src/infer/unify.rs 346:42-346:55: Expected Canonicalized<InEnvironment<Goal<Interner>>>, got Canonicalized<<InEnvironment<Goal<Interner>> as Fold<Interner>>::Result>
crates/hir_ty/src/infer/unify.rs 345:40-345:54: Expected &Canonicalized<InEnvironment<Goal<Interner>>>, got &Canonicalized<<InEnvironment<Goal<Interner>> as Fold<Interner>>::Result>
crates/hir_ty/src/infer/unify.rs 372:48-372:59: Expected InEnvironment<Goal<Interner>>, got <InEnvironment<Goal<Interner>> as Fold<Interner>>::Result
crates/hir/src/display.rs 242:57-242:68: Expected &[Binders<WhereClause<Interner>>], got &Vec<<Binders<WhereClause<Interner>> as Fold<<Binders<WhereClause<Interner>> as HasInterner>::Interner>>::Result, Global>

probably expected type not passed through correctly for unsized coercion (fix: Fix coercion in match with expected type #9239)

crates/hir_ty/src/chalk_db.rs 104:53-104:67: Expected &[TyFingerprint; 12], got &[TyFingerprint; 2]
crates/ide/src/display/navigation_target.rs 342:33-342:35: Expected &Macro, got &Fn
crates/hir_def/src/attr.rs 71:20-71:23: Expected &Arc<[Attr]>, got &[Attr; 0]
crates/hir_def/src/attr.rs 82:20-82:23: Expected &Arc<[Attr]>, got &[Attr; 0]
crates/hir_def/src/attr.rs 224:41-224:47: Expected &TupleField, got &RecordField

Expected InFile<&dyn AttrsOwner>, got InFile<&SourceFile>: Improve expected type handling for calls #9560

crates/hir_def/src/attr.rs 305:70-305:97: Expected InFile<&dyn AttrsOwner>, got InFile<&SourceFile>
crates/hir_def/src/attr.rs 355:51-355:90: Expected InFile<&dyn AttrsOwner>, got InFile<&LifetimeParam>
crates/hir_def/src/attr.rs 359:51-359:90: Expected InFile<&dyn AttrsOwner>, got InFile<&ConstParam>
crates/hir_def/src/attr.rs 377:57-377:91: Expected InFile<&dyn AttrsOwner>, got InFile<&Module>
crates/hir_def/src/attr.rs 381:57-381:84: Expected InFile<&dyn AttrsOwner>, got InFile<&SourceFile>
crates/ide/src/display/navigation_target.rs 317:53-317:71: Expected InFile<&dyn NameOwner>, got InFile<&RecordField>

Also similar:

crates/proc_macro_api/src/msg.rs 100:15-100:28: Expected Result<Option<&String>, Error>, got Result<Option<&mut String>, {unknown}>
crates/rust-analyzer/tests/slow-tests/support.rs 326:16-326:36: Expected Option<(&Value, &Value)>, got Option<(&&Value, &&Value)>
crates/rust-analyzer/tests/slow-tests/support.rs 327:19-330:13: Expected Option<(&&Value, &&Value)>, got Option<(&Value, &Value)>
crates/rust-analyzer/tests/slow-tests/support.rs 324:12-330:13: Expected Option<(&Value, &Value)>, got Option<(&&Value, &&Value)>
crates/rust-analyzer/tests/slow-tests/support.rs 332:48-348:9: Expected Option<(&&Value, &&Value)>, got Option<(&Value, &Value)>
crates/rust-analyzer/tests/slow-tests/support.rs 352:13-352:37: Expected Option<(&&Value, &&Value)>, got Option<(&Value, &Value)>
crates/rust-analyzer/tests/slow-tests/support.rs 304:4-353:5: Expected Option<(&Value, &Value)>, got Option<(&&Value, &&Value)>
crates/rust-analyzer/tests/slow-tests/support.rs 303:95-354:1: Expected Option<(&Value, &Value)>, got Option<(&&Value, &&Value)>
crates/tt/src/buffer.rs 166:27-166:40: Expected Option<&Subtree>, got Option<&&Subtree>
crates/tt/src/buffer.rs 194:83-194:91: Expected Option<&TokenTree>, got Option<&&TokenTree>
crates/ide/src/doc_links.rs 33:83-33:96: Expected Option<&mut dyn FnMut(BrokenLink) -> Option<(CowStr, CowStr)>>, got Option<&mut fn broken_link_clone_cb(BrokenLink) -> Option<(CowStr, CowStr)>>
crates/ide/src/doc_links.rs 74:68-74:81: Expected Option<&mut dyn FnMut(BrokenLink) -> Option<(CowStr, CowStr)>>, got Option<&mut |BrokenLink| -> Option<(CowStr, CowStr)>>
crates/ide/src/doc_links.rs 127:8-127:39: Expected Option<&mut dyn FnMut(BrokenLink) -> Option<(CowStr, CowStr)>>, got Option<&mut fn broken_link_clone_cb(BrokenLink) -> Option<(CowStr, CowStr)>>
crates/proc_macro_srv/src/lib.rs 75:8-80:10: Expected Result<&Expander, String>, got Result<&mut Expander, {unknown}>
crates/proc_macro_srv/src/lib.rs 70:76-81:5: Expected Result<&Expander, String>, got Result<&mut Expander, {unknown}>
crates/proc_macro_srv/src/proc_macro/bridge/rpc.rs 279:39-279:50: Expected Box<&str, Global>, got Box<String, Global>
crates/proc_macro_srv/src/proc_macro/bridge/rpc.rs 292:39-292:46: Expected Option<&&str>, got Option<&String>
crates/proc_macro_srv/src/proc_macro/bridge/rpc.rs 290:8-294:9: Expected Option<&str>, got Option<&&str>
crates/proc_macro_srv/src/proc_macro/bridge/rpc.rs 289:41-295:5: Expected Option<&str>, got Option<&&str>
crates/project_model/src/workspace.rs 148:47-148:64: Expected Option<&AbsPath>, got Option<&AbsPathBuf>
crates/hir_ty/src/diagnostics/expr.rs 115:43-115:68: Expected AstPtr<RecordExpr>, got AstPtr<&RecordExpr>

Expected &dyn X, got &impl X: Handle implicit Sized bounds #8984

crates/hir_def/src/item_tree/lower.rs 701:50-701:54: Expected &dyn GenericParamsOwner, got &impl GenericParamsOwner
crates/hir_def/src/item_tree/lower.rs 713:50-713:54: Expected &dyn GenericParamsOwner, got &impl GenericParamsOwner
crates/hir_def/src/item_tree/lower.rs 727:55-727:59: Expected &dyn GenericParamsOwner, got &impl GenericParamsOwner
crates/hir_def/src/item_tree/lower.rs 733:55-733:59: Expected &dyn GenericParamsOwner, got &impl GenericParamsOwner
crates/hir_expand/src/diagnostics.rs 56:33-56:35: Expected &dyn Diagnostic, got &impl Diagnostic
crates/hir_def/src/path.rs 82:59-82:66: Expected &mut dyn FnMut(ModPath, &UseTree, bool, Option<ImportAlias>), got &mut impl FnMut(ModPath, &UseTree, bool, Option<ImportAlias>)

Maybe also

crates/syntax/src/algo.rs 264:39-264:53: Expected &mut (dyn Iterator<Item = NodeOrToken<SyntaxNode<RustLanguage>, SyntaxToken<RustLanguage>>>), got &mut <impl IntoIterator<Item = NodeOrToken<SyntaxNode<RustLanguage>, SyntaxToken<RustLanguage>>> as IntoIterator>::IntoIter
crates/syntax/src/algo.rs 308:41-308:55: Expected &mut (dyn Iterator<Item = NodeOrToken<SyntaxNode<RustLanguage>, SyntaxToken<RustLanguage>>>), got &mut <impl IntoIterator<Item = NodeOrToken<SyntaxNode<RustLanguage>, SyntaxToken<RustLanguage>>> as IntoIterator>::IntoIter

These are the remaining ones I haven't categorized yet (28; I suspect a few are follow-ups from missing attribute macro support or other missing features):

crates/hir_expand/src/builtin_macro.rs 166:61-166:78: Expected usize, got TextSize
crates/hir_expand/src/builtin_macro.rs 166:48-166:78: Expected TextSize, got <usize as Sub<TextSize>>::Output

crates/ide/src/doc_links.rs 314:28-314:67: Expected str, got String
crates/ide/src/doc_links.rs 314:28-314:67: Expected str, got String
crates/ide_assists/src/handlers/raw_string.rs 79:91-79:98: Expected str, got String
crates/syntax/src/ast/make.rs 69:15-69:19: Expected &str, got &String

crates/ide_db/src/search.rs 391:74-391:79: Expected &SyntaxNode<RustLanguage>, got &Lazy<{unknown}, || -> SyntaxNode<RustLanguage>>
crates/ide_db/src/search.rs 409:62-409:67: Expected &SyntaxNode<RustLanguage>, got &Lazy<{unknown}, || -> SyntaxNode<RustLanguage>>

crates/hir/src/semantics/source_to_def.rs 157:8-157:39: Expected Option<ID>, got Copied<{unknown}>
crates/hir/src/semantics/source_to_def.rs 152:20-158:5: Expected Option<ID>, got Copied<{unknown}>
crates/hir/src/semantics/source_to_def.rs 166:8-166:52: Expected Option<TypeParamId>, got Copied<{unknown}>
crates/hir/src/semantics/source_to_def.rs 160:99-167:5: Expected Option<TypeParamId>, got Copied<{unknown}>
crates/hir/src/semantics/source_to_def.rs 178:8-178:56: Expected Option<LifetimeParamId>, got Copied<{unknown}>
crates/hir/src/semantics/source_to_def.rs 172:33-179:5: Expected Option<LifetimeParamId>, got Copied<{unknown}>
crates/hir/src/semantics/source_to_def.rs 190:8-190:53: Expected Option<ConstParamId>, got Copied<{unknown}>
crates/hir/src/semantics/source_to_def.rs 184:30-191:5: Expected Option<ConstParamId>, got Copied<{unknown}>

crates/hir_def/src/find_path.rs 112:67-114:5: Expected &mut dyn FnMut(&DefMap, Idx<ModuleData>) -> Option<Name>, got &mut |{unknown}, {unknown}| -> Map<{unknown}, |({unknown}, {unknown})| -> {unknown}>
crates/hir_def/src/find_path.rs 139:55-141:17: Expected &mut dyn FnMut(&DefMap, Idx<ModuleData>) -> Option<{unknown}>, got &mut |{unknown}, {unknown}| -> Filter<{unknown}, |&{unknown}| -> bool>
crates/hir_def/src/nameres.rs 303:47-309:9: Expected &mut dyn FnMut(&DefMap, Idx<ModuleData>) -> Option<ModuleId>, got &mut |{unknown}, {unknown}| -> Option<{unknown}>
crates/hir_def/src/nameres/path_resolution.rs 257:52-263:17: Expected &mut dyn FnMut(&DefMap, Idx<ModuleData>) -> Option<PerNs>, got &mut |{unknown}, {unknown}| -> Option<PerNs>
crates/hir_def/src/resolver.rs 348:62-355:17: Expected &mut dyn FnMut(&DefMap, Idx<ModuleData>) -> Option<{unknown}>, got &mut |{unknown}, {unknown}| -> Option<()>

crates/hir_ty/src/diagnostics/decl_check/case_conv.rs 54:13-54:54: Expected String, got <String as Add<&String>>::Output
crates/ide_assists/src/handlers/convert_comment_block.rs 170:8-170:43: Expected String, got <String as Add<&&str>>::Output
crates/ide_assists/src/handlers/convert_comment_block.rs 169:11-171:5: Expected String, got <String as Add<&&str>>::Output
crates/tt/src/lib.rs 258:35-260:29: Expected <String as Add<&String>>::Output, got String
crates/tt/src/lib.rs 262:29-262:30: Expected <String as Add<&String>>::Output, got String
crates/tt/src/lib.rs 265:42-265:62: Expected <String as Add<&String>>::Output, got String
crates/tt/src/lib.rs 267:25-267:27: Expected &str, got &<String as Add<&String>>::Output

The text was updated successfully, but these errors were encountered:

bjorn3 · 2021-05-24T12:23:38Z

Expected &dyn X, got &impl X: weird one, maybe a Chalk bug?

Just a guess: Who is responsible for the impl X for dyn X impl for object safe traits? Is it Chalk or rust-analyzer. If it is Chalk does rust-analyzer need to tell Chalk that the trait is object safe? And are unsizing pointer coercions implemented?

https://github.com/rust-analyzer/rust-analyzer/blob/31a19148e967163ea9ebb42e341944be76ce8960/crates/hir_expand/src/diagnostics.rs#L55-L57

flodiebold · 2021-05-24T18:01:45Z

The impl X for dyn X doesn't come into it. The relevant Unsize implementation comes from Chalk, and the impl Diagnostic is in this case just a placeholder for which there should be a T: Diagnostic clause in the environment. We tell Chalk that every trait is object safe, and unsizing is implemented. (That said, it might very well be some oversight, similar to what I suspect for Expected .+, got !.)

flodiebold · 2021-05-25T10:54:52Z

Aah, the Expected &dyn X, got &impl X is because we don't add the implicit + Sized...

9239: fix: Fix coercion in match with expected type r=flodiebold a=flodiebold Plus add infrastructure to test type mismatches without expect. CC #8961 Co-authored-by: Florian Diebold <flodiebold@gmail.com>

9244: feat: Make block-local trait impls work r=flodiebold a=flodiebold As long as either the trait or the implementing type are defined in the same block. CC #8961 Co-authored-by: Florian Diebold <flodiebold@gmail.com>

lnicola · 2021-08-16T18:55:21Z

self:

webrender:

(8) Expected &mut [{unknown}], got &mut [i32; 1] Proc macros / non-deterministic analysis results with webrender #9997
(2) Expected &mut dyn FnMut(&TypedRect<f32, LayoutPixel>, &TypedRect<f32, LayoutPixel>, GpuDataRequest), got &mut |{unknown}, {unknown}, {unknown}| -> ()
(2) Expected Vec<FilterOp, Global>, got Vec<<AuxIter<FilterOp> as IntoIterator>::Item, Global>
(1) Expected {unknown}, got <{unknown} as Index<i32>>::Output Proc macros / non-deterministic analysis results with webrender #9997
(1) Expected {unknown}, got i32 Proc macros / non-deterministic analysis results with webrender #9997
(2) Expected &str, got String: Type mismatch with format! on the 2018 edition #11572

ripgrep:

(3) Expected bool, got &bool: MBE doesn't bracket reference arguments #9996
(2) Expected (), got bool: Wrong inferred type in while and if with block conditions #11561

diesel:

diesel/src/query_builder/where_clause.rs 119:32-119:48: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<Predicate, Global>              
diesel/src/query_builder/where_clause.rs 169:41-169:93: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<Grouped<And<Box<dyn QueryFragment<DB> + Send, Global>, Predicate>>, Global>
diesel/src/query_builder/where_clause.rs 170:44-170:63: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<Predicate, Global>
diesel/src/query_builder/where_clause.rs 186:41-186:92: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<Grouped<Or<Box<dyn QueryFragment<DB> + Send, Global>, Predicate>>, Global>
diesel/src/query_builder/where_clause.rs 187:44-187:63: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<Predicate, Global>
diesel/src/query_builder/order_clause.rs 9:13-9:29: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<Expr, Global>
diesel/src/query_builder/sql_query.rs 213:18-213:77: Expected Box<dyn Fn(AstPass<DB>) -> Result<(), Error>, Global>, got Box<|AstPass<DB>| -> Result<(), Error>, Global>
diesel/src/query_builder/select_clause.rs 95:8-95:24: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<T, Global>
diesel/src/query_builder/select_clause.rs 94:80-96:5: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<T, Global>
diesel/src/query_builder/select_clause.rs 108:8-108:44: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<<QS as QuerySource>::DefaultSelection, Global>
diesel/src/query_builder/select_clause.rs 107:79-109:5: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<<QS as QuerySource>::DefaultSelection, Global>
diesel/src/query_builder/debug_query.rs 57:26-57:49: Expected &dyn Debug, got &String                                    
diesel/src/query_builder/debug_query.rs 58:28-58:40: Expected &dyn Debug, got &DebugBinds<T, DB>              
diesel/src/query_builder/select_statement/dsl_impls.rs 363:12-363:35: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<D, Global>                   
diesel/src/query_builder/select_statement/boxed.rs 60:22-60:40: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<G, Global>                         
diesel/src/query_builder/select_statement/boxed.rs 178:24-178:48: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<DistinctClause, Global>
diesel/src/query_builder/select_statement/boxed.rs 193:20-193:39: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<Selection, Global>
diesel/src/query_builder/select_statement/boxed.rs 243:39-243:88: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<LimitClause<Bound<BigInt, i64>>, Global>
diesel/src/query_builder/select_statement/boxed.rs 256:40-256:91: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<OffsetClause<Bound<BigInt, i64>>, Global>
diesel/src/query_builder/select_statement/boxed.rs 283:30-283:52: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<(Box<dyn QueryFragment<DB> + Send, Global>, Order), Global>
diesel/src/query_builder/select_statement/boxed.rs 284:25-284:40: Expected Box<dyn QueryFragment<DB> + Send, Global>, got Box<Order, Global>   
diesel/src/query_builder/ast_pass.rs 205:24-205:28: Expected &dyn Debug, got &U                                                                                              
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B,) as EqAll<(SB,)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B,) as EqAll<(SB,)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B,) as EqAll<(SB,)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B,) as EqAll<(SB,)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C) as EqAll<(SB, SC)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C) as EqAll<(SB, SC)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C) as EqAll<(SB, SC)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C) as EqAll<(SB, SC)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D) as EqAll<(SB, SC, SD)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D) as EqAll<(SB, SC, SD)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D) as EqAll<(SB, SC, SD)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D) as EqAll<(SB, SC, SD)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E) as EqAll<(SB, SC, SD, SE)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E) as EqAll<(SB, SC, SD, SE)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E) as EqAll<(SB, SC, SD, SE)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E) as EqAll<(SB, SC, SD, SE)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F) as EqAll<(SB, SC, SD, SE, SF)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F) as EqAll<(SB, SC, SD, SE, SF)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F) as EqAll<(SB, SC, SD, SE, SF)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F) as EqAll<(SB, SC, SD, SE, SF)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G) as EqAll<(SB, SC, SD, SE, SF, SG)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G) as EqAll<(SB, SC, SD, SE, SF, SG)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G) as EqAll<(SB, SC, SD, SE, SF, SG)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G) as EqAll<(SB, SC, SD, SE, SF, SG)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H) as EqAll<(SB, SC, SD, SE, SF, SG, SH)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H) as EqAll<(SB, SC, SD, SE, SF, SG, SH)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H) as EqAll<(SB, SC, SD, SE, SF, SG, SH)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H) as EqAll<(SB, SC, SD, SE, SF, SG, SH)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>
diesel/src/expression_methods/eq_all.rs 73:0-73:53: Expected Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>>::Output>>, got Grouped<And<Nullable<<A as EqAll<SA>>::Output>, <<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) as EqAll<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>>::Output as AsExpression<Nullable<Bool>>>::Expression>>

9973: Handle coercion on binary operator RHS r=flodiebold a=lnicola Closes #9968 CC #8961 Co-authored-by: Laurențiu Nicola <lnicola@dend.ro>

10193: fix: fix type mismatches with `panic!()` on Rust 1.55.0 r=jonas-schievink a=jonas-schievink This addresses the regression mentioned in #8961 (comment) (no test because #10192 makes that rather hard, but I've checked that the analysis-stats are back to normal) bors r+ Co-authored-by: Jonas Schievink <jonasschievink@gmail.com>

flodiebold · 2022-03-14T11:20:22Z

Update: Expected &dyn DefDatabase, got &DB will be fixed by rust-lang/chalk#727. For Expected &Expr, got Vec<PathExpr, Global>, I opened #11681 (this might be a big refactoring, or just a small fix? not sure). The DynMap problem (Expected Option<MacroCallId>, got Copied<{unknown}> and Expected Option<&[MacroCallId]>, got Map<{unknown}, fn as_ref<{unknown}, {unknown}>(&{unknown}) -> &{unknown}>) I have investigated and know the cause of, but it requires yet another cleanup/refactoring in method resolution (I'm having to properly fix all the shortcuts / simplifications that I basically already knew were wrong but seemed good enough at the time 😄 ). So we are pretty much on the way to fixing everything 🙂

For the other crates, it'd be interesting to check them again after the Chalk fix lands (especially Diesel). There are still some Chalk problems left that might occur there though. I would open new tracking issues for those once we're at 0 for rust-analyzer though.

flodiebold · 2022-04-13T14:28:15Z

With #11970, we are now at 1 type mismatch, which is the hygiene issue #11681. Let's count this as done and track other type mismatches in separate issues 🙂

matklad · 2022-04-13T14:31:21Z

🎉 🥳 🎉

we are now at 1 type mismatch

This is just amazing, would never have thought that being possible without effectively merging rustc and ra

flodiebold added A-ty type system / type inference / traits / method resolution S-actionable Someone could pick this issue up and work on it right now labels May 24, 2021

matklad mentioned this issue May 24, 2021

Steering issue #4 #8972

Closed

6 tasks

flodiebold mentioned this issue Jun 12, 2021

fix: Fix coercion in match with expected type #9239

Merged

bors bot added a commit that referenced this issue Jun 12, 2021

Merge #9239

cbc0d20

9239: fix: Fix coercion in match with expected type r=flodiebold a=flodiebold Plus add infrastructure to test type mismatches without expect. CC #8961 Co-authored-by: Florian Diebold <flodiebold@gmail.com>

bors bot added a commit that referenced this issue Jun 12, 2021

Merge #9239

d6737e5

9239: fix: Fix coercion in match with expected type r=flodiebold a=flodiebold Plus add infrastructure to test type mismatches without expect. CC #8961 Co-authored-by: Florian Diebold <flodiebold@gmail.com>

flodiebold mentioned this issue Jun 13, 2021

feat: Make block-local trait impls work #9244

Merged

matklad mentioned this issue Jul 12, 2021

Steering issue #5 #9580

Closed

7 tasks

jonas-schievink mentioned this issue Aug 16, 2021

Steering issue #6 #9925

Closed

4 tasks

This was referenced Aug 21, 2021

Type mismatch with deref and reseating references #9968

Closed

Normalization issue with operators or Deref #9971

Closed

Handle coercion on binary operator RHS #9973

Merged

bors bot added a commit that referenced this issue Aug 21, 2021

Merge #9973

337ccc7

9973: Handle coercion on binary operator RHS r=flodiebold a=lnicola Closes #9968 CC #8961 Co-authored-by: Laurențiu Nicola <lnicola@dend.ro>

This was referenced Aug 22, 2021

Type mismatch in salsa-generated code #9990

Closed

MBE doesn't bracket reference arguments #9996

Closed

This comment was marked as resolved.

Sign in to view

This comment has been minimized.

Sign in to view

jonas-schievink mentioned this issue Sep 9, 2021

fix: fix type mismatches with panic!() on Rust 1.55.0 #10193

Merged

lnicola mentioned this issue Dec 20, 2021

Steering issue #9 #11068

Closed

2 tasks

flodiebold mentioned this issue Mar 11, 2022

Hygiene not taken into account for name resolution (wrong type inference with izip!) #11681

Open

jonas-schievink mentioned this issue Mar 14, 2022

Steering issue #11 #11704

Closed

19 tasks

flodiebold mentioned this issue Mar 17, 2022

fix: Properly unify receivers during method resolution #11743

Merged

This comment was marked as off-topic.

Sign in to view

flodiebold closed this as completed Apr 13, 2022

Veykril mentioned this issue Mar 4, 2023

Fix up our pattern type inference and enable pattern type mismatch diagnostic #14250

Closed

This was referenced Aug 23, 2023

False positive E0308 with &dyn - Expected x, found y #15506

Closed

False positive E0308 with &[&dyn T] inference #15507

Closed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Tracking issue: Fix remaining type mismatches in rust-analyzer repo #8961

Tracking issue: Fix remaining type mismatches in rust-analyzer repo #8961

flodiebold commented May 24, 2021 •

edited by lnicola

bjorn3 commented May 24, 2021

flodiebold commented May 24, 2021 •

edited

flodiebold commented May 25, 2021 •

edited

lnicola commented Aug 16, 2021 •

edited

This comment was marked as resolved.

This comment was marked as resolved.

This comment has been minimized.

This comment has been minimized.

flodiebold commented Mar 14, 2022 •

edited

This comment was marked as off-topic.

This comment was marked as off-topic.

flodiebold commented Apr 13, 2022

matklad commented Apr 13, 2022

Tracking issue: Fix remaining type mismatches in rust-analyzer repo #8961

Tracking issue: Fix remaining type mismatches in rust-analyzer repo #8961

Comments

flodiebold commented May 24, 2021 • edited by lnicola

bjorn3 commented May 24, 2021

flodiebold commented May 24, 2021 • edited

flodiebold commented May 25, 2021 • edited

lnicola commented Aug 16, 2021 • edited

This comment was marked as resolved.

This comment was marked as resolved.

This comment has been minimized.

This comment has been minimized.

flodiebold commented Mar 14, 2022 • edited

This comment was marked as off-topic.

This comment was marked as off-topic.

flodiebold commented Apr 13, 2022

matklad commented Apr 13, 2022

flodiebold commented May 24, 2021 •

edited by lnicola

flodiebold commented May 24, 2021 •

edited

flodiebold commented May 25, 2021 •

edited

lnicola commented Aug 16, 2021 •

edited

flodiebold commented Mar 14, 2022 •

edited