impl TypeBound { }  #[derive(Debug, Clone, PartialEq, Eq, Hash)]-pub enum ConstRefOrPath {-    Scalar(ConstRef),+pub enum ConstRef {+    Scalar(ConcreteConstRef),     Path(Name),+    Complex(InFile<FileAstId<ast::Expr>>), } -impl ConstRefOrPath {-    pub(crate) fn from_expr_opt(expr: Option<ast::Expr>) -> Self {+impl ConstRef {+    pub(crate) fn from_expr_opt(lower_ctx: &LowerCtx<'_>, expr: Option<ast::Expr>) -> Self {         match expr {-            Some(x) => Self::from_expr(x),-            None => Self::Scalar(ConstRef::Unknown),+            Some(x) => {+                let ast_id = lower_ctx.ast_id(&x);+                Self::from_expr(x, ast_id)+            }+            None => Self::Scalar(ConcreteConstRef::Unknown),         }     }      pub fn display<'a>(&'a self, db: &'a dyn ExpandDatabase) -> impl fmt::Display + 'a {-        struct Display<'a>(&'a dyn ExpandDatabase, &'a ConstRefOrPath);+        struct Display<'a>(&'a dyn ExpandDatabase, &'a ConstRef);         impl fmt::Display for Display<'_> {             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {                 match self.1 {-                    ConstRefOrPath::Scalar(s) => s.fmt(f),-                    ConstRefOrPath::Path(n) => n.display(self.0).fmt(f),+                    ConstRef::Scalar(s) => s.fmt(f),+                    ConstRef::Path(n) => n.display(self.0).fmt(f),+                    ConstRef::Complex(_) => f.write_str("{const}"),                 }             }         }         Display(db, self)     } -    // FIXME: as per the comments on `TypeRef::Array`, this evaluation should not happen at this-    // parse stage.-    fn from_expr(expr: ast::Expr) -> Self {+    // We special case literals and single identifiers, to speed up things.+    fn from_expr(expr: ast::Expr, ast_id: Option<InFile<FileAstId<ast::Expr>>>) -> Self {+        fn is_path_ident(p: &ast::PathExpr) -> bool {+            let Some(path) = p.path() else {+                return false;+            };+            if path.coloncolon_token().is_some() {+                return false;+            }+            if let Some(s) = path.segment() {+                if s.coloncolon_token().is_some() || s.generic_arg_list().is_some() {+                    return false;+                }+            }+            true+        }         match expr {-            ast::Expr::PathExpr(p) => {+            ast::Expr::PathExpr(p) if is_path_ident(&p) => {                 match p.path().and_then(|x| x.segment()).and_then(|x| x.name_ref()) {                     Some(x) => Self::Path(x.as_name()),-                    None => Self::Scalar(ConstRef::Unknown),+                    None => Self::Scalar(ConcreteConstRef::Unknown),                 }             }-            ast::Expr::PrefixExpr(prefix_expr) => match prefix_expr.op_kind() {-                Some(ast::UnaryOp::Neg) => {-                    let unsigned = Self::from_expr_opt(prefix_expr.expr());-                    // Add sign-                    match unsigned {-                        Self::Scalar(ConstRef::UInt(num)) => {-                            Self::Scalar(ConstRef::Int(-(num as i128)))-                        }-                        other => other,-                    }-                }-                _ => Self::from_expr_opt(prefix_expr.expr()),-            },             ast::Expr::Literal(literal) => Self::Scalar(match literal.kind() {                 ast::LiteralKind::IntNumber(num) => {-                    num.value().map(ConstRef::UInt).unwrap_or(ConstRef::Unknown)+                    num.value().map(ConcreteConstRef::UInt).unwrap_or(ConcreteConstRef::Unknown)                 }                 ast::LiteralKind::Char(c) => {-                    c.value().map(ConstRef::Char).unwrap_or(ConstRef::Unknown)+                    c.value().map(ConcreteConstRef::Char).unwrap_or(ConcreteConstRef::Unknown)                 }-                ast::LiteralKind::Bool(f) => ConstRef::Bool(f),-                _ => ConstRef::Unknown,+                ast::LiteralKind::Bool(f) => ConcreteConstRef::Bool(f),+                _ => ConcreteConstRef::Unknown,             }),-            _ => Self::Scalar(ConstRef::Unknown),+            _ => {+                if let Some(ast_id) = ast_id {+                    Self::Complex(ast_id)+                } else {+                    Self::Scalar(ConcreteConstRef::Unknown)+                }+            }         }     } }  /// A concrete constant value #[derive(Debug, Clone, PartialEq, Eq, Hash)]-pub enum ConstRef {+pub enum ConcreteConstRef {

 pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<Infer                 },             });         }+        DefWithBodyId::InTypeConstId(_) => {+            // FIXME: We should know the expected type here.

 impl_from!(     for ModuleDefId ); -// FIXME: make this a DefWithBodyId #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)] pub struct AnonymousConstId(InternId); impl_intern_key!(AnonymousConstId); +#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]+pub enum TypeOwnerId {+    ModuleId(ModuleId),

 impl_from!(     for ModuleDefId ); -// FIXME: make this a DefWithBodyId+/// Id of the anonymous const block expression and patterns. This is very similar to `ClosureId` and+/// shouldn't be a `DefWithBodyId` since its type inference is dependent on its parent. #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)] pub struct AnonymousConstId(InternId); impl_intern_key!(AnonymousConstId); +#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]+pub enum TypeOwnerId {+    ModuleId(ModuleId),+    DefWithBodyId(DefWithBodyId),+    GenericDefId(GenericDefId),+}

 impl AstIdMap {                 || ast::Variant::can_cast(kind)                 || ast::RecordField::can_cast(kind)                 || ast::TupleField::can_cast(kind)+                || ast::Expr::can_cast(kind)

 fn test() { S2.into(); }     ); } +#[test]+fn method_resolution_prefer_explicit_bound() {+    check_types(+        r#"+trait Tr<T> {+    fn tr(self) -> T;+}++impl<T> Tr<T> for T {+    fn tr(self) -> T {+        self+    }+}+fn test<T: Tr<i32>>(x: T) { x.tr(); }+                          //^^^^^^ i32+fn test<T: Tr<i32> + Tr<i64>>(x: T) { let x: i64 = x.tr(); }+                                                 //^^^^^^ i64+"#,+    );+}+