Revert source_analyzer changes

Author: SomeoneToIgnore

crates/ra_hir/src/code_model.rs

@@ -696,7 +696,6 @@ impl AssocItem {
             AssocItem::TypeAlias(t) => t.module(db),
         }
     }
-
     pub fn container(self, db: &impl DefDatabase) -> AssocItemContainer {
         let container = match self {
             AssocItem::Function(it) => it.id.lookup(db).container,

crates/ra_hir/src/source_analyzer.rs

@@ -20,19 +20,16 @@ use hir_def::{
 use hir_expand::{
     hygiene::Hygiene, name::AsName, AstId, HirFileId, InFile, MacroCallId, MacroCallKind,
 };
-use hir_ty::{
-    method_resolution::{iterate_method_candidates, LookupMode},
-    Canonical, InEnvironment, InferenceResult, TraitEnvironment,
-};
+use hir_ty::{InEnvironment, InferenceResult, TraitEnvironment};
 use ra_syntax::{
     ast::{self, AstNode},
     AstPtr, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange, TextUnit,
 };
 use rustc_hash::FxHashSet;
 
 use crate::{
-    db::HirDatabase, Adt, AssocItem, Const, DefWithBody, EnumVariant, Function, Local, MacroDef,
-    ModuleDef, Name, Path, ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam,
+    db::HirDatabase, Adt, Const, DefWithBody, EnumVariant, Function, Local, MacroDef, Name, Path,
+    ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam,
 };
 
 /// `SourceAnalyzer` is a convenience wrapper which exposes HIR API in terms of
@@ -292,11 +289,9 @@ impl SourceAnalyzer {
 
     pub fn resolve_path(&self, db: &impl HirDatabase, path: &ast::Path) -> Option<PathResolution> {
         if let Some(path_expr) = path.syntax().parent().and_then(ast::PathExpr::cast) {
-            let path_resolution = self
-                .resolve_as_full_path(path_expr.clone())
-                .or_else(|| self.resolve_as_path_to_method(db, &path_expr));
-            if path_resolution.is_some() {
-                return path_resolution;
+            let expr_id = self.expr_id(&path_expr.into())?;
+            if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_expr(expr_id) {
+                return Some(PathResolution::AssocItem(assoc.into()));
             }
         }
         if let Some(path_pat) = path.syntax().parent().and_then(ast::PathPat::cast) {
@@ -310,49 +305,6 @@ impl SourceAnalyzer {
         self.resolve_hir_path(db, &hir_path)
     }
 
-    fn resolve_as_full_path(&self, path_expr: ast::PathExpr) -> Option<PathResolution> {
-        let expr_id = self.expr_id(&path_expr.into())?;
-        self.infer
-            .as_ref()?
-            .assoc_resolutions_for_expr(expr_id)
-            .map(|assoc| PathResolution::AssocItem(assoc.into()))
-    }
-
-    fn resolve_as_path_to_method(
-        &self,
-        db: &impl HirDatabase,
-        path_expr: &ast::PathExpr,
-    ) -> Option<PathResolution> {
-        let full_path = path_expr.path()?;
-        let path_to_method = full_path.qualifier()?;
-        let method_name = full_path.segment()?.syntax().to_string();
-        match self.resolve_path(db, &path_to_method)? {
-            PathResolution::Def(ModuleDef::Adt(adt)) => {
-                let ty = adt.ty(db);
-                iterate_method_candidates(
-                    &Canonical { value: ty.ty.value, num_vars: 0 },
-                    db,
-                    ty.ty.environment,
-                    self.resolver.krate()?,
-                    &self.resolver.traits_in_scope(db),
-                    None,
-                    LookupMode::Path,
-                    |_, assoc_item_id| {
-                        let assoc = assoc_item_id.into();
-                        if let AssocItem::Function(function) = assoc {
-                            if function.name(db).to_string() == method_name {
-                                return Some(assoc);
-                            }
-                        }
-                        None
-                    },
-                )
-            }
-            _ => None,
-        }
-        .map(PathResolution::AssocItem)
-    }
-
     fn resolve_local_name(&self, name_ref: &ast::NameRef) -> Option<ScopeEntryWithSyntax> {
         let name = name_ref.as_name();
         let source_map = self.body_source_map.as_ref()?;