19 files changed, 126 insertions, 65 deletions

diff --git a/crates/assists/src/handlers/add_lifetime_to_type.rs b/crates/assists/src/handlers/add_lifetime_to_type.rs
index c1603e972..2edf7b204 100644
--- a/crates/assists/src/handlers/add_lifetime_to_type.rs
+++ b/crates/assists/src/handlers/add_lifetime_to_type.rs
@@ -26,7 +26,7 @@ pub(crate) fn add_lifetime_to_type(acc: &mut Assists, ctx: &AssistContext) -> Op
         return None;
     }
 
-    let node = ctx.find_node_at_offset::<ast::AdtDef>()?;
+    let node = ctx.find_node_at_offset::<ast::Adt>()?;
     let has_lifetime = node
         .generic_param_list()
         .map(|gen_list| gen_list.lifetime_params().count() > 0)
@@ -66,9 +66,9 @@ pub(crate) fn add_lifetime_to_type(acc: &mut Assists, ctx: &AssistContext) -> Op
     )
 }
 
-fn fetch_borrowed_types(node: &ast::AdtDef) -> Option<Vec<RefType>> {
+fn fetch_borrowed_types(node: &ast::Adt) -> Option<Vec<RefType>> {
     let ref_types: Vec<RefType> = match node {
-        ast::AdtDef::Enum(enum_) => {
+        ast::Adt::Enum(enum_) => {
             let variant_list = enum_.variant_list()?;
             variant_list
                 .variants()
@@ -80,11 +80,11 @@ fn fetch_borrowed_types(node: &ast::AdtDef) -> Option<Vec<RefType>> {
                 .flatten()
                 .collect()
         }
-        ast::AdtDef::Struct(strukt) => {
+        ast::Adt::Struct(strukt) => {
             let field_list = strukt.field_list()?;
             find_ref_types_from_field_list(&field_list)?
         }
-        ast::AdtDef::Union(un) => {
+        ast::Adt::Union(un) => {
             let record_field_list = un.record_field_list()?;
             record_field_list
                 .fields()
diff --git a/crates/assists/src/handlers/generate_derive.rs b/crates/assists/src/handlers/generate_derive.rs
index f876b7684..adae8ab7e 100644
--- a/crates/assists/src/handlers/generate_derive.rs
+++ b/crates/assists/src/handlers/generate_derive.rs
@@ -26,7 +26,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // ```
 pub(crate) fn generate_derive(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let cap = ctx.config.snippet_cap?;
-    let nominal = ctx.find_node_at_offset::<ast::AdtDef>()?;
+    let nominal = ctx.find_node_at_offset::<ast::Adt>()?;
     let node_start = derive_insertion_offset(&nominal)?;
     let target = nominal.syntax().text_range();
     acc.add(
@@ -58,7 +58,7 @@ pub(crate) fn generate_derive(acc: &mut Assists, ctx: &AssistContext) -> Option<
 }
 
 // Insert `derive` after doc comments.
-fn derive_insertion_offset(nominal: &ast::AdtDef) -> Option<TextSize> {
+fn derive_insertion_offset(nominal: &ast::Adt) -> Option<TextSize> {
     let non_ws_child = nominal
         .syntax()
         .children_with_tokens()
diff --git a/crates/assists/src/handlers/generate_enum_match_method.rs b/crates/assists/src/handlers/generate_enum_match_method.rs
index 4cf66b5d5..9d6b161c9 100644
--- a/crates/assists/src/handlers/generate_enum_match_method.rs
+++ b/crates/assists/src/handlers/generate_enum_match_method.rs
@@ -49,7 +49,7 @@ pub(crate) fn generate_enum_match_method(acc: &mut Assists, ctx: &AssistContext)
     // Return early if we've found an existing new fn
     let impl_def = find_struct_impl(
         &ctx,
-        &ast::AdtDef::Enum(parent_enum.clone()),
+        &ast::Adt::Enum(parent_enum.clone()),
         format!("is_{}", fn_name).as_str(),
     )?;
 
diff --git a/crates/assists/src/handlers/generate_impl.rs b/crates/assists/src/handlers/generate_impl.rs
index 827477272..61d1bd25c 100644
--- a/crates/assists/src/handlers/generate_impl.rs
+++ b/crates/assists/src/handlers/generate_impl.rs
@@ -27,7 +27,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let nominal = ctx.find_node_at_offset::<ast::AdtDef>()?;
+    let nominal = ctx.find_node_at_offset::<ast::Adt>()?;
     let name = nominal.name()?;
     let target = nominal.syntax().text_range();
 
diff --git a/crates/assists/src/handlers/generate_new.rs b/crates/assists/src/handlers/generate_new.rs
index 307f2e228..a9203d33f 100644
--- a/crates/assists/src/handlers/generate_new.rs
+++ b/crates/assists/src/handlers/generate_new.rs
@@ -40,7 +40,7 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
     };
 
     // Return early if we've found an existing new fn
-    let impl_def = find_struct_impl(&ctx, &ast::AdtDef::Struct(strukt.clone()), "new")?;
+    let impl_def = find_struct_impl(&ctx, &ast::Adt::Struct(strukt.clone()), "new")?;
 
     let target = strukt.syntax().text_range();
     acc.add(AssistId("generate_new", AssistKind::Generate), "Generate `new`", target, |builder| {
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index 8045aac40..cd80c2958 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -281,7 +281,7 @@ pub(crate) fn does_pat_match_variant(pat: &ast::Pat, var: &ast::Pat) -> bool {
 // FIXME: this partially overlaps with `find_impl_block`
 pub(crate) fn find_struct_impl(
     ctx: &AssistContext,
-    strukt: &ast::AdtDef,
+    strukt: &ast::Adt,
     name: &str,
 ) -> Option<Option<ast::Impl>> {
     let db = ctx.db();
@@ -290,9 +290,9 @@ pub(crate) fn find_struct_impl(
     })?;
 
     let struct_def = match strukt {
-        ast::AdtDef::Enum(e) => Adt::Enum(ctx.sema.to_def(e)?),
-        ast::AdtDef::Struct(s) => Adt::Struct(ctx.sema.to_def(s)?),
-        ast::AdtDef::Union(u) => Adt::Union(ctx.sema.to_def(u)?),
+        ast::Adt::Enum(e) => Adt::Enum(ctx.sema.to_def(e)?),
+        ast::Adt::Struct(s) => Adt::Struct(ctx.sema.to_def(s)?),
+        ast::Adt::Union(u) => Adt::Union(ctx.sema.to_def(u)?),
     };
 
     let block = module.descendants().filter_map(ast::Impl::cast).find_map(|impl_blk| {
diff --git a/crates/completion/src/completions/keyword.rs b/crates/completion/src/completions/keyword.rs
index 47e146128..eb81f9765 100644
--- a/crates/completion/src/completions/keyword.rs
+++ b/crates/completion/src/completions/keyword.rs
@@ -88,6 +88,7 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
         add_keyword(ctx, acc, "loop", "loop {$0}");
         add_keyword(ctx, acc, "if", "if $0 {}");
         add_keyword(ctx, acc, "if let", "if let $1 = $0 {}");
+        add_keyword(ctx, acc, "for", "for $1 in $0 {}");
     }
 
     if ctx.if_is_prev || ctx.block_expr_parent {
@@ -258,6 +259,7 @@ mod tests {
                 kw loop
                 kw if
                 kw if let
+                kw for
                 kw let
                 kw mod
                 kw const
@@ -284,6 +286,7 @@ mod tests {
                 kw loop
                 kw if
                 kw if let
+                kw for
                 kw let
                 kw mod
                 kw const
@@ -310,6 +313,7 @@ mod tests {
                 kw loop
                 kw if
                 kw if let
+                kw for
                 kw let
                 kw else
                 kw else if
@@ -343,6 +347,7 @@ fn quux() -> i32 {
                 kw loop
                 kw if
                 kw if let
+                kw for
                 kw unsafe
                 kw return
             "#]],
@@ -391,6 +396,7 @@ fn quux() -> i32 {
                 kw loop
                 kw if
                 kw if let
+                kw for
                 kw let
                 kw mod
                 kw const
@@ -549,6 +555,7 @@ pub mod future {
                 kw loop
                 kw if
                 kw if let
+                kw for
                 kw return
             "#]],
         )
@@ -607,6 +614,7 @@ fn foo() {
                 kw loop
                 kw if
                 kw if let
+                kw for
                 kw return
             "#]],
         );
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index f6bf49546..418ac8cbb 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -17,9 +17,9 @@ ena = "0.14.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 scoped-tls = "1"
-chalk-solve = { version = "0.55", default-features = false }
-chalk-ir = "0.55"
-chalk-recursive = "0.55"
+chalk-solve = { version = "0.56", default-features = false }
+chalk-ir = "0.56"
+chalk-recursive = "0.56"
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
 
 stdx = { path = "../stdx", version = "0.0.0" }
diff --git a/crates/hir_ty/src/traits/chalk/interner.rs b/crates/hir_ty/src/traits/chalk/interner.rs
index 6a4aa8333..54bd1c724 100644
--- a/crates/hir_ty/src/traits/chalk/interner.rs
+++ b/crates/hir_ty/src/traits/chalk/interner.rs
@@ -193,8 +193,9 @@ impl chalk_ir::interner::Interner for Interner {
         tls::with_current_program(|prog| Some(prog?.debug_quantified_where_clauses(clauses, fmt)))
     }
 
-    fn intern_ty(&self, ty: chalk_ir::TyData<Self>) -> Arc<chalk_ir::TyData<Self>> {
-        Arc::new(ty)
+    fn intern_ty(&self, kind: chalk_ir::TyKind<Self>) -> Arc<chalk_ir::TyData<Self>> {
+        let flags = kind.compute_flags(self);
+        Arc::new(chalk_ir::TyData { kind, flags })
     }
 
     fn ty_data<'a>(&self, ty: &'a Arc<chalk_ir::TyData<Self>>) -> &'a chalk_ir::TyData<Self> {
diff --git a/crates/ide/src/goto_implementation.rs b/crates/ide/src/goto_implementation.rs
index 761a98b2c..3990305fc 100644
--- a/crates/ide/src/goto_implementation.rs
+++ b/crates/ide/src/goto_implementation.rs
@@ -23,7 +23,7 @@ pub(crate) fn goto_implementation(
 
     let krate = sema.to_module_def(position.file_id)?.krate();
 
-    if let Some(nominal_def) = find_node_at_offset::<ast::AdtDef>(&syntax, position.offset) {
+    if let Some(nominal_def) = find_node_at_offset::<ast::Adt>(&syntax, position.offset) {
         return Some(RangeInfo::new(
             nominal_def.syntax().text_range(),
             impls_for_def(&sema, &nominal_def, krate)?,
@@ -40,13 +40,13 @@ pub(crate) fn goto_implementation(
 
 fn impls_for_def(
     sema: &Semantics<RootDatabase>,
-    node: &ast::AdtDef,
+    node: &ast::Adt,
     krate: Crate,
 ) -> Option<Vec<NavigationTarget>> {
     let ty = match node {
-        ast::AdtDef::Struct(def) => sema.to_def(def)?.ty(sema.db),
-        ast::AdtDef::Enum(def) => sema.to_def(def)?.ty(sema.db),
-        ast::AdtDef::Union(def) => sema.to_def(def)?.ty(sema.db),
+        ast::Adt::Struct(def) => sema.to_def(def)?.ty(sema.db),
+        ast::Adt::Enum(def) => sema.to_def(def)?.ty(sema.db),
+        ast::Adt::Union(def) => sema.to_def(def)?.ty(sema.db),
     };
 
     let impls = Impl::all_in_crate(sema.db, krate);
diff --git a/crates/rust-analyzer/src/cli/analysis_bench.rs b/crates/rust-analyzer/src/cli/analysis_bench.rs
index a01b49822..6735b6388 100644
--- a/crates/rust-analyzer/src/cli/analysis_bench.rs
+++ b/crates/rust-analyzer/src/cli/analysis_bench.rs
@@ -16,7 +16,10 @@ use ide_db::{
 };
 use vfs::AbsPathBuf;
 
-use crate::cli::{load_cargo::load_cargo, print_memory_usage, Verbosity};
+use crate::cli::{
+    load_cargo::{load_cargo, LoadCargoConfig},
+    print_memory_usage, Verbosity,
+};
 
 pub struct BenchCmd {
     pub path: PathBuf,
@@ -59,7 +62,14 @@ impl BenchCmd {
 
         let start = Instant::now();
         eprint!("loading: ");
-        let (mut host, vfs) = load_cargo(&self.path, self.load_output_dirs, self.with_proc_macro)?;
+
+        let load_cargo_config = LoadCargoConfig {
+            cargo_config: Default::default(),
+            load_out_dirs_from_check: self.load_output_dirs,
+            with_proc_macro: self.with_proc_macro,
+        };
+
+        let (mut host, vfs) = load_cargo(&self.path, &load_cargo_config)?;
         eprintln!("{:?}\n", start.elapsed());
 
         let file_id = {
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 66416f709..3417af687 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -25,8 +25,10 @@ use stdx::format_to;
 use syntax::AstNode;
 
 use crate::cli::{
-    load_cargo::load_cargo, print_memory_usage, progress_report::ProgressReport, report_metric,
-    Result, Verbosity,
+    load_cargo::{load_cargo, LoadCargoConfig},
+    print_memory_usage,
+    progress_report::ProgressReport,
+    report_metric, Result, Verbosity,
 };
 use profile::StopWatch;
 
@@ -57,7 +59,12 @@ impl AnalysisStatsCmd {
         };
 
         let mut db_load_sw = self.stop_watch();
-        let (host, vfs) = load_cargo(&self.path, self.load_output_dirs, self.with_proc_macro)?;
+        let load_cargo_config = LoadCargoConfig {
+            cargo_config: Default::default(),
+            load_out_dirs_from_check: self.load_output_dirs,
+            with_proc_macro: self.with_proc_macro,
+        };
+        let (host, vfs) = load_cargo(&self.path, &load_cargo_config)?;
         let db = host.raw_database();
         eprintln!("{:<20} {}", "Database loaded:", db_load_sw.elapsed());
 
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
index 0090fd2c2..c60374c24 100644
--- a/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -10,7 +10,10 @@ use hir::{db::HirDatabase, Crate, Module};
 use ide::{DiagnosticsConfig, Severity};
 use ide_db::base_db::SourceDatabaseExt;
 
-use crate::cli::{load_cargo::load_cargo, Result};
+use crate::cli::{
+    load_cargo::{load_cargo, LoadCargoConfig},
+    Result,
+};
 
 fn all_modules(db: &dyn HirDatabase) -> Vec<Module> {
     let mut worklist: Vec<_> =
@@ -25,8 +28,17 @@ fn all_modules(db: &dyn HirDatabase) -> Vec<Module> {
     modules
 }
 
-pub fn diagnostics(path: &Path, load_output_dirs: bool, with_proc_macro: bool) -> Result<()> {
-    let (host, _vfs) = load_cargo(path, load_output_dirs, with_proc_macro)?;
+pub fn diagnostics(
+    path: &Path,
+    load_out_dirs_from_check: bool,
+    with_proc_macro: bool,
+) -> Result<()> {
+    let load_cargo_config = LoadCargoConfig {
+        cargo_config: Default::default(),
+        load_out_dirs_from_check,
+        with_proc_macro,
+    };
+    let (host, _vfs) = load_cargo(path, &load_cargo_config)?;
     let db = host.raw_database();
     let analysis = host.analysis();
 
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index e12e87180..cc63c6cc2 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -13,14 +13,16 @@ use vfs::{loader::Handle, AbsPath, AbsPathBuf};
 
 use crate::reload::{ProjectFolders, SourceRootConfig};
 
-pub fn load_cargo(
-    root: &Path,
-    load_out_dirs_from_check: bool,
-    with_proc_macro: bool,
-) -> Result<(AnalysisHost, vfs::Vfs)> {
+pub struct LoadCargoConfig {
+    pub cargo_config: CargoConfig,
+    pub load_out_dirs_from_check: bool,
+    pub with_proc_macro: bool,
+}
+
+pub fn load_cargo(root: &Path, config: &LoadCargoConfig) -> Result<(AnalysisHost, vfs::Vfs)> {
     let root = AbsPathBuf::assert(std::env::current_dir()?.join(root));
     let root = ProjectManifest::discover_single(&root)?;
-    let ws = ProjectWorkspace::load(root, &CargoConfig::default(), &|_| {})?;
+    let ws = ProjectWorkspace::load(root, &config.cargo_config, &|_| {})?;
 
     let (sender, receiver) = unbounded();
     let mut vfs = vfs::Vfs::default();
@@ -30,14 +32,14 @@ pub fn load_cargo(
         Box::new(loader)
     };
 
-    let proc_macro_client = if with_proc_macro {
+    let proc_macro_client = if config.with_proc_macro {
         let path = std::env::current_exe()?;
         Some(ProcMacroClient::extern_process(path, &["proc-macro"]).unwrap())
     } else {
         None
     };
 
-    let build_data = if load_out_dirs_from_check {
+    let build_data = if config.load_out_dirs_from_check {
         let mut collector = BuildDataCollector::default();
         ws.collect_build_data_configs(&mut collector);
         Some(collector.collect(&|_| {})?)
@@ -116,7 +118,13 @@ mod tests {
     #[test]
     fn test_loading_rust_analyzer() {
         let path = Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap().parent().unwrap();
-        let (host, _vfs) = load_cargo(path, false, false).unwrap();
+        let load_cargo_config = LoadCargoConfig {
+            cargo_config: Default::default(),
+            load_out_dirs_from_check: false,
+            with_proc_macro: false,
+        };
+
+        let (host, _vfs) = load_cargo(path, &load_cargo_config).unwrap();
         let n_crates = Crate::all(host.raw_database()).len();
         // RA has quite a few crates, but the exact count doesn't matter
         assert!(n_crates > 20);
diff --git a/crates/rust-analyzer/src/cli/ssr.rs b/crates/rust-analyzer/src/cli/ssr.rs
index bbb550ec9..8729ff0d9 100644
--- a/crates/rust-analyzer/src/cli/ssr.rs
+++ b/crates/rust-analyzer/src/cli/ssr.rs
@@ -1,11 +1,19 @@
 //! Applies structured search replace rules from the command line.
 
-use crate::cli::{load_cargo::load_cargo, Result};
+use crate::cli::{
+    load_cargo::{load_cargo, LoadCargoConfig},
+    Result,
+};
 use ssr::{MatchFinder, SsrPattern, SsrRule};
 
 pub fn apply_ssr_rules(rules: Vec<SsrRule>) -> Result<()> {
     use ide_db::base_db::SourceDatabaseExt;
-    let (host, vfs) = load_cargo(&std::env::current_dir()?, true, true)?;
+    let load_cargo_config = LoadCargoConfig {
+        cargo_config: Default::default(),
+        load_out_dirs_from_check: true,
+        with_proc_macro: true,
+    };
+    let (host, vfs) = load_cargo(&std::env::current_dir()?, &load_cargo_config)?;
     let db = host.raw_database();
     let mut match_finder = MatchFinder::at_first_file(db)?;
     for rule in rules {
@@ -28,7 +36,12 @@ pub fn apply_ssr_rules(rules: Vec<SsrRule>) -> Result<()> {
 pub fn search_for_patterns(patterns: Vec<SsrPattern>, debug_snippet: Option<String>) -> Result<()> {
     use ide_db::base_db::SourceDatabaseExt;
     use ide_db::symbol_index::SymbolsDatabase;
-    let (host, _vfs) = load_cargo(&std::env::current_dir()?, true, true)?;
+    let load_cargo_config = LoadCargoConfig {
+        cargo_config: Default::default(),
+        load_out_dirs_from_check: true,
+        with_proc_macro: true,
+    };
+    let (host, _vfs) = load_cargo(&std::env::current_dir()?, &load_cargo_config)?;
     let db = host.raw_database();
     let mut match_finder = MatchFinder::at_first_file(db)?;
     for pattern in patterns {
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index 7ce9a4ab6..be0bea00b 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -44,6 +44,7 @@ define_semantic_token_types![
     (BRACE, "brace"),
     (BRACKET, "bracket"),
     (BUILTIN_TYPE, "builtinType"),
+    (CHAR_LITERAL, "characterLiteral"),
     (COMMA, "comma"),
     (COLON, "colon"),
     (DOT, "dot"),
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 96f915f1c..5236932e8 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -426,7 +426,8 @@ fn semantic_token_type_and_modifiers(
         HlTag::None => semantic_tokens::GENERIC,
         HlTag::ByteLiteral | HlTag::NumericLiteral => lsp_types::SemanticTokenType::NUMBER,
         HlTag::BoolLiteral => semantic_tokens::BOOLEAN,
-        HlTag::CharLiteral | HlTag::StringLiteral => lsp_types::SemanticTokenType::STRING,
+        HlTag::StringLiteral => lsp_types::SemanticTokenType::STRING,
+        HlTag::CharLiteral => semantic_tokens::CHAR_LITERAL,
         HlTag::Comment => lsp_types::SemanticTokenType::COMMENT,
         HlTag::Attribute => semantic_tokens::ATTRIBUTE,
         HlTag::Keyword => lsp_types::SemanticTokenType::KEYWORD,
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index aa6f6e0b6..e3ef71650 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 [dependencies]
 itertools = "0.10.0"
 rowan = "0.12.2"
-rustc_lexer = { version = "702.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "705.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.5.1"
 once_cell = "1.3.1"
diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs
index 5baa54a3f..064931aec 100644
--- a/crates/syntax/src/ast/generated/nodes.rs
+++ b/crates/syntax/src/ast/generated/nodes.rs
@@ -1401,15 +1401,15 @@ pub enum FieldList {
     TupleFieldList(TupleFieldList),
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum AdtDef {
+pub enum Adt {
     Enum(Enum),
     Struct(Struct),
     Union(Union),
 }
-impl ast::AttrsOwner for AdtDef {}
-impl ast::GenericParamsOwner for AdtDef {}
-impl ast::NameOwner for AdtDef {}
-impl ast::VisibilityOwner for AdtDef {}
+impl ast::AttrsOwner for Adt {}
+impl ast::GenericParamsOwner for Adt {}
+impl ast::NameOwner for Adt {}
+impl ast::VisibilityOwner for Adt {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum AssocItem {
     Const(Const),
@@ -3394,16 +3394,16 @@ impl AstNode for FieldList {
         }
     }
 }
-impl From<Enum> for AdtDef {
-    fn from(node: Enum) -> AdtDef { AdtDef::Enum(node) }
+impl From<Enum> for Adt {
+    fn from(node: Enum) -> Adt { Adt::Enum(node) }
 }
-impl From<Struct> for AdtDef {
-    fn from(node: Struct) -> AdtDef { AdtDef::Struct(node) }
+impl From<Struct> for Adt {
+    fn from(node: Struct) -> Adt { Adt::Struct(node) }
 }
-impl From<Union> for AdtDef {
-    fn from(node: Union) -> AdtDef { AdtDef::Union(node) }
+impl From<Union> for Adt {
+    fn from(node: Union) -> Adt { Adt::Union(node) }
 }
-impl AstNode for AdtDef {
+impl AstNode for Adt {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
             ENUM | STRUCT | UNION => true,
@@ -3412,18 +3412,18 @@ impl AstNode for AdtDef {
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         let res = match syntax.kind() {
-            ENUM => AdtDef::Enum(Enum { syntax }),
-            STRUCT => AdtDef::Struct(Struct { syntax }),
-            UNION => AdtDef::Union(Union { syntax }),
+            ENUM => Adt::Enum(Enum { syntax }),
+            STRUCT => Adt::Struct(Struct { syntax }),
+            UNION => Adt::Union(Union { syntax }),
             _ => return None,
         };
         Some(res)
     }
     fn syntax(&self) -> &SyntaxNode {
         match self {
-            AdtDef::Enum(it) => &it.syntax,
-            AdtDef::Struct(it) => &it.syntax,
-            AdtDef::Union(it) => &it.syntax,
+            Adt::Enum(it) => &it.syntax,
+            Adt::Struct(it) => &it.syntax,
+            Adt::Union(it) => &it.syntax,
         }
     }
 }
@@ -3571,7 +3571,7 @@ impl std::fmt::Display for FieldList {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for AdtDef {
+impl std::fmt::Display for Adt {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }