WIP Add late desugaring to rustc_resolve

compiler/rustc_interface/src/passes.rs

@@ -273,7 +273,7 @@ fn configure_and_expand(
 
     // Done with macro expansion!
 
-    resolver.resolve_crate(&krate);
+    resolver.resolve_crate(&mut krate);
 
     krate
 }

compiler/rustc_resolve/src/late.rs

@@ -12,6 +12,7 @@ use crate::{path_names_to_string, rustdoc, BindingError, Finalize, LexicalScopeB
 use crate::{Module, ModuleOrUniformRoot, NameBinding, ParentScope, PathResult};
 use crate::{ResolutionError, Resolver, Segment, UseError};
 
+use rustc_ast::mut_visit::MutVisitor;
 use rustc_ast::ptr::P;
 use rustc_ast::visit::{self, AssocCtxt, BoundKind, FnCtxt, FnKind, Visitor};
 use rustc_ast::*;
@@ -669,7 +670,7 @@ struct LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
     /// State used to know whether to ignore resolution errors for function bodies.
     ///
     /// In particular, rustdoc uses this to avoid giving errors for `cfg()` items.
-    /// In most cases this will be `None`, in which case errors will always be reported.
+    /// In most cases this will be `false`, in which case errors will always be reported.
     /// If it is `true`, then it will be updated when entering a nested function or trait body.
     in_func_body: bool,
 
@@ -4592,13 +4593,55 @@ impl<'ast> Visitor<'ast> for LifetimeCountVisitor<'_, '_, '_> {
 }
 
 impl<'a, 'tcx> Resolver<'a, 'tcx> {
-    pub(crate) fn late_resolve_crate(&mut self, krate: &Crate) {
+    pub(crate) fn late_resolve_crate(&mut self, krate: &mut Crate) {
         visit::walk_crate(&mut LifetimeCountVisitor { r: self }, krate);
-        let mut late_resolution_visitor = LateResolutionVisitor::new(self);
-        late_resolution_visitor.resolve_doc_links(&krate.attrs, MaybeExported::Ok(CRATE_NODE_ID));
-        visit::walk_crate(&mut late_resolution_visitor, krate);
-        for (id, span) in late_resolution_visitor.diagnostic_metadata.unused_labels.iter() {
-            self.lint_buffer.buffer_lint(lint::builtin::UNUSED_LABELS, *id, *span, "unused label");
+        {
+            let mut late_resolution_visitor = LateResolutionVisitor::new(self);
+            late_resolution_visitor
+                .resolve_doc_links(&krate.attrs, MaybeExported::Ok(CRATE_NODE_ID));
+            visit::walk_crate(&mut late_resolution_visitor, krate);
+            for (id, span) in late_resolution_visitor.diagnostic_metadata.unused_labels.iter() {
+                self.lint_buffer.buffer_lint(
+                    lint::builtin::UNUSED_LABELS,
+                    *id,
+                    *span,
+                    "unused label",
+                );
+            }
+        }
+
+        {
+            let mut late_desugar_visitor = LateDesugarVisitor::new(self);
+            late_desugar_visitor.visit_crate(krate);
+        }
+    }
+}
+
+struct LateDesugarVisitor<'a, 'b, 'tcx> {
+    r: &'b mut Resolver<'a, 'tcx>,
+}
+
+impl<'a, 'b, 'tcx> LateDesugarVisitor<'a, 'b, 'tcx> {
+    fn new(resolver: &'b mut Resolver<'a, 'tcx>) -> Self {
+        LateDesugarVisitor { r: resolver }
+    }
+}
+
+impl MutVisitor for LateDesugarVisitor<'_, '_, '_> {
+    fn visit_ty(&mut self, ty: &mut P<Ty>) {
+        if let TyKind::Path(None, _path) = &ty.kind
+            && let Some(partial_res) = self.r.partial_res_map.get(&ty.id)
+            && let Some(res @ Res::Def(DefKind::Trait | DefKind::TraitAlias, _)) =
+                partial_res.full_res()
+        {
+            debug!("[Desugar][Ty][BareTrait][{:?}] {:?}\n{:#?}", ty.span, res, ty);
+
+            let trait_obj = TyKind::TraitObject(vec![], TraitObjectSyntax::None);
+            ty.kind = trait_obj;
+
+            debug!("->\n{:#?}\n", ty);
         }
+
+        mut_visit::noop_visit_ty(ty, self);
     }
 }

compiler/rustc_resolve/src/lib.rs

@@ -1591,7 +1591,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
     }
 
     /// Entry point to crate resolution.
-    pub fn resolve_crate(&mut self, krate: &Crate) {
+    pub fn resolve_crate(&mut self, krate: &mut Crate) {
         self.tcx.sess.time("resolve_crate", || {
             self.tcx.sess.time("finalize_imports", || self.finalize_imports());
             let exported_ambiguities = self.tcx.sess.time("compute_effective_visibilities", || {