Don't require has_self when adding constness

This can help with typeck and fixes ui tests.

Author: fee1-dead

compiler/rustc_typeck/src/astconv/generics.rs

@@ -390,7 +390,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 }
             }
         }
-        if !has_constness && has_self && let Some(constness) = constness {
+        if !has_constness && let Some(constness) = constness {
             if let ty::ConstnessArg::Const = constness {
                 substs.push(constness.into());
             }

compiler/rustc_typeck/src/check/check.rs

@@ -84,6 +84,7 @@ pub(super) fn check_fn<'a, 'tcx>(
     can_be_generator: Option<hir::Movability>,
     return_type_pre_known: bool,
 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
+    debug!(?body.value.hir_id);
     // Create the function context. This is either derived from scratch or,
     // in the case of closures, based on the outer context.
     let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);

compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs

@@ -845,6 +845,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         expect_args
     }
 
+    #[tracing::instrument(level = "debug", skip(self))]
     pub(in super::super) fn resolve_lang_item_path(
         &self,
         lang_item: hir::LangItem,

compiler/rustc_typeck/src/check/fn_ctxt/mod.rs

@@ -147,15 +147,25 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             return_type_pre_known: true,
             return_type_has_opaque: false,
             constness: {
-                if body_id.is_owner() {
-                    let did = body_id.expect_owner();
-                    if inh.tcx.is_const_fn_raw(did.to_def_id()) || inh.tcx.is_const_default_method(did.to_def_id()) || inh.tcx.def_kind(did.to_def_id()) == hir::def::DefKind::Const {
+                fn get_constness(tcx: TyCtxt<'_>, did: DefId) -> ty::ConstnessArg {
+                    if tcx.is_const_fn_raw(did) || tcx.is_const_default_method(did) || tcx.def_kind(did) == hir::def::DefKind::Const {
+                        trace!("const");
                         ty::ConstnessArg::Const
                     } else {
+                        trace!("not const");
+                        ty::ConstnessArg::Not
+                    }
+                }
+                if body_id.is_owner() {
+                    let did = body_id.expect_owner();
+                    get_constness(inh.tcx, did.to_def_id())
+                } else if let Some(hir::Node::Expr(hir::Expr { kind, .. })) = inh.tcx.hir().find(body_id) {
+                    if let hir::ExprKind::Closure { .. } = kind {
                         ty::ConstnessArg::Not
+                    } else {
+                        get_constness(inh.tcx, body_id.owner.to_def_id())
                     }
                 } else {
-                    // TODO: check correctness
                     ty::ConstnessArg::Not
                 }
             },