Simplify

Author: Veykril

crates/base-db/src/input.rs

@@ -285,6 +285,7 @@ pub struct CrateData {
 /// For purposes of analysis, crates are anonymous (only names in
 /// `Dependency` matters), this name should only be used for UI.
 pubdisplay_name:Option<CrateDisplayName>,
+// FIXME: Arc this
 pubcfg_options:CfgOptions,
 /// The cfg options that could be used by the crate
 pubpotential_cfg_options:Option<CfgOptions>,

crates/hir-def/src/data.rs

@@ -737,7 +737,7 @@ impl<'a> AssocItemCollector<'a> {
 &AstIdWithPath::new(file_id, ast_id,Clone::clone(path)),
  ctxt,
  expand_to,
-self.expander.module.krate(),
+self.expander.krate(),
  resolver,
 ){
 Ok(Some(call_id)) => {

crates/hir-def/src/expander.rs

@@ -21,7 +21,6 @@ use crate::{
 pubstructExpander{
 cfg_options:CfgOptions,
 span_map:OnceCell<SpanMap>,
-krate:CrateId,
 current_file_id:HirFileId,
 pub(crate)module:ModuleId,
 /// `recursion_depth == usize::MAX` indicates that the recursion limit has been reached.
@@ -45,10 +44,13 @@ impl Expander {
  recursion_limit,
 cfg_options: db.crate_graph()[module.krate].cfg_options.clone(),
 span_map:OnceCell::new(),
-krate: module.krate,
 }
 }
 
+pubfnkrate(&self) -> CrateId{
+self.module.krate
+}
+
 pubfnenter_expand<T: ast::AstNode>(
 &mutself,
 db:&dynDefDatabase,
@@ -112,7 +114,7 @@ impl Expander {
 pub(crate)fnparse_attrs(&self,db:&dynDefDatabase,owner:&dyn ast::HasAttrs) -> Attrs{
 Attrs::filter(
  db,
-self.krate,
+self.krate(),
 RawAttrs::new(
  db.upcast(),
  owner,

crates/hir-ty/src/consteval.rs

@@ -77,30 +77,32 @@ pub(crate) fn path_to_const(
 resolver:&Resolver,
 path:&Path,
 mode:ParamLoweringMode,
-args_lazy:implFnOnce() -> Generics,
+args:implFnOnce() -> Option<Generics>,
 debruijn:DebruijnIndex,
 expected_ty:Ty,
 ) -> Option<Const>{
 match resolver.resolve_path_in_value_ns_fully(db.upcast(), path){
 Some(ValueNs::GenericParam(p)) => {
 let ty = db.const_param_ty(p);
-let args = args_lazy();
 let value = match mode {
 ParamLoweringMode::Placeholder => {
 ConstValue::Placeholder(to_placeholder_idx(db, p.into()))
 }
-ParamLoweringMode::Variable => match args.param_idx(p.into()){
-Some(it) => ConstValue::BoundVar(BoundVar::new(debruijn, it)),
-None => {
-never!(
-"Generic list doesn't contain this param: {:?}, {:?}, {:?}",
- args,
- path,
- p
-);
-returnNone;
+ParamLoweringMode::Variable => {
+let args = args();
+match args.as_ref().and_then(|args| args.param_idx(p.into())){
+Some(it) => ConstValue::BoundVar(BoundVar::new(debruijn, it)),
+None => {
+never!(
+"Generic list doesn't contain this param: {:?}, {:?}, {:?}",
+ args,
+ path,
+ p
+);
+returnNone;
+}
 }
-},
+}
 };
 Some(ConstData{ ty, value }.intern(Interner))
 }
@@ -285,7 +287,6 @@ pub(crate) fn eval_to_const(
 expr:ExprId,
 mode:ParamLoweringMode,
 ctx:&mutInferenceContext<'_>,
-args:implFnOnce() -> Generics,
 debruijn:DebruijnIndex,
 ) -> Const{
 let db = ctx.db;
@@ -304,7 +305,9 @@ pub(crate) fn eval_to_const(
 }
 ifletExpr::Path(p) = &ctx.body.exprs[expr]{
 let resolver = &ctx.resolver;
-ifletSome(c) = path_to_const(db, resolver, p, mode, args, debruijn, infer[expr].clone()){
+ifletSome(c) =
+path_to_const(db, resolver, p, mode, || ctx.generics(), debruijn, infer[expr].clone())
+{
 return c;
 }
 }

crates/hir-ty/src/infer.rs

@@ -60,7 +60,7 @@ use crate::{
  lower::ImplTraitLoweringMode,
  to_assoc_type_id,
  traits::FnTrait,
- utils::{InTypeConstIdMetadata,UnevaluatedConstEvaluatorFolder},
+ utils::{Generics,InTypeConstIdMetadata,UnevaluatedConstEvaluatorFolder},
 AliasEq,AliasTy,Binders,ClosureId,Const,DomainGoal,GenericArg,Goal,ImplTraitId,
 ImplTraitIdx,InEnvironment,Interner,Lifetime,OpaqueTyId,ProjectionTy,Substitution,
 TraitEnvironment,Ty,TyBuilder,TyExt,
@@ -630,6 +630,10 @@ impl<'a> InferenceContext<'a> {
 }
 }
 
+pub(crate)fngenerics(&self) -> Option<Generics>{
+Some(crate::utils::generics(self.db.upcast(),self.resolver.generic_def()?))
+}
+
 // FIXME: This function should be private in module. It is currently only used in the consteval, since we need
 // `InferenceResult` in the middle of inference. See the fixme comment in `consteval::eval_to_const`. If you
 // used this function for another workaround, mention it here. If you really need this function and believe that

crates/hir-ty/src/infer/cast.rs

@@ -19,10 +19,6 @@ impl CastCheck {
 let expr_ty = table.resolve_ty_shallow(&self.expr_ty);
 let cast_ty = table.resolve_ty_shallow(&self.cast_ty);
 
-if expr_ty.contains_unknown() || cast_ty.contains_unknown(){
-return;
-}
-
 if table.coerce(&expr_ty,&cast_ty).is_ok(){
 return;
 }

crates/hir-ty/src/infer/closure.rs

@@ -26,7 +26,7 @@ use crate::{
  mir::{BorrowKind,MirSpan,MutBorrowKind,ProjectionElem},
  to_chalk_trait_id,
  traits::FnTrait,
- utils::{self, elaborate_clause_supertraits,generics,Generics},
+ utils::{self, elaborate_clause_supertraits,Generics},
 Adjust,Adjustment,AliasEq,AliasTy,Binders,BindingMode,ChalkTraitId,ClosureId,DynTy,
 DynTyExt,FnAbi,FnPointer,FnSig,Interner,OpaqueTy,ProjectionTyExt,Substitution,Ty,
 TyExt,WhereClause,
@@ -331,14 +331,10 @@ impl CapturedItemWithoutTy {
 place:self.place,
 kind:self.kind,
 span:self.span,
-ty:replace_placeholder_with_binder(ctx.db, ctx.owner, ty),
+ty:replace_placeholder_with_binder(ctx, ty),
 };
 
-fnreplace_placeholder_with_binder(
-db:&dynHirDatabase,
-owner:DefWithBodyId,
-ty:Ty,
-) -> Binders<Ty>{
+fnreplace_placeholder_with_binder(ctx:&mutInferenceContext<'_>,ty:Ty) -> Binders<Ty>{
 structFiller<'a>{
 db:&'adynHirDatabase,
 generics:Generics,
@@ -379,12 +375,12 @@ impl CapturedItemWithoutTy {
 Ok(BoundVar::new(outer_binder, idx).to_ty(Interner))
 }
 }
-letSome(generic_def) = owner.as_generic_def_id()else{
+letSome(generics) = ctx.generics()else{
 returnBinders::empty(Interner, ty);
 };
-let filler = &mutFiller{ db,generics:generics(db.upcast(), generic_def)};
+let filler = &mutFiller{db: ctx.db, generics};
 let result = ty.clone().try_fold_with(filler,DebruijnIndex::INNERMOST).unwrap_or(ty);
-make_binders(db,&filler.generics, result)
+make_binders(ctx.db,&filler.generics, result)
 }
 }
 }

crates/hir-ty/src/infer/expr.rs

@@ -1040,18 +1040,12 @@ impl InferenceContext<'_> {
 
 (
  elem_ty,
-ifletSome(g_def) = self.owner.as_generic_def_id(){
-let generics = generics(self.db.upcast(), g_def);
- consteval::eval_to_const(
- repeat,
-ParamLoweringMode::Placeholder,
-self,
- || generics,
-DebruijnIndex::INNERMOST,
-)
-}else{
- consteval::usize_const(self.db,None, krate)
-},
+ consteval::eval_to_const(
+ repeat,
+ParamLoweringMode::Placeholder,
+self,
+DebruijnIndex::INNERMOST,
+),
 )
 }
 };
@@ -1852,7 +1846,7 @@ impl InferenceContext<'_> {
  ty,
  c,
 ParamLoweringMode::Placeholder,
- || generics(this.db.upcast(), this.resolver.generic_def().unwrap()),
+ || this.generics(),
 DebruijnIndex::INNERMOST,
 )
 },

crates/hir-ty/src/infer/pat.rs

@@ -2,22 +2,22 @@
 
 use std::iter::repeat_with;
 
-use chalk_ir::Mutability;
 use hir_def::{
  body::Body,
  hir::{Binding,BindingAnnotation,BindingId,Expr,ExprId,ExprOrPatId,Literal,Pat,PatId},
  path::Path,
 };
 use hir_expand::name::Name;
+use stdx::TupleExt;
 
 usecrate::{
  consteval::{try_const_usize, usize_const},
  error_lifetime,
  infer::{BindingMode,Expectation,InferenceContext,TypeMismatch},
  lower::lower_to_chalk_mutability,
  primitive::UintTy,
- static_lifetime,InferenceDiagnostic,Interner,Scalar,Substitution,Ty,TyBuilder,TyExt,
-TyKind,
+ static_lifetime,InferenceDiagnostic,Interner,Mutability,Scalar,Substitution,Ty,
+TyBuilder,TyExt,TyKind,
 };
 
 /// Used to generalize patterns and assignee expressions.
@@ -90,9 +90,6 @@ impl InferenceContext<'_> {
 
 self.unify(&ty, expected);
 
-let substs =
- ty.as_adt().map(|(_, s)| s.clone()).unwrap_or_else(|| Substitution::empty(Interner));
-
 match def {
  _ if subs.is_empty() => {}
 Some(def) => {
@@ -109,26 +106,28 @@ impl InferenceContext<'_> {
 let pre_iter = pre.iter().enumerate();
 let post_iter = (post_idx_offset..).zip(post.iter());
 
+let substs = ty.as_adt().map(TupleExt::tail);
+
 for(i,&subpat)in pre_iter.chain(post_iter){
-letfield_def = {
+letexpected_ty = {
 match variant_data.field(&Name::new_tuple_field(i)){
 Some(local_id) => {
 if !visibilities[local_id]
 .is_visible_from(self.db.upcast(),self.resolver.module())
 {
 // FIXME(DIAGNOSE): private tuple field
 }
-Some(local_id)
+let f = field_types[local_id].clone();
+let expected_ty = match substs {
+Some(substs) => f.substitute(Interner, substs),
+None => f.substitute(Interner,&Substitution::empty(Interner)),
+};
+self.normalize_associated_types_in(expected_ty)
 }
-None => None,
+None => self.err_ty(),
 }
 };
 
-let expected_ty = field_def.map_or(self.err_ty(), |f| {
- field_types[f].clone().substitute(Interner,&substs)
-});
-let expected_ty = self.normalize_associated_types_in(expected_ty);
-
 T::infer(self, subpat,&expected_ty, default_bm);
 }
 }
@@ -159,18 +158,17 @@ impl InferenceContext<'_> {
 
 self.unify(&ty, expected);
 
-let substs =
- ty.as_adt().map(|(_, s)| s.clone()).unwrap_or_else(|| Substitution::empty(Interner));
-
 match def {
  _ if subs.len() == 0 => {}
 Some(def) => {
 let field_types = self.db.field_types(def);
 let variant_data = def.variant_data(self.db.upcast());
 let visibilities = self.db.field_visibilities(def);
 
+let substs = ty.as_adt().map(TupleExt::tail);
+
 for(name, inner)in subs {
-letfield_def = {
+letexpected_ty = {
 match variant_data.field(&name){
 Some(local_id) => {
 if !visibilities[local_id]
@@ -181,23 +179,23 @@ impl InferenceContext<'_> {
 private:true,
 });
 }
-Some(local_id)
+let f = field_types[local_id].clone();
+let expected_ty = match substs {
+Some(substs) => f.substitute(Interner, substs),
+None => f.substitute(Interner,&Substitution::empty(Interner)),
+};
+self.normalize_associated_types_in(expected_ty)
 }
 None => {
 self.push_diagnostic(InferenceDiagnostic::NoSuchField{
 field: inner.into(),
 private:false,
 });
-None
+self.err_ty()
 }
 }
 };
 
-let expected_ty = field_def.map_or(self.err_ty(), |f| {
- field_types[f].clone().substitute(Interner,&substs)
-});
-let expected_ty = self.normalize_associated_types_in(expected_ty);
-
 T::infer(self, inner,&expected_ty, default_bm);
 }
 }