148 files changed, 5160 insertions, 3440 deletions
diff --git a/Cargo.lock b/Cargo.lock
index f3a512a8a..76a26ea4e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -320,6 +320,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc4b29f4b9bb94bf267d57269fd0706d343a160937108e9619fe380645428abb"
 [[package]]
+name = "dot"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a74b6c4d4a1cff5f454164363c16b72fa12463ca6b31f4b5f2035a65fa3d5906"
+[[package]]
 name = "drop_bomb"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -431,18 +437,18 @@ dependencies = [
 [[package]]
 name = "fsevent-sys"
-version = "3.0.2"
+version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a29c77f1ca394c3e73a9a5d24cfcabb734682d9634fc398f2204a63c994120"
+checksum = "ca6f5e6817058771c10f0eb0f05ddf1e35844266f972004fe8e4b21fda295bd5"
 dependencies = [
 "libc",
 ]
 [[package]]
 name = "fst"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d79238883cf0307100b90aba4a755d8051a3182305dfe7f649a1e9dc0517006f"
+checksum = "e398fae362f4124bbe630d99519fb2d68a03e2e3a23b441028cdcdc4f4895687"
 [[package]]
 name = "gimli"
@@ -480,6 +486,7 @@ version = "0.0.0"
 dependencies = [
 "arrayvec",
 "base_db",
+ "cfg",
 "either",
 "hir_def",
 "hir_expand",
@@ -587,6 +594,7 @@ version = "0.0.0"
 dependencies = [
 "cfg",
 "cov-mark",
+ "dot",
 "either",
 "expect-test",
 "hir",
@@ -931,11 +939,10 @@ dependencies = [
 [[package]]
 name = "notify"
-version = "5.0.0-pre.7"
+version = "5.0.0-pre.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ebe7699a0f8c5759450716ee03d231685c22b4fe8f406c42c22e0ad94d40ce7"
+checksum = "46bbbcd078f1f00ddb7a9abe70b96e91229b44b0b3afdec610f8e5137f8f014b"
 dependencies = [
- "anymap",
 "bitflags",
 "crossbeam-channel",
 "filetime",
@@ -1287,9 +1294,9 @@ checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
 [[package]]
 name = "rowan"
-version = "0.13.0-pre.5"
+version = "0.13.0-pre.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a5fc82ed0b7e7fba157331f0d8f64abd73bced6e7ac2a4dfa0c4cf0ab584e8"
+checksum = "82ccc04e145e9a5ab51b9c12a81d77c4a8250d87a407ab02ac650451141ff00d"
 dependencies = [
 "countme",
 "hashbrown",
diff --git a/Cargo.toml b/Cargo.toml
index d34251fc0..498cf7d62 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,12 @@
 [workspace]
+resolver = "2"
 members = ["xtask/", "lib/*", "crates/*"]
 [profile.dev]
+# We do want incremental builds, but they are broken at the moment :(
+# https://github.com/rust-lang/rust/issues/85003#issuecomment-833796289
+incremental = false
 # Disabling debug info speeds up builds a bunch,
 # and we don't rely on it for debugging that much.
 debug = 0
@@ -16,9 +21,14 @@ text-size.opt-level = 3
 miniz_oxide.opt-level = 3
 [profile.release]
-incremental = true
+# We do want incremental release builds, but they are broken at the moment :(
+# https://github.com/rust-lang/rust/issues/85003#issuecomment-833796289
+incremental = false
 debug = 0 # Set this to 1 or 2 to get more useful backtraces in debugger.
+[profile.test]
+incremental = false
 [patch.'crates-io']
 # rowan = { path = "../rowan" }
diff --git a/crates/cfg/src/lib.rs b/crates/cfg/src/lib.rs
index d88ecf8b0..59fd38880 100644
--- a/crates/cfg/src/lib.rs
+++ b/crates/cfg/src/lib.rs
@@ -13,7 +13,7 @@ use tt::SmolStr;
 pub use cfg_expr::{CfgAtom, CfgExpr};
 pub use dnf::DnfExpr;
-/// Configuration options used for conditional compilition on items with `cfg` attributes.
+/// Configuration options used for conditional compilation on items with `cfg` attributes.
 /// We have two kind of options in different namespaces: atomic options like `unix`, and
 /// key-value options like `target_arch="x86"`.
 ///
diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index 1682d8bde..93cf6a3d6 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -215,6 +215,7 @@ impl FlycheckActor {
            } => {
                let mut cmd = Command::new(toolchain::cargo());
                cmd.arg(command);
+                cmd.current_dir(&self.workspace_root);
                cmd.args(&["--workspace", "--message-format=json", "--manifest-path"])
                    .arg(self.workspace_root.join("Cargo.toml"));
diff --git a/crates/hir/Cargo.toml b/crates/hir/Cargo.toml
index 9e329656f..560b15238 100644
--- a/crates/hir/Cargo.toml
+++ b/crates/hir/Cargo.toml
@@ -25,3 +25,4 @@ hir_expand = { path = "../hir_expand", version = "0.0.0" }
 hir_def = { path = "../hir_def", version = "0.0.0" }
 hir_ty = { path = "../hir_ty", version = "0.0.0" }
 tt = { path = "../tt", version = "0.0.0" }
+cfg = { path = "../cfg", version = "0.0.0" }
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index f876339de..d443b124c 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -52,7 +52,9 @@ use hir_def::{
 };
 use hir_expand::{diagnostics::DiagnosticSink, name::name, MacroDefKind};
 use hir_ty::{
-    autoderef, could_unify,
+    autoderef,
+    consteval::ConstExt,
+    could_unify,
    method_resolution::{self, def_crates, TyFingerprint},
    primitive::UintTy,
    subst_prefix,
@@ -89,6 +91,7 @@ pub use crate::{
 // Generally, a refactoring which *removes* a name from this list is a good
 // idea!
 pub use {
+    cfg::{CfgAtom, CfgExpr, CfgOptions},
    hir_def::{
        adt::StructKind,
        attr::{Attr, Attrs, AttrsWithOwner, Documentation},
@@ -215,6 +218,10 @@ impl Crate {
        doc_url.map(|s| s.trim_matches('"').trim_end_matches('/').to_owned() + "/")
    }
+    pub fn cfg(&self, db: &dyn HirDatabase) -> CfgOptions {
+        db.crate_graph()[self.id].cfg_options.clone()
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -868,6 +875,10 @@ impl Function {
        db.function_data(self.id).is_unsafe()
    }
+    pub fn is_async(self, db: &dyn HirDatabase) -> bool {
+        db.function_data(self.id).is_async()
+    }
    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
        let krate = self.module(db).id.krate();
        hir_def::diagnostics::validate_body(db.upcast(), self.id.into(), sink);
@@ -1905,6 +1916,7 @@ impl Type {
                    substs.iter(&Interner).filter_map(|a| a.ty(&Interner)).any(go)
                }
+                TyKind::Array(_ty, len) if len.is_unknown() => true,
                TyKind::Array(ty, _)
                | TyKind::Slice(ty)
                | TyKind::Raw(_, ty)
@@ -2066,6 +2078,10 @@ impl Type {
        Some(adt.into())
    }
+    pub fn as_builtin(&self) -> Option<BuiltinType> {
+        self.ty.as_builtin().map(|inner| BuiltinType { inner })
+    }
    pub fn as_dyn_trait(&self) -> Option<Trait> {
        self.ty.dyn_trait().map(Into::into)
    }
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index a2479016e..aadd4e44a 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -9,7 +9,7 @@ use std::{
 use base_db::CrateId;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
-use hir_expand::{hygiene::Hygiene, name::AsName, AstId, AttrId, InFile};
+use hir_expand::{hygiene::Hygiene, name::AsName, AstId, InFile};
 use itertools::Itertools;
 use la_arena::ArenaMap;
 use mbe::ast_to_token_tree;
@@ -101,17 +101,13 @@ impl RawAttrs {
        hygiene: &Hygiene,
    ) -> Self {
        let entries = collect_attrs(owner)
-            .enumerate()
+            .flat_map(|(id, attr)| match attr {
-            .flat_map(|(i, attr)| {
+                Either::Left(attr) => Attr::from_src(db, attr, hygiene, id),
-                let index = AttrId(i as u32);
+                Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
-                match attr {
+                    id,
-                    Either::Left(attr) => Attr::from_src(db, attr, hygiene, index),
+                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
-                    Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
+                    path: Interned::new(ModPath::from(hir_expand::name!(doc))),
-                        id: index,
+                }),
-                        input: Some(AttrInput::Literal(SmolStr::new(doc))),
-                        path: Interned::new(ModPath::from(hir_expand::name!(doc))),
-                    }),
-                }
            })
            .collect::<Arc<_>>();
@@ -124,6 +120,7 @@ impl RawAttrs {
    }
    pub(crate) fn merge(&self, other: Self) -> Self {
+        // FIXME: This needs to fixup `AttrId`s
        match (&self.entries, &other.entries) {
            (None, None) => Self::EMPTY,
            (Some(entries), None) | (None, Some(entries)) => {
@@ -375,39 +372,26 @@ impl AttrsWithOwner {
                let def_map = module.def_map(db);
                let mod_data = &def_map[module.local_id];
-                let attrs = match mod_data.declaration_source(db) {
+                match mod_data.declaration_source(db) {
                    Some(it) => {
-                        let mut attrs: Vec<_> = collect_attrs(&it.value as &dyn ast::AttrsOwner)
+                        let mut map = AttrSourceMap::new(InFile::new(it.file_id, &it.value));
-                            .map(|attr| InFile::new(it.file_id, attr))
-                            .collect();
                        if let InFile { file_id, value: ModuleSource::SourceFile(file) } =
                            mod_data.definition_source(db)
                        {
-                            attrs.extend(
+                            map.merge(AttrSourceMap::new(InFile::new(file_id, &file)));
-                                collect_attrs(&file as &dyn ast::AttrsOwner)
-                                    .map(|attr| InFile::new(file_id, attr)),
-                            )
                        }
-                        attrs
+                        return map;
                    }
                    None => {
                        let InFile { file_id, value } = mod_data.definition_source(db);
-                        match &value {
+                        let attrs_owner = match &value {
-                            ModuleSource::SourceFile(file) => {
+                            ModuleSource::SourceFile(file) => file as &dyn ast::AttrsOwner,
-                                collect_attrs(file as &dyn ast::AttrsOwner)
+                            ModuleSource::Module(module) => module as &dyn ast::AttrsOwner,
-                            }
+                            ModuleSource::BlockExpr(block) => block as &dyn ast::AttrsOwner,
-                            ModuleSource::Module(module) => {
+                        };
-                                collect_attrs(module as &dyn ast::AttrsOwner)
+                        return AttrSourceMap::new(InFile::new(file_id, attrs_owner));
-                            }
-                            ModuleSource::BlockExpr(block) => {
-                                collect_attrs(block as &dyn ast::AttrsOwner)
-                            }
-                        }
-                        .map(|attr| InFile::new(file_id, attr))
-                        .collect()
                    }
-                };
+                }
-                return AttrSourceMap { attrs };
            }
            AttrDefId::FieldId(id) => {
                let map = db.fields_attrs_source_map(id.parent);
@@ -462,11 +446,7 @@ impl AttrsWithOwner {
            },
        };
-        AttrSourceMap {
+        AttrSourceMap::new(owner.as_ref().map(|node| node as &dyn AttrsOwner))
-            attrs: collect_attrs(&owner.value)
-                .map(|attr| InFile::new(owner.file_id, attr))
-                .collect(),
-        }
    }
    pub fn docs_with_rangemap(
@@ -518,7 +498,7 @@ impl AttrsWithOwner {
        if buf.is_empty() {
            None
        } else {
-            Some((Documentation(buf), DocsRangeMap { mapping, source: self.source_map(db).attrs }))
+            Some((Documentation(buf), DocsRangeMap { mapping, source_map: self.source_map(db) }))
        }
    }
 }
@@ -559,27 +539,59 @@ fn inner_attributes(
 }
 pub struct AttrSourceMap {
-    attrs: Vec<InFile<Either<ast::Attr, ast::Comment>>>,
+    attrs: Vec<InFile<ast::Attr>>,
+    doc_comments: Vec<InFile<ast::Comment>>,
 }
 impl AttrSourceMap {
+    fn new(owner: InFile<&dyn ast::AttrsOwner>) -> Self {
+        let mut attrs = Vec::new();
+        let mut doc_comments = Vec::new();
+        for (_, attr) in collect_attrs(owner.value) {
+            match attr {
+                Either::Left(attr) => attrs.push(owner.with_value(attr)),
+                Either::Right(comment) => doc_comments.push(owner.with_value(comment)),
+            }
+        }
+        Self { attrs, doc_comments }
+    }
+    fn merge(&mut self, other: Self) {
+        self.attrs.extend(other.attrs);
+        self.doc_comments.extend(other.doc_comments);
+    }
    /// Maps the lowered `Attr` back to its original syntax node.
    ///
    /// `attr` must come from the `owner` used for AttrSourceMap
    ///
    /// Note that the returned syntax node might be a `#[cfg_attr]`, or a doc comment, instead of
    /// the attribute represented by `Attr`.
-    pub fn source_of(&self, attr: &Attr) -> InFile<&Either<ast::Attr, ast::Comment>> {
+    pub fn source_of(&self, attr: &Attr) -> InFile<Either<ast::Attr, ast::Comment>> {
-        self.attrs
+        self.source_of_id(attr.id)
-            .get(attr.id.0 as usize)
+    }
-            .unwrap_or_else(|| panic!("cannot find `Attr` at index {:?}", attr.id))
-            .as_ref()
+    fn source_of_id(&self, id: AttrId) -> InFile<Either<ast::Attr, ast::Comment>> {
+        if id.is_doc_comment {
+            self.doc_comments
+                .get(id.ast_index as usize)
+                .unwrap_or_else(|| panic!("cannot find doc comment at index {:?}", id))
+                .clone()
+                .map(|attr| Either::Right(attr))
+        } else {
+            self.attrs
+                .get(id.ast_index as usize)
+                .unwrap_or_else(|| panic!("cannot find `Attr` at index {:?}", id))
+                .clone()
+                .map(|attr| Either::Left(attr))
+        }
    }
 }
 /// A struct to map text ranges from [`Documentation`] back to TextRanges in the syntax tree.
 pub struct DocsRangeMap {
-    source: Vec<InFile<Either<ast::Attr, ast::Comment>>>,
+    source_map: AttrSourceMap,
    // (docstring-line-range, attr_index, attr-string-range)
    // a mapping from the text range of a line of the [`Documentation`] to the attribute index and
    // the original (untrimmed) syntax doc line
@@ -596,7 +608,7 @@ impl DocsRangeMap {
        let relative_range = range - line_docs_range.start();
-        let &InFile { file_id, value: ref source } = &self.source[idx.0 as usize];
+        let &InFile { file_id, value: ref source } = &self.source_map.source_of_id(idx);
        match source {
            Either::Left(_) => None, // FIXME, figure out a nice way to handle doc attributes here
            // as well as for whats done in syntax highlight doc injection
@@ -615,6 +627,12 @@ impl DocsRangeMap {
    }
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) struct AttrId {
+    is_doc_comment: bool,
+    pub(crate) ast_index: u32,
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Attr {
    pub(crate) id: AttrId,
@@ -749,22 +767,32 @@ fn attrs_from_item_tree<N: ItemTreeNode>(id: ItemTreeId<N>, db: &dyn DefDatabase
 fn collect_attrs(
    owner: &dyn ast::AttrsOwner,
-) -> impl Iterator<Item = Either<ast::Attr, ast::Comment>> {
+) -> impl Iterator<Item = (AttrId, Either<ast::Attr, ast::Comment>)> {
    let (inner_attrs, inner_docs) = inner_attributes(owner.syntax())
        .map_or((None, None), |(attrs, docs)| (Some(attrs), Some(docs)));
    let outer_attrs = owner.attrs().filter(|attr| attr.kind().is_outer());
-    let attrs = outer_attrs
+    let attrs =
-        .chain(inner_attrs.into_iter().flatten())
+        outer_attrs.chain(inner_attrs.into_iter().flatten()).enumerate().map(|(idx, attr)| {
-        .map(|attr| (attr.syntax().text_range().start(), Either::Left(attr)));
+            (
+                AttrId { ast_index: idx as u32, is_doc_comment: false },
+                attr.syntax().text_range().start(),
+                Either::Left(attr),
+            )
+        });
    let outer_docs =
        ast::CommentIter::from_syntax_node(owner.syntax()).filter(ast::Comment::is_outer);
-    let docs = outer_docs
+    let docs =
-        .chain(inner_docs.into_iter().flatten())
+        outer_docs.chain(inner_docs.into_iter().flatten()).enumerate().map(|(idx, docs_text)| {
-        .map(|docs_text| (docs_text.syntax().text_range().start(), Either::Right(docs_text)));
+            (
+                AttrId { ast_index: idx as u32, is_doc_comment: true },
+                docs_text.syntax().text_range().start(),
+                Either::Right(docs_text),
+            )
+        });
    // sort here by syntax node offset because the source can have doc attributes and doc strings be interleaved
-    docs.chain(attrs).sorted_by_key(|&(offset, _)| offset).map(|(_, attr)| attr)
+    docs.chain(attrs).sorted_by_key(|&(_, offset, _)| offset).map(|(id, _, attr)| (id, attr))
 }
 pub(crate) fn variants_attrs_source_map(
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 8360426f1..98b485b60 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -21,8 +21,6 @@ use profile::Count;
 use rustc_hash::FxHashMap;
 use syntax::{ast, AstNode, AstPtr};
-pub use lower::LowerCtx;
 use crate::{
    attr::{Attrs, RawAttrs},
    db::DefDatabase,
@@ -35,6 +33,8 @@ use crate::{
    UnresolvedMacro,
 };
+pub use lower::LowerCtx;
 /// A subset of Expander that only deals with cfg attributes. We only need it to
 /// avoid cyclic queries in crate def map during enum processing.
 #[derive(Debug)]
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 75dc19c11..2a7e0205f 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -205,7 +205,7 @@ impl ExprCollector<'_> {
        self.maybe_collect_expr(expr).unwrap_or_else(|| self.missing_expr())
    }
-    /// Returns `None` if the expression is `#[cfg]`d out.
+    /// Returns `None` if and only if the expression is `#[cfg]`d out.
    fn maybe_collect_expr(&mut self, expr: ast::Expr) -> Option<ExprId> {
        let syntax_ptr = AstPtr::new(&expr);
        self.check_cfg(&expr)?;
@@ -668,7 +668,7 @@ impl ExprCollector<'_> {
                if self.check_cfg(&stmt).is_none() {
                    return;
                }
+                let has_semi = stmt.semicolon_token().is_some();
                // Note that macro could be expended to multiple statements
                if let Some(ast::Expr::MacroCall(m)) = stmt.expr() {
                    let macro_ptr = AstPtr::new(&m);
@@ -685,18 +685,19 @@ impl ExprCollector<'_> {
                                statements.statements().for_each(|stmt| this.collect_stmt(stmt));
                                if let Some(expr) = statements.expr() {
                                    let expr = this.collect_expr(expr);
-                                    this.statements_in_scope.push(Statement::Expr(expr));
+                                    this.statements_in_scope
+                                        .push(Statement::Expr { expr, has_semi });
                                }
                            }
                            None => {
                                let expr = this.alloc_expr(Expr::Missing, syntax_ptr.clone());
-                                this.statements_in_scope.push(Statement::Expr(expr));
+                                this.statements_in_scope.push(Statement::Expr { expr, has_semi });
                            }
                        },
                    );
                } else {
                    let expr = self.collect_expr_opt(stmt.expr());
-                    self.statements_in_scope.push(Statement::Expr(expr));
+                    self.statements_in_scope.push(Statement::Expr { expr, has_semi });
                }
            }
            ast::Stmt::Item(item) => {
@@ -725,8 +726,17 @@ impl ExprCollector<'_> {
        let prev_statements = std::mem::take(&mut self.statements_in_scope);
        block.statements().for_each(|s| self.collect_stmt(s));
+        block.tail_expr().and_then(|e| {
-        let tail = block.tail_expr().map(|e| self.collect_expr(e));
+            let expr = self.maybe_collect_expr(e)?;
+            Some(self.statements_in_scope.push(Statement::Expr { expr, has_semi: false }))
+        });
+        let mut tail = None;
+        if let Some(Statement::Expr { expr, has_semi: false }) = self.statements_in_scope.last() {
+            tail = Some(*expr);
+            self.statements_in_scope.pop();
+        }
+        let tail = tail;
        let statements = std::mem::replace(&mut self.statements_in_scope, prev_statements);
        let syntax_node_ptr = AstPtr::new(&block.into());
        let expr_id = self.alloc_expr(
@@ -996,23 +1006,27 @@ impl From<ast::BinOp> for BinaryOp {
 impl From<ast::LiteralKind> for Literal {
    fn from(ast_lit_kind: ast::LiteralKind) -> Self {
        match ast_lit_kind {
+            // FIXME: these should have actual values filled in, but unsure on perf impact
            LiteralKind::IntNumber(lit) => {
                if let builtin @ Some(_) = lit.suffix().and_then(BuiltinFloat::from_suffix) {
                    return Literal::Float(Default::default(), builtin);
                } else if let builtin @ Some(_) =
                    lit.suffix().and_then(|it| BuiltinInt::from_suffix(&it))
                {
-                    Literal::Int(Default::default(), builtin)
+                    Literal::Int(lit.value().unwrap_or(0) as i128, builtin)
                } else {
                    let builtin = lit.suffix().and_then(|it| BuiltinUint::from_suffix(&it));
-                    Literal::Uint(Default::default(), builtin)
+                    Literal::Uint(lit.value().unwrap_or(0), builtin)
                }
            }
            LiteralKind::FloatNumber(lit) => {
                let ty = lit.suffix().and_then(|it| BuiltinFloat::from_suffix(&it));
                Literal::Float(Default::default(), ty)
            }
-            LiteralKind::ByteString(_) => Literal::ByteString(Default::default()),
+            LiteralKind::ByteString(bs) => {
+                let text = bs.value().map(Vec::from).unwrap_or_else(Default::default);
+                Literal::ByteString(text)
+            }
            LiteralKind::String(_) => Literal::String(Default::default()),
            LiteralKind::Byte => Literal::Uint(Default::default(), Some(BuiltinUint::U8)),
            LiteralKind::Bool(val) => Literal::Bool(val),
diff --git a/crates/hir_def/src/body/scope.rs b/crates/hir_def/src/body/scope.rs
index bd7005ca6..6764de3a7 100644
--- a/crates/hir_def/src/body/scope.rs
+++ b/crates/hir_def/src/body/scope.rs
@@ -157,7 +157,7 @@ fn compute_block_scopes(
                scope = scopes.new_scope(scope);
                scopes.add_bindings(body, scope, *pat);
            }
-            Statement::Expr(expr) => {
+            Statement::Expr { expr, .. } => {
                scopes.set_scope(*expr, scope);
                compute_expr_scopes(*expr, body, scopes, scope);
            }
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index b4ad984bd..2ba619d23 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -43,8 +43,8 @@ pub enum Literal {
    ByteString(Vec<u8>),
    Char(char),
    Bool(bool),
-    Int(u64, Option<BuiltinInt>),
+    Int(i128, Option<BuiltinInt>),
-    Uint(u64, Option<BuiltinUint>),
+    Uint(u128, Option<BuiltinUint>),
    Float(u64, Option<BuiltinFloat>), // FIXME: f64 is not Eq
 }
@@ -242,7 +242,7 @@ pub struct RecordLitField {
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Statement {
    Let { pat: PatId, type_ref: Option<Interned<TypeRef>>, initializer: Option<ExprId> },
-    Expr(ExprId),
+    Expr { expr: ExprId, has_semi: bool },
 }
 impl Expr {
@@ -265,7 +265,7 @@ impl Expr {
                                f(*expr);
                            }
                        }
-                        Statement::Expr(e) => f(*e),
+                        Statement::Expr { expr: expression, .. } => f(*expression),
                    }
                }
                if let Some(expr) = tail {
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index 858e88038..ee52794aa 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -5,10 +5,10 @@ use std::iter;
 use hir_expand::name::{known, AsName, Name};
 use rustc_hash::FxHashSet;
-use crate::nameres::DefMap;
 use crate::{
    db::DefDatabase,
    item_scope::ItemInNs,
+    nameres::DefMap,
    path::{ModPath, PathKind},
    visibility::Visibility,
    ModuleDefId, ModuleId,
@@ -134,7 +134,16 @@ fn find_path_inner(
    for (name, def_id) in root_def_map.extern_prelude() {
        if item == ItemInNs::Types(*def_id) {
            let name = scope_name.unwrap_or_else(|| name.clone());
-            return Some(ModPath::from_segments(PathKind::Plain, vec![name]));
+            let name_already_occupied_in_type_ns = def_map
+                .with_ancestor_maps(db, from.local_id, &mut |def_map, local_id| {
+                    def_map[local_id].scope.get(&name).take_types().filter(|&id| id != *def_id)
+                })
+                .is_some();
+            return Some(ModPath::from_segments(
+                if name_already_occupied_in_type_ns { PathKind::Abs } else { PathKind::Plain },
+                vec![name],
+            ));
        }
    }
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 8d13c7e04..cad8a7479 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -18,7 +18,7 @@ use hir_expand::{
    ast_id_map::FileAstId,
    hygiene::Hygiene,
    name::{name, AsName, Name},
-    HirFileId, InFile,
+    FragmentKind, HirFileId, InFile,
 };
 use la_arena::{Arena, Idx, RawIdx};
 use profile::Count;
@@ -656,6 +656,7 @@ pub struct MacroCall {
    /// Path to the called macro.
    pub path: Interned<ModPath>,
    pub ast_id: FileAstId<ast::MacroCall>,
+    pub fragment: FragmentKind,
 }
 #[derive(Debug, Clone, Eq, PartialEq)]
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 5743b3386..fe348091d 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -624,7 +624,8 @@ impl<'a> Ctx<'a> {
    fn lower_macro_call(&mut self, m: &ast::MacroCall) -> Option<FileItemTreeId<MacroCall>> {
        let path = Interned::new(ModPath::from_src(self.db, m.path()?, &self.hygiene)?);
        let ast_id = self.source_ast_id_map.ast_id(m);
-        let res = MacroCall { path, ast_id };
+        let fragment = hir_expand::to_fragment_kind(m);
+        let res = MacroCall { path, ast_id, fragment };
        Some(id(self.data().macro_calls.alloc(res)))
    }
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index da46f16f7..a82ea5957 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -62,13 +62,14 @@ use hir_expand::{
    ast_id_map::FileAstId,
    eager::{expand_eager_macro, ErrorEmitted, ErrorSink},
    hygiene::Hygiene,
-    AstId, AttrId, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
+    AstId, FragmentKind, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
 };
 use la_arena::Idx;
 use nameres::DefMap;
 use path::ModPath;
 use syntax::ast;
+use crate::attr::AttrId;
 use crate::builtin_type::BuiltinType;
 use item_tree::{
    Const, Enum, Function, Impl, ItemTreeId, ItemTreeNode, ModItem, Static, Struct, Trait,
@@ -652,6 +653,7 @@ impl AsMacroCall for InFile<&ast::MacroCall> {
        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
        mut error_sink: &mut dyn FnMut(mbe::ExpandError),
    ) -> Result<Result<MacroCallId, ErrorEmitted>, UnresolvedMacro> {
+        let fragment = hir_expand::to_fragment_kind(self.value);
        let ast_id = AstId::new(self.file_id, db.ast_id_map(self.file_id).ast_id(self.value));
        let h = Hygiene::new(db.upcast(), self.file_id);
        let path = self.value.path().and_then(|path| path::ModPath::from_src(db, path, &h));
@@ -667,6 +669,7 @@ impl AsMacroCall for InFile<&ast::MacroCall> {
        macro_call_as_call_id(
            &AstIdWithPath::new(ast_id.file_id, ast_id.value, path),
+            fragment,
            db,
            krate,
            resolver,
@@ -695,6 +698,7 @@ pub struct UnresolvedMacro {
 fn macro_call_as_call_id(
    call: &AstIdWithPath<ast::MacroCall>,
+    fragment: FragmentKind,
    db: &dyn db::DefDatabase,
    krate: CrateId,
    resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
@@ -718,7 +722,11 @@ fn macro_call_as_call_id(
        .map(MacroCallId::from)
    } else {
        Ok(def
-            .as_lazy_macro(db.upcast(), krate, MacroCallKind::FnLike { ast_id: call.ast_id })
+            .as_lazy_macro(
+                db.upcast(),
+                krate,
+                MacroCallKind::FnLike { ast_id: call.ast_id, fragment },
+            )
            .into())
    };
    Ok(res)
@@ -745,7 +753,7 @@ fn derive_macro_as_call_id(
            MacroCallKind::Derive {
                ast_id: item_attr.ast_id,
                derive_name: last_segment.to_string(),
-                derive_attr,
+                derive_attr_index: derive_attr.ast_index,
            },
        )
        .into();
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 1bc72ec1f..249af6fc8 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -629,7 +629,7 @@ mod diagnostics {
                DiagnosticKind::UnresolvedProcMacro { ast } => {
                    let mut precise_location = None;
                    let (file, ast, name) = match ast {
-                        MacroCallKind::FnLike { ast_id } => {
+                        MacroCallKind::FnLike { ast_id, .. } => {
                            let node = ast_id.to_node(db.upcast());
                            (ast_id.file_id, SyntaxNodePtr::from(AstPtr::new(&node)), None)
                        }
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 05ceb1efb..19db6cc59 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -13,14 +13,14 @@ use hir_expand::{
    builtin_macro::find_builtin_macro,
    name::{AsName, Name},
    proc_macro::ProcMacroExpander,
-    AttrId, HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
+    FragmentKind, HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
 };
 use hir_expand::{InFile, MacroCallLoc};
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::ast;
 use crate::{
-    attr::Attrs,
+    attr::{AttrId, Attrs},
    db::DefDatabase,
    derive_macro_as_call_id,
    intern::Interned,
@@ -215,7 +215,7 @@ struct MacroDirective {
 #[derive(Clone, Debug, Eq, PartialEq)]
 enum MacroDirectiveKind {
-    FnLike { ast_id: AstIdWithPath<ast::MacroCall> },
+    FnLike { ast_id: AstIdWithPath<ast::MacroCall>, fragment: FragmentKind },
    Derive { ast_id: AstIdWithPath<ast::Item>, derive_attr: AttrId },
 }
@@ -481,6 +481,11 @@ impl DefCollector<'_> {
        let res = self.def_map.resolve_name_in_extern_prelude(self.db, &extern_crate.name);
        if let Some(ModuleDefId::ModuleId(m)) = res.take_types() {
+            if m == self.def_map.module_id(current_module_id) {
+                cov_mark::hit!(ignore_macro_use_extern_crate_self);
+                return;
+            }
            cov_mark::hit!(macro_rules_from_other_crates_are_visible_with_macro_use);
            self.import_all_macros_exported(current_module_id, m.krate);
        }
@@ -807,9 +812,10 @@ impl DefCollector<'_> {
        let mut res = ReachedFixedPoint::Yes;
        macros.retain(|directive| {
            match &directive.kind {
-                MacroDirectiveKind::FnLike { ast_id } => {
+                MacroDirectiveKind::FnLike { ast_id, fragment } => {
                    match macro_call_as_call_id(
                        ast_id,
+                        *fragment,
                        self.db,
                        self.def_map.krate,
                        |path| {
@@ -926,8 +932,9 @@ impl DefCollector<'_> {
        for directive in &self.unexpanded_macros {
            match &directive.kind {
-                MacroDirectiveKind::FnLike { ast_id, .. } => match macro_call_as_call_id(
+                MacroDirectiveKind::FnLike { ast_id, fragment } => match macro_call_as_call_id(
                    ast_id,
+                    *fragment,
                    self.db,
                    self.def_map.krate,
                    |path| {
@@ -1496,6 +1503,7 @@ impl ModCollector<'_, '_> {
        let mut error = None;
        match macro_call_as_call_id(
            &ast_id,
+            mac.fragment,
            self.def_collector.db,
            self.def_collector.def_map.krate,
            |path| {
@@ -1524,9 +1532,14 @@ impl ModCollector<'_, '_> {
            }
            Ok(Err(_)) => {
                // Built-in macro failed eager expansion.
+                // FIXME: don't parse the file here
+                let fragment = hir_expand::to_fragment_kind(
+                    &ast_id.ast_id.to_node(self.def_collector.db.upcast()),
+                );
                self.def_collector.def_map.diagnostics.push(DefDiagnostic::macro_error(
                    self.module_id,
-                    MacroCallKind::FnLike { ast_id: ast_id.ast_id },
+                    MacroCallKind::FnLike { ast_id: ast_id.ast_id, fragment },
                    error.unwrap().to_string(),
                ));
                return;
@@ -1543,7 +1556,7 @@ impl ModCollector<'_, '_> {
        self.def_collector.unexpanded_macros.push(MacroDirective {
            module_id: self.module_id,
            depth: self.macro_depth + 1,
-            kind: MacroDirectiveKind::FnLike { ast_id },
+            kind: MacroDirectiveKind::FnLike { ast_id, fragment: mac.fragment },
        });
    }
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index 4f2e7a2f9..9f652731d 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -411,6 +411,22 @@ struct Arc;
 }
 #[test]
+fn macro_use_extern_crate_self() {
+    cov_mark::check!(ignore_macro_use_extern_crate_self);
+    check(
+        r#"
+//- /main.rs crate:main
+#[macro_use]
+extern crate self as bla;
+"#,
+        expect![[r#"
+            crate
+            bla: t
+        "#]],
+    );
+}
+#[test]
 fn reexport_across_crates() {
    check(
        r#"
diff --git a/crates/hir_def/src/nameres/tests/incremental.rs b/crates/hir_def/src/nameres/tests/incremental.rs
index 227ecd162..d884a6eb4 100644
--- a/crates/hir_def/src/nameres/tests/incremental.rs
+++ b/crates/hir_def/src/nameres/tests/incremental.rs
@@ -137,6 +137,9 @@ m!(Z);
        });
        let n_recalculated_item_trees = events.iter().filter(|it| it.contains("item_tree")).count();
        assert_eq!(n_recalculated_item_trees, 6);
+        let n_reparsed_macros =
+            events.iter().filter(|it| it.contains("parse_macro_expansion")).count();
+        assert_eq!(n_reparsed_macros, 3);
    }
    let new_text = r#"
@@ -155,5 +158,8 @@ m!(Z);
        });
        let n_recalculated_item_trees = events.iter().filter(|it| it.contains("item_tree")).count();
        assert_eq!(n_recalculated_item_trees, 1);
+        let n_reparsed_macros =
+            events.iter().filter(|it| it.contains("parse_macro_expansion")).count();
+        assert_eq!(n_reparsed_macros, 0);
    }
 }
diff --git a/crates/hir_def/src/type_ref.rs b/crates/hir_def/src/type_ref.rs
index ea29da5da..9e44547cb 100644
--- a/crates/hir_def/src/type_ref.rs
+++ b/crates/hir_def/src/type_ref.rs
@@ -2,6 +2,7 @@
 //! be directly created from an ast::TypeRef, without further queries.
 use hir_expand::{name::Name, AstId, InFile};
+use std::convert::TryInto;
 use syntax::ast;
 use crate::{body::LowerCtx, path::Path};
@@ -79,7 +80,9 @@ pub enum TypeRef {
    Path(Path),
    RawPtr(Box<TypeRef>, Mutability),
    Reference(Box<TypeRef>, Option<LifetimeRef>, Mutability),
-    Array(Box<TypeRef> /*, Expr*/),
+    // FIXME: for full const generics, the latter element (length) here is going to have to be an
+    // expression that is further lowered later in hir_ty.
+    Array(Box<TypeRef>, ConstScalar),
    Slice(Box<TypeRef>),
    /// A fn pointer. Last element of the vector is the return type.
    Fn(Vec<TypeRef>, bool /*varargs*/),
@@ -140,7 +143,16 @@ impl TypeRef {
                TypeRef::RawPtr(Box::new(inner_ty), mutability)
            }
            ast::Type::ArrayType(inner) => {
-                TypeRef::Array(Box::new(TypeRef::from_ast_opt(&ctx, inner.ty())))
+                // FIXME: This is a hack. We should probably reuse the machinery of
+                // `hir_def::body::lower` to lower this into an `Expr` and then evaluate it at the
+                // `hir_ty` level, which would allow knowing the type of:
+                // let v: [u8; 2 + 2] = [0u8; 4];
+                let len = inner
+                    .expr()
+                    .map(ConstScalar::usize_from_literal_expr)
+                    .unwrap_or(ConstScalar::Unknown);
+                TypeRef::Array(Box::new(TypeRef::from_ast_opt(&ctx, inner.ty())), len)
            }
            ast::Type::SliceType(inner) => {
                TypeRef::Slice(Box::new(TypeRef::from_ast_opt(&ctx, inner.ty())))
@@ -212,7 +224,7 @@ impl TypeRef {
                }
                TypeRef::RawPtr(type_ref, _)
                | TypeRef::Reference(type_ref, ..)
-                | TypeRef::Array(type_ref)
+                | TypeRef::Array(type_ref, _)
                | TypeRef::Slice(type_ref) => go(&type_ref, f),
                TypeRef::ImplTrait(bounds) | TypeRef::DynTrait(bounds) => {
                    for bound in bounds {
@@ -298,3 +310,58 @@ impl TypeBound {
        }
    }
 }
+/// A concrete constant value
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ConstScalar {
+    // for now, we only support the trivial case of constant evaluating the length of an array
+    // Note that this is u64 because the target usize may be bigger than our usize
+    Usize(u64),
+    /// Case of an unknown value that rustc might know but we don't
+    // FIXME: this is a hack to get around chalk not being able to represent unevaluatable
+    // constants
+    // https://github.com/rust-analyzer/rust-analyzer/pull/8813#issuecomment-840679177
+    // https://rust-lang.zulipchat.com/#narrow/stream/144729-wg-traits/topic/Handling.20non.20evaluatable.20constants'.20equality/near/238386348
+    Unknown,
+}
+impl std::fmt::Display for ConstScalar {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            ConstScalar::Usize(us) => write!(fmt, "{}", us),
+            ConstScalar::Unknown => write!(fmt, "_"),
+        }
+    }
+}
+impl ConstScalar {
+    /// Gets a target usize out of the ConstScalar
+    pub fn as_usize(&self) -> Option<u64> {
+        match self {
+            &ConstScalar::Usize(us) => Some(us),
+            _ => None,
+        }
+    }
+    // FIXME: as per the comments on `TypeRef::Array`, this evaluation should not happen at this
+    // parse stage.
+    fn usize_from_literal_expr(expr: ast::Expr) -> ConstScalar {
+        match expr {
+            ast::Expr::Literal(lit) => {
+                let lkind = lit.kind();
+                match lkind {
+                    ast::LiteralKind::IntNumber(num)
+                        if num.suffix() == None || num.suffix() == Some("usize") =>
+                    {
+                        num.value().and_then(|v| v.try_into().ok())
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+        .map(ConstScalar::Usize)
+        .unwrap_or(ConstScalar::Unknown)
+    }
+}
diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index 537c03028..b6a6d602f 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -269,7 +269,7 @@ mod tests {
    use expect_test::{expect, Expect};
    use name::AsName;
-    use crate::{test_db::TestDB, AstId, AttrId, MacroCallId, MacroCallKind, MacroCallLoc};
+    use crate::{test_db::TestDB, AstId, MacroCallId, MacroCallKind, MacroCallLoc};
    use super::*;
@@ -320,7 +320,7 @@ $0
            kind: MacroCallKind::Derive {
                ast_id,
                derive_name: name.to_string(),
-                derive_attr: AttrId(0),
+                derive_attr_index: 0,
            },
        };
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 179de61f9..280c25f11 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -118,6 +118,7 @@ register_builtin! {
    EAGER:
    (compile_error, CompileError) => compile_error_expand,
    (concat, Concat) => concat_expand,
+    (concat_idents, ConcatIdents) => concat_idents_expand,
    (include, Include) => include_expand,
    (include_bytes, IncludeBytes) => include_bytes_expand,
    (include_str, IncludeStr) => include_str_expand,
@@ -373,6 +374,28 @@ fn concat_expand(
    ExpandResult { value: Some(ExpandedEager::new(quote!(#text), FragmentKind::Expr)), err }
 }
+fn concat_idents_expand(
+    _db: &dyn AstDatabase,
+    _arg_id: EagerMacroId,
+    tt: &tt::Subtree,
+) -> ExpandResult<Option<ExpandedEager>> {
+    let mut err = None;
+    let mut ident = String::new();
+    for (i, t) in tt.token_trees.iter().enumerate() {
+        match t {
+            tt::TokenTree::Leaf(tt::Leaf::Ident(id)) => {
+                ident.push_str(id.text.as_str());
+            }
+            tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if i % 2 == 1 && punct.char == ',' => (),
+            _ => {
+                err.get_or_insert(mbe::ExpandError::UnexpectedToken);
+            }
+        }
+    }
+    let ident = tt::Ident { text: ident.into(), id: tt::TokenId::unspecified() };
+    ExpandResult { value: Some(ExpandedEager::new(quote!(#ident), FragmentKind::Expr)), err }
+}
 fn relative_file(
    db: &dyn AstDatabase,
    call_id: MacroCallId,
@@ -578,6 +601,7 @@ mod tests {
                    krate,
                    kind: MacroCallKind::FnLike {
                        ast_id: AstId::new(file_id.into(), ast_id_map.ast_id(&macro_call)),
+                        fragment: FragmentKind::Expr,
                    },
                };
@@ -788,9 +812,21 @@ mod tests {
            r##"
            #[rustc_builtin_macro]
            macro_rules! concat {}
-            concat!("foo", "r", 0, r#"bar"#, false);
+            concat!("foo", "r", 0, r#"bar"#, "\n", false);
+            "##,
+            expect![[r#""foor0bar\nfalse""#]],
+        );
+    }
+    #[test]
+    fn test_concat_idents_expand() {
+        check_expansion(
+            r##"
+            #[rustc_builtin_macro]
+            macro_rules! concat_idents {}
+            concat_idents!(foo, bar);
            "##,
-            expect![[r#""foor0barfalse""#]],
+            expect![[r#"foobar"#]],
        );
    }
 }
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index d61f4b31a..c43d382ad 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -8,15 +8,13 @@ use parser::FragmentKind;
 use syntax::{
    algo::diff,
    ast::{self, NameOwner},
-    AstNode, GreenNode, Parse,
+    AstNode, GreenNode, Parse, SyntaxNode, SyntaxToken,
-    SyntaxKind::*,
-    SyntaxNode, SyntaxToken,
 };
 use crate::{
-    ast_id_map::AstIdMap, hygiene::HygieneFrame, BuiltinDeriveExpander, BuiltinFnLikeExpander,
+    ast_id_map::AstIdMap, hygiene::HygieneFrame, input::process_macro_input, BuiltinDeriveExpander,
-    EagerCallLoc, EagerMacroId, HirFileId, HirFileIdRepr, LazyMacroId, MacroCallId, MacroCallLoc,
+    BuiltinFnLikeExpander, EagerCallLoc, EagerMacroId, HirFileId, HirFileIdRepr, LazyMacroId,
-    MacroDefId, MacroDefKind, MacroFile, ProcMacroExpander,
+    MacroCallId, MacroCallLoc, MacroDefId, MacroDefKind, MacroFile, ProcMacroExpander,
 };
 /// Total limit on the number of tokens produced by any macro invocation.
@@ -160,7 +158,7 @@ pub fn expand_hypothetical(
    let hypothetical_expansion = macro_def.expand(db, lazy_id, &tt);
-    let fragment_kind = to_fragment_kind(db, actual_macro_call);
+    let fragment_kind = macro_fragment_kind(db, actual_macro_call);
    let (node, tmap_2) =
        mbe::token_tree_to_syntax_node(&hypothetical_expansion.value, fragment_kind).ok()?;
@@ -226,7 +224,7 @@ fn parse_macro_expansion(
        None => return ExpandResult { value: None, err: result.err },
    };
-    let fragment_kind = to_fragment_kind(db, macro_file.macro_call_id);
+    let fragment_kind = macro_fragment_kind(db, macro_file.macro_call_id);
    log::debug!("expanded = {}", tt.as_debug_string());
    log::debug!("kind = {:?}", fragment_kind);
@@ -269,7 +267,16 @@ fn parse_macro_expansion(
 fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
    let arg = db.macro_arg_text(id)?;
-    let (tt, tmap) = mbe::syntax_node_to_token_tree(&SyntaxNode::new_root(arg));
+    let (mut tt, tmap) = mbe::syntax_node_to_token_tree(&SyntaxNode::new_root(arg));
+    if let MacroCallId::LazyMacro(id) = id {
+        let loc: MacroCallLoc = db.lookup_intern_macro(id);
+        if loc.def.is_proc_macro() {
+            // proc macros expect their inputs without parentheses, MBEs expect it with them included
+            tt.delimiter = None;
+        }
+    }
    Some(Arc::new((tt, tmap)))
 }
@@ -283,6 +290,7 @@ fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
    };
    let loc = db.lookup_intern_macro(id);
    let arg = loc.kind.arg(db)?;
+    let arg = process_macro_input(db, arg, id);
    Some(arg.green().into())
 }
@@ -427,62 +435,15 @@ fn hygiene_frame(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<HygieneFrame>
    Arc::new(HygieneFrame::new(db, file_id))
 }
-/// Given a `MacroCallId`, return what `FragmentKind` it belongs to.
+fn macro_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
-/// FIXME: Not completed
+    match id {
-fn to_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
+        MacroCallId::LazyMacro(id) => {
-    let lazy_id = match id {
+            let loc: MacroCallLoc = db.lookup_intern_macro(id);
-        MacroCallId::LazyMacro(id) => id,
+            loc.kind.fragment_kind()
-        MacroCallId::EagerMacro(id) => {
-            return db.lookup_intern_eager_expansion(id).fragment;
-        }
-    };
-    let syn = db.lookup_intern_macro(lazy_id).kind.node(db).value;
-    let parent = match syn.parent() {
-        Some(it) => it,
-        None => return FragmentKind::Statements,
-    };
-    match parent.kind() {
-        MACRO_ITEMS | SOURCE_FILE => FragmentKind::Items,
-        MACRO_STMTS => FragmentKind::Statements,
-        MACRO_PAT => FragmentKind::Pattern,
-        MACRO_TYPE => FragmentKind::Type,
-        ITEM_LIST => FragmentKind::Items,
-        LET_STMT => {
-            // FIXME: Handle LHS Pattern
-            FragmentKind::Expr
        }
-        EXPR_STMT => FragmentKind::Statements,
+        MacroCallId::EagerMacro(id) => {
-        BLOCK_EXPR => FragmentKind::Statements,
+            let loc: EagerCallLoc = db.lookup_intern_eager_expansion(id);
-        ARG_LIST => FragmentKind::Expr,
+            loc.fragment
-        TRY_EXPR => FragmentKind::Expr,
-        TUPLE_EXPR => FragmentKind::Expr,
-        PAREN_EXPR => FragmentKind::Expr,
-        ARRAY_EXPR => FragmentKind::Expr,
-        FOR_EXPR => FragmentKind::Expr,
-        PATH_EXPR => FragmentKind::Expr,
-        CLOSURE_EXPR => FragmentKind::Expr,
-        CONDITION => FragmentKind::Expr,
-        BREAK_EXPR => FragmentKind::Expr,
-        RETURN_EXPR => FragmentKind::Expr,
-        MATCH_EXPR => FragmentKind::Expr,
-        MATCH_ARM => FragmentKind::Expr,
-        MATCH_GUARD => FragmentKind::Expr,
-        RECORD_EXPR_FIELD => FragmentKind::Expr,
-        CALL_EXPR => FragmentKind::Expr,
-        INDEX_EXPR => FragmentKind::Expr,
-        METHOD_CALL_EXPR => FragmentKind::Expr,
-        FIELD_EXPR => FragmentKind::Expr,
-        AWAIT_EXPR => FragmentKind::Expr,
-        CAST_EXPR => FragmentKind::Expr,
-        REF_EXPR => FragmentKind::Expr,
-        PREFIX_EXPR => FragmentKind::Expr,
-        RANGE_EXPR => FragmentKind::Expr,
-        BIN_EXPR => FragmentKind::Expr,
-        _ => {
-            // Unknown , Just guess it is `Items`
-            FragmentKind::Items
        }
    }
 }
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index f12132f84..85491fe8b 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -175,8 +175,13 @@ fn lazy_expand(
 ) -> ExpandResult<Option<InFile<SyntaxNode>>> {
    let ast_id = db.ast_id_map(macro_call.file_id).ast_id(&macro_call.value);
+    let fragment = crate::to_fragment_kind(&macro_call.value);
    let id: MacroCallId = def
-        .as_lazy_macro(db, krate, MacroCallKind::FnLike { ast_id: macro_call.with_value(ast_id) })
+        .as_lazy_macro(
+            db,
+            krate,
+            MacroCallKind::FnLike { ast_id: macro_call.with_value(ast_id), fragment },
+        )
        .into();
    let err = db.macro_expand_error(id);
diff --git a/crates/hir_expand/src/input.rs b/crates/hir_expand/src/input.rs
new file mode 100644
index 000000000..112216859
--- /dev/null
+++ b/crates/hir_expand/src/input.rs
@@ -0,0 +1,94 @@
+//! Macro input conditioning.
+use syntax::{
+    ast::{self, AttrsOwner},
+    AstNode, SyntaxNode,
+};
+use crate::{
+    db::AstDatabase,
+    name::{name, AsName},
+    LazyMacroId, MacroCallKind, MacroCallLoc,
+};
+pub(crate) fn process_macro_input(
+    db: &dyn AstDatabase,
+    node: SyntaxNode,
+    id: LazyMacroId,
+) -> SyntaxNode {
+    let loc: MacroCallLoc = db.lookup_intern_macro(id);
+    match loc.kind {
+        MacroCallKind::FnLike { .. } => node,
+        MacroCallKind::Derive { derive_attr_index, .. } => {
+            let item = match ast::Item::cast(node.clone()) {
+                Some(item) => item,
+                None => return node,
+            };
+            remove_derives_up_to(item, derive_attr_index as usize).syntax().clone()
+        }
+    }
+}
+/// Removes `#[derive]` attributes from `item`, up to `attr_index`.
+fn remove_derives_up_to(item: ast::Item, attr_index: usize) -> ast::Item {
+    let item = item.clone_for_update();
+    for attr in item.attrs().take(attr_index + 1) {
+        if let Some(name) =
+            attr.path().and_then(|path| path.as_single_segment()).and_then(|seg| seg.name_ref())
+        {
+            if name.as_name() == name![derive] {
+                attr.syntax().detach();
+            }
+        }
+    }
+    item
+}
+#[cfg(test)]
+mod tests {
+    use base_db::fixture::WithFixture;
+    use base_db::SourceDatabase;
+    use expect_test::{expect, Expect};
+    use crate::test_db::TestDB;
+    use super::*;
+    fn test_remove_derives_up_to(attr: usize, ra_fixture: &str, expect: Expect) {
+        let (db, file_id) = TestDB::with_single_file(&ra_fixture);
+        let parsed = db.parse(file_id);
+        let mut items: Vec<_> =
+            parsed.syntax_node().descendants().filter_map(ast::Item::cast).collect();
+        assert_eq!(items.len(), 1);
+        let item = remove_derives_up_to(items.pop().unwrap(), attr);
+        expect.assert_eq(&item.to_string());
+    }
+    #[test]
+    fn remove_derive() {
+        test_remove_derives_up_to(
+            2,
+            r#"
+#[allow(unused)]
+#[derive(Copy)]
+#[derive(Hello)]
+#[derive(Clone)]
+struct A {
+    bar: u32
+}
+        "#,
+            expect![[r#"
+#[allow(unused)]
+#[derive(Clone)]
+struct A {
+    bar: u32
+}"#]],
+        );
+    }
+}
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 0402640de..88cb16ca4 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -14,9 +14,12 @@ pub mod builtin_macro;
 pub mod proc_macro;
 pub mod quote;
 pub mod eager;
+mod input;
 use either::Either;
 pub use mbe::{ExpandError, ExpandResult};
+pub use parser::FragmentKind;
 use std::hash::Hash;
 use std::sync::Arc;
@@ -269,6 +272,10 @@ impl MacroDefId {
        };
        Either::Left(*id)
    }
+    pub fn is_proc_macro(&self) -> bool {
+        matches!(self.kind, MacroDefKind::ProcMacro(..))
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -290,13 +297,21 @@ pub struct MacroCallLoc {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum MacroCallKind {
-    FnLike { ast_id: AstId<ast::MacroCall> },
+    FnLike {
-    Derive { ast_id: AstId<ast::Item>, derive_name: String, derive_attr: AttrId },
+        ast_id: AstId<ast::MacroCall>,
+        fragment: FragmentKind,
+    },
+    Derive {
+        ast_id: AstId<ast::Item>,
+        derive_name: String,
+        /// Syntactical index of the invoking `#[derive]` attribute.
+        ///
+        /// Outer attributes are counted first, then inner attributes. This does not support
+        /// out-of-line modules, which may have attributes spread across 2 files!
+        derive_attr_index: u32,
+    },
 }
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct AttrId(pub u32);
 impl MacroCallKind {
    fn file_id(&self) -> HirFileId {
        match self {
@@ -324,6 +339,13 @@ impl MacroCallKind {
            MacroCallKind::Derive { ast_id, .. } => Some(ast_id.to_node(db).syntax().clone()),
        }
    }
+    fn fragment_kind(&self) -> FragmentKind {
+        match self {
+            MacroCallKind::FnLike { fragment, .. } => *fragment,
+            MacroCallKind::Derive { .. } => FragmentKind::Items,
+        }
+    }
 }
 impl MacroCallId {
@@ -357,7 +379,6 @@ pub struct ExpansionInfo {
 }
 pub use mbe::Origin;
-use parser::FragmentKind;
 impl ExpansionInfo {
    pub fn call_node(&self) -> Option<InFile<SyntaxNode>> {
@@ -562,3 +583,59 @@ impl<N: AstNode> InFile<N> {
        self.with_value(self.value.syntax())
    }
 }
+/// Given a `MacroCallId`, return what `FragmentKind` it belongs to.
+/// FIXME: Not completed
+pub fn to_fragment_kind(call: &ast::MacroCall) -> FragmentKind {
+    use syntax::SyntaxKind::*;
+    let syn = call.syntax();
+    let parent = match syn.parent() {
+        Some(it) => it,
+        None => return FragmentKind::Statements,
+    };
+    match parent.kind() {
+        MACRO_ITEMS | SOURCE_FILE => FragmentKind::Items,
+        MACRO_STMTS => FragmentKind::Statements,
+        MACRO_PAT => FragmentKind::Pattern,
+        MACRO_TYPE => FragmentKind::Type,
+        ITEM_LIST => FragmentKind::Items,
+        LET_STMT => {
+            // FIXME: Handle LHS Pattern
+            FragmentKind::Expr
+        }
+        EXPR_STMT => FragmentKind::Statements,
+        BLOCK_EXPR => FragmentKind::Statements,
+        ARG_LIST => FragmentKind::Expr,
+        TRY_EXPR => FragmentKind::Expr,
+        TUPLE_EXPR => FragmentKind::Expr,
+        PAREN_EXPR => FragmentKind::Expr,
+        ARRAY_EXPR => FragmentKind::Expr,
+        FOR_EXPR => FragmentKind::Expr,
+        PATH_EXPR => FragmentKind::Expr,
+        CLOSURE_EXPR => FragmentKind::Expr,
+        CONDITION => FragmentKind::Expr,
+        BREAK_EXPR => FragmentKind::Expr,
+        RETURN_EXPR => FragmentKind::Expr,
+        MATCH_EXPR => FragmentKind::Expr,
+        MATCH_ARM => FragmentKind::Expr,
+        MATCH_GUARD => FragmentKind::Expr,
+        RECORD_EXPR_FIELD => FragmentKind::Expr,
+        CALL_EXPR => FragmentKind::Expr,
+        INDEX_EXPR => FragmentKind::Expr,
+        METHOD_CALL_EXPR => FragmentKind::Expr,
+        FIELD_EXPR => FragmentKind::Expr,
+        AWAIT_EXPR => FragmentKind::Expr,
+        CAST_EXPR => FragmentKind::Expr,
+        REF_EXPR => FragmentKind::Expr,
+        PREFIX_EXPR => FragmentKind::Expr,
+        RANGE_EXPR => FragmentKind::Expr,
+        BIN_EXPR => FragmentKind::Expr,
+        _ => {
+            // Unknown , Just guess it is `Items`
+            FragmentKind::Items
+        }
+    }
+}
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index bcfd3e524..5a5dc9afd 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -212,6 +212,7 @@ pub mod known {
        std_panic,
        stringify,
        concat,
+        concat_idents,
        include,
        include_bytes,
        include_str,
diff --git a/crates/hir_expand/src/proc_macro.rs b/crates/hir_expand/src/proc_macro.rs
index 75e950816..d5643393a 100644
--- a/crates/hir_expand/src/proc_macro.rs
+++ b/crates/hir_expand/src/proc_macro.rs
@@ -2,7 +2,6 @@
 use crate::db::AstDatabase;
 use base_db::{CrateId, ProcMacroId};
-use tt::buffer::{Cursor, TokenBuffer};
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 pub struct ProcMacroExpander {
@@ -44,9 +43,6 @@ impl ProcMacroExpander {
                    .clone()
                    .ok_or_else(|| err!("No derive macro found."))?;
-                let tt = remove_derive_attrs(tt)
-                    .ok_or_else(|| err!("Fail to remove derive for custom derive"))?;
                // Proc macros have access to the environment variables of the invoking crate.
                let env = &krate_graph[calling_crate].env;
@@ -56,101 +52,3 @@ impl ProcMacroExpander {
        }
    }
 }
-fn eat_punct(cursor: &mut Cursor, c: char) -> bool {
-    if let Some(tt::buffer::TokenTreeRef::Leaf(tt::Leaf::Punct(punct), _)) = cursor.token_tree() {
-        if punct.char == c {
-            *cursor = cursor.bump();
-            return true;
-        }
-    }
-    false
-}
-fn eat_subtree(cursor: &mut Cursor, kind: tt::DelimiterKind) -> bool {
-    if let Some(tt::buffer::TokenTreeRef::Subtree(subtree, _)) = cursor.token_tree() {
-        if Some(kind) == subtree.delimiter_kind() {
-            *cursor = cursor.bump_subtree();
-            return true;
-        }
-    }
-    false
-}
-fn eat_ident(cursor: &mut Cursor, t: &str) -> bool {
-    if let Some(tt::buffer::TokenTreeRef::Leaf(tt::Leaf::Ident(ident), _)) = cursor.token_tree() {
-        if t == ident.text.as_str() {
-            *cursor = cursor.bump();
-            return true;
-        }
-    }
-    false
-}
-fn remove_derive_attrs(tt: &tt::Subtree) -> Option<tt::Subtree> {
-    let buffer = TokenBuffer::from_tokens(&tt.token_trees);
-    let mut p = buffer.begin();
-    let mut result = tt::Subtree::default();
-    while !p.eof() {
-        let curr = p;
-        if eat_punct(&mut p, '#') {
-            eat_punct(&mut p, '!');
-            let parent = p;
-            if eat_subtree(&mut p, tt::DelimiterKind::Bracket) {
-                if eat_ident(&mut p, "derive") {
-                    p = parent.bump();
-                    continue;
-                }
-            }
-        }
-        result.token_trees.push(curr.token_tree()?.cloned());
-        p = curr.bump();
-    }
-    Some(result)
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use test_utils::assert_eq_text;
-    #[test]
-    fn test_remove_derive_attrs() {
-        let tt = mbe::parse_to_token_tree(
-            r#"
-    #[allow(unused)]
-    #[derive(Copy)]
-    #[derive(Hello)]
-    struct A {
-        bar: u32
-    }
-"#,
-        )
-        .unwrap()
-        .0;
-        let result = format!("{:#?}", remove_derive_attrs(&tt).unwrap());
-        assert_eq_text!(
-            r#"
-SUBTREE $
-  PUNCH   # [alone] 0
-  SUBTREE [] 1
-    IDENT   allow 2
-    SUBTREE () 3
-      IDENT   unused 4
-  IDENT   struct 15
-  IDENT   A 16
-  SUBTREE {} 17
-    IDENT   bar 18
-    PUNCH   : [alone] 19
-    IDENT   u32 20
-"#
-            .trim(),
-            &result
-        );
-    }
-}
diff --git a/crates/hir_expand/src/quote.rs b/crates/hir_expand/src/quote.rs
index c82487ef0..230a59964 100644
--- a/crates/hir_expand/src/quote.rs
+++ b/crates/hir_expand/src/quote.rs
@@ -196,8 +196,8 @@ impl_to_to_tokentrees! {
    tt::Literal => self { self };
    tt::Ident => self { self };
    tt::Punct => self { self };
-    &str => self { tt::Literal{text: format!("{:?}", self.escape_default().to_string()).into(), id: tt::TokenId::unspecified()}};
+    &str => self { tt::Literal{text: format!("\"{}\"", self.escape_debug()).into(), id: tt::TokenId::unspecified()}};
-    String => self { tt::Literal{text: format!("{:?}", self.escape_default().to_string()).into(), id: tt::TokenId::unspecified()}}
+    String => self { tt::Literal{text: format!("\"{}\"", self.escape_debug()).into(), id: tt::TokenId::unspecified()}}
 }
 #[cfg(test)]
diff --git a/crates/hir_ty/src/chalk_ext.rs b/crates/hir_ty/src/chalk_ext.rs
index 8c4542956..5232a7d80 100644
--- a/crates/hir_ty/src/chalk_ext.rs
+++ b/crates/hir_ty/src/chalk_ext.rs
@@ -1,8 +1,10 @@
 //! Various extensions traits for Chalk types.
-use chalk_ir::Mutability;
+use chalk_ir::{FloatTy, IntTy, Mutability, Scalar, UintTy};
 use hir_def::{
-    type_ref::Rawness, AssocContainerId, FunctionId, GenericDefId, HasModule, Lookup, TraitId,
+    builtin_type::{BuiltinFloat, BuiltinInt, BuiltinType, BuiltinUint},
+    type_ref::Rawness,
+    AssocContainerId, FunctionId, GenericDefId, HasModule, Lookup, TraitId,
 };
 use crate::{
@@ -18,6 +20,7 @@ pub trait TyExt {
    fn is_unknown(&self) -> bool;
    fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)>;
+    fn as_builtin(&self) -> Option<BuiltinType>;
    fn as_tuple(&self) -> Option<&Substitution>;
    fn as_fn_def(&self, db: &dyn HirDatabase) -> Option<FunctionId>;
    fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)>;
@@ -59,6 +62,35 @@ impl TyExt for Ty {
        }
    }
+    fn as_builtin(&self) -> Option<BuiltinType> {
+        match self.kind(&Interner) {
+            TyKind::Str => Some(BuiltinType::Str),
+            TyKind::Scalar(Scalar::Bool) => Some(BuiltinType::Bool),
+            TyKind::Scalar(Scalar::Char) => Some(BuiltinType::Char),
+            TyKind::Scalar(Scalar::Float(fty)) => Some(BuiltinType::Float(match fty {
+                FloatTy::F64 => BuiltinFloat::F64,
+                FloatTy::F32 => BuiltinFloat::F32,
+            })),
+            TyKind::Scalar(Scalar::Int(ity)) => Some(BuiltinType::Int(match ity {
+                IntTy::Isize => BuiltinInt::Isize,
+                IntTy::I8 => BuiltinInt::I8,
+                IntTy::I16 => BuiltinInt::I16,
+                IntTy::I32 => BuiltinInt::I32,
+                IntTy::I64 => BuiltinInt::I64,
+                IntTy::I128 => BuiltinInt::I128,
+            })),
+            TyKind::Scalar(Scalar::Uint(ity)) => Some(BuiltinType::Uint(match ity {
+                UintTy::Usize => BuiltinUint::Usize,
+                UintTy::U8 => BuiltinUint::U8,
+                UintTy::U16 => BuiltinUint::U16,
+                UintTy::U32 => BuiltinUint::U32,
+                UintTy::U64 => BuiltinUint::U64,
+                UintTy::U128 => BuiltinUint::U128,
+            })),
+            _ => None,
+        }
+    }
    fn as_tuple(&self) -> Option<&Substitution> {
        match self.kind(&Interner) {
            TyKind::Tuple(_, substs) => Some(substs),
diff --git a/crates/hir_ty/src/consteval.rs b/crates/hir_ty/src/consteval.rs
new file mode 100644
index 000000000..e3ceb3d62
--- /dev/null
+++ b/crates/hir_ty/src/consteval.rs
@@ -0,0 +1,56 @@
+//! Constant evaluation details
+use std::convert::TryInto;
+use hir_def::{
+    builtin_type::BuiltinUint,
+    expr::{Expr, Literal},
+    type_ref::ConstScalar,
+};
+use crate::{Const, ConstData, ConstValue, Interner, TyKind};
+/// Extension trait for [`Const`]
+pub trait ConstExt {
+    /// Is a [`Const`] unknown?
+    fn is_unknown(&self) -> bool;
+}
+impl ConstExt for Const {
+    fn is_unknown(&self) -> bool {
+        match self.data(&Interner).value {
+            // interned Unknown
+            chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
+                interned: ConstScalar::Unknown,
+            }) => true,
+            // interned concrete anything else
+            chalk_ir::ConstValue::Concrete(..) => false,
+            _ => {
+                log::error!("is_unknown was called on a non-concrete constant value! {:?}", self);
+                true
+            }
+        }
+    }
+}
+// FIXME: support more than just evaluating literals
+pub fn eval_usize(expr: &Expr) -> Option<u64> {
+    match expr {
+        Expr::Literal(Literal::Uint(v, None))
+        | Expr::Literal(Literal::Uint(v, Some(BuiltinUint::Usize))) => (*v).try_into().ok(),
+        _ => None,
+    }
+}
+/// Interns a possibly-unknown target usize
+pub fn usize_const(value: Option<u64>) -> Const {
+    ConstData {
+        ty: TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::Usize)).intern(&Interner),
+        value: ConstValue::Concrete(chalk_ir::ConcreteConst {
+            interned: value.map(|value| ConstScalar::Usize(value)).unwrap_or(ConstScalar::Unknown),
+        }),
+    }
+    .intern(&Interner)
+}
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index 79602c3dd..47709c1e8 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -83,7 +83,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        if let Expr::Block { statements, tail, .. } = body_expr {
            if let Some(t) = tail {
                self.validate_results_in_tail_expr(body.body_expr, *t, db);
-            } else if let Some(Statement::Expr(id)) = statements.last() {
+            } else if let Some(Statement::Expr { expr: id, .. }) = statements.last() {
                self.validate_missing_tail_expr(body.body_expr, *id, db);
            }
        }
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index e9762622f..6ee0529c6 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -1119,6 +1119,7 @@ fn main() {
        (true, false, true) => (),
        (true) => (),
    }
+    match (true, false) { (true,) => {} }
    match (0) { () => () }
    match Unresolved::Bar { Unresolved::Baz => () }
 }
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 1f6edf7a2..7bbd1a1f7 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -308,7 +308,7 @@ impl HirDisplay for Const {
                let param_data = &generics.params.consts[id.local_id];
                write!(f, "{}", param_data.name)
            }
-            ConstValue::Concrete(_) => write!(f, "_"),
+            ConstValue::Concrete(c) => write!(f, "{}", c.interned),
        }
    }
 }
@@ -962,11 +962,10 @@ impl HirDisplay for TypeRef {
                write!(f, "{}", mutability)?;
                inner.hir_fmt(f)?;
            }
-            TypeRef::Array(inner) => {
+            TypeRef::Array(inner, len) => {
                write!(f, "[")?;
                inner.hir_fmt(f)?;
-                // FIXME: Array length?
+                write!(f, "; {}]", len)?;
-                write!(f, "; _]")?;
            }
            TypeRef::Slice(inner) => {
                write!(f, "[")?;
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 50497eecb..b6b5a1b75 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -15,7 +15,7 @@ use stdx::always;
 use syntax::ast::RangeOp;
 use crate::{
-    autoderef, dummy_usize_const,
+    autoderef, consteval,
    lower::lower_to_chalk_mutability,
    mapping::from_chalk,
    method_resolution, op,
@@ -717,11 +717,12 @@ impl<'a> InferenceContext<'a> {
                    _ => self.table.new_type_var(),
                };
-                match array {
+                let len = match array {
                    Array::ElementList(items) => {
                        for expr in items.iter() {
                            self.infer_expr_coerce(*expr, &Expectation::has_type(elem_ty.clone()));
                        }
+                        Some(items.len() as u64)
                    }
                    Array::Repeat { initializer, repeat } => {
                        self.infer_expr_coerce(
@@ -734,10 +735,13 @@ impl<'a> InferenceContext<'a> {
                                TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner),
                            ),
                        );
+                        let repeat_expr = &self.body.exprs[*repeat];
+                        consteval::eval_usize(repeat_expr)
                    }
-                }
+                };
-                TyKind::Array(elem_ty, dummy_usize_const()).intern(&Interner)
+                TyKind::Array(elem_ty, consteval::usize_const(len)).intern(&Interner)
            }
            Expr::Literal(lit) => match lit {
                Literal::Bool(..) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
@@ -745,10 +749,12 @@ impl<'a> InferenceContext<'a> {
                    TyKind::Ref(Mutability::Not, static_lifetime(), TyKind::Str.intern(&Interner))
                        .intern(&Interner)
                }
-                Literal::ByteString(..) => {
+                Literal::ByteString(bs) => {
                    let byte_type = TyKind::Scalar(Scalar::Uint(UintTy::U8)).intern(&Interner);
-                    let array_type =
-                        TyKind::Array(byte_type, dummy_usize_const()).intern(&Interner);
+                    let len = consteval::usize_const(Some(bs.len() as u64));
+                    let array_type = TyKind::Array(byte_type, len).intern(&Interner);
                    TyKind::Ref(Mutability::Not, static_lifetime(), array_type).intern(&Interner)
                }
                Literal::Char(..) => TyKind::Scalar(Scalar::Char).intern(&Interner),
@@ -809,7 +815,7 @@ impl<'a> InferenceContext<'a> {
                    let ty = self.resolve_ty_as_possible(ty);
                    self.infer_pat(*pat, &ty, BindingMode::default());
                }
-                Statement::Expr(expr) => {
+                Statement::Expr { expr, .. } => {
                    self.infer_expr(*expr, &Expectation::none());
                }
            }
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index aea354cde..60b94a642 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -126,11 +126,12 @@ impl<'a> InferenceContext<'a> {
                    _ => &[],
                };
-                let (pre, post) = match ellipsis {
+                let ((pre, post), n_uncovered_patterns) = match ellipsis {
-                    Some(idx) => args.split_at(idx),
+                    Some(idx) => {
-                    None => (&args[..], &[][..]),
+                        (args.split_at(idx), expectations.len().saturating_sub(args.len()))
+                    }
+                    None => ((&args[..], &[][..]), 0),
                };
-                let n_uncovered_patterns = expectations.len().saturating_sub(args.len());
                let err_ty = self.err_ty();
                let mut expectations_iter =
                    expectations.iter().map(|a| a.assert_ty_ref(&Interner)).chain(repeat(&err_ty));
diff --git a/crates/hir_ty/src/interner.rs b/crates/hir_ty/src/interner.rs
index a1656115d..7b4119747 100644
--- a/crates/hir_ty/src/interner.rs
+++ b/crates/hir_ty/src/interner.rs
@@ -6,6 +6,7 @@ use base_db::salsa::InternId;
 use chalk_ir::{Goal, GoalData};
 use hir_def::{
    intern::{impl_internable, InternStorage, Internable, Interned},
+    type_ref::ConstScalar,
    TypeAliasId,
 };
 use smallvec::SmallVec;
@@ -31,6 +32,7 @@ impl_internable!(
    InternedWrapper<chalk_ir::TyData<Interner>>,
    InternedWrapper<chalk_ir::LifetimeData<Interner>>,
    InternedWrapper<chalk_ir::ConstData<Interner>>,
+    InternedWrapper<ConstScalar>,
    InternedWrapper<Vec<chalk_ir::CanonicalVarKind<Interner>>>,
    InternedWrapper<Vec<chalk_ir::ProgramClause<Interner>>>,
    InternedWrapper<Vec<chalk_ir::QuantifiedWhereClause<Interner>>>,
@@ -41,7 +43,7 @@ impl chalk_ir::interner::Interner for Interner {
    type InternedType = Interned<InternedWrapper<chalk_ir::TyData<Interner>>>;
    type InternedLifetime = Interned<InternedWrapper<chalk_ir::LifetimeData<Self>>>;
    type InternedConst = Interned<InternedWrapper<chalk_ir::ConstData<Self>>>;
-    type InternedConcreteConst = ();
+    type InternedConcreteConst = ConstScalar;
    type InternedGenericArg = chalk_ir::GenericArgData<Self>;
    type InternedGoal = Arc<GoalData<Self>>;
    type InternedGoals = Vec<Goal<Self>>;
@@ -245,10 +247,15 @@ impl chalk_ir::interner::Interner for Interner {
    fn const_eq(
        &self,
        _ty: &Self::InternedType,
-        _c1: &Self::InternedConcreteConst,
+        c1: &Self::InternedConcreteConst,
-        _c2: &Self::InternedConcreteConst,
+        c2: &Self::InternedConcreteConst,
    ) -> bool {
-        true
+        match (c1, c2) {
+            (&ConstScalar::Usize(a), &ConstScalar::Usize(b)) => a == b,
+            // we were previously assuming this to be true, I'm not whether true or false on
+            // unknown values is safer.
+            (_, _) => true,
+        }
    }
    fn intern_generic_arg(
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 0505fa4ae..15b61bedc 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -10,6 +10,7 @@ mod autoderef;
 mod builder;
 mod chalk_db;
 mod chalk_ext;
+pub mod consteval;
 mod infer;
 mod interner;
 mod lower;
@@ -37,7 +38,11 @@ use chalk_ir::{
    interner::HasInterner,
    UintTy,
 };
-use hir_def::{expr::ExprId, type_ref::Rawness, TypeParamId};
+use hir_def::{
+    expr::ExprId,
+    type_ref::{ConstScalar, Rawness},
+    TypeParamId,
+};
 use crate::{db::HirDatabase, display::HirDisplay, utils::generics};
@@ -250,7 +255,9 @@ pub fn dummy_usize_const() -> Const {
    let usize_ty = chalk_ir::TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner);
    chalk_ir::ConstData {
        ty: usize_ty,
-        value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { interned: () }),
+        value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
+            interned: ConstScalar::Unknown,
+        }),
    }
    .intern(&Interner)
 }
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index c99dd8d0a..bd8bb6028 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -29,8 +29,8 @@ use stdx::impl_from;
 use syntax::ast;
 use crate::{
+    consteval,
    db::HirDatabase,
-    dummy_usize_const,
    mapping::ToChalk,
    static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
    utils::{
@@ -172,9 +172,12 @@ impl<'a> TyLoweringContext<'a> {
                let inner_ty = self.lower_ty(inner);
                TyKind::Raw(lower_to_chalk_mutability(*mutability), inner_ty).intern(&Interner)
            }
-            TypeRef::Array(inner) => {
+            TypeRef::Array(inner, len) => {
                let inner_ty = self.lower_ty(inner);
-                TyKind::Array(inner_ty, dummy_usize_const()).intern(&Interner)
+                let const_len = consteval::usize_const(len.as_usize());
+                TyKind::Array(inner_ty, const_len).intern(&Interner)
            }
            TypeRef::Slice(inner) => {
                let inner_ty = self.lower_ty(inner);
diff --git a/crates/hir_ty/src/tests/coercion.rs b/crates/hir_ty/src/tests/coercion.rs
index 63d9d4e0b..190471069 100644
--- a/crates/hir_ty/src/tests/coercion.rs
+++ b/crates/hir_ty/src/tests/coercion.rs
@@ -55,7 +55,7 @@ fn coerce_places() {
        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
        "#,
-        expect![[r"
+        expect![[r#"
            30..31 '_': &[T]
            44..55 '{ loop {} }': T
            46..53 'loop {}': !
@@ -64,43 +64,43 @@ fn coerce_places() {
            81..92 '{ loop {} }': T
            83..90 'loop {}': !
            88..90 '{}': ()
-            121..132 '{ loop {} }': *mut [T; _]
+            121..132 '{ loop {} }': *mut [T; 2]
            123..130 'loop {}': !
            128..130 '{}': ()
            159..172 '{     gen() }': *mut [U]
-            165..168 'gen': fn gen<U>() -> *mut [U; _]
+            165..168 'gen': fn gen<U>() -> *mut [U; 2]
-            165..170 'gen()': *mut [U; _]
+            165..170 'gen()': *mut [U; 2]
            185..419 '{     ...rr); }': ()
-            195..198 'arr': &[u8; _]
+            195..198 'arr': &[u8; 1]
-            211..215 '&[1]': &[u8; _]
+            211..215 '&[1]': &[u8; 1]
-            212..215 '[1]': [u8; _]
+            212..215 '[1]': [u8; 1]
            213..214 '1': u8
            226..227 'a': &[u8]
-            236..239 'arr': &[u8; _]
+            236..239 'arr': &[u8; 1]
            249..250 'b': u8
            253..254 'f': fn f<u8>(&[u8]) -> u8
            253..259 'f(arr)': u8
-            255..258 'arr': &[u8; _]
+            255..258 'arr': &[u8; 1]
            269..270 'c': &[u8]
            279..286 '{ arr }': &[u8]
-            281..284 'arr': &[u8; _]
+            281..284 'arr': &[u8; 1]
            296..297 'd': u8
            300..301 'g': fn g<u8>(S<&[u8]>) -> u8
            300..315 'g(S { a: arr })': u8
            302..314 'S { a: arr }': S<&[u8]>
-            309..312 'arr': &[u8; _]
+            309..312 'arr': &[u8; 1]
-            325..326 'e': [&[u8]; _]
+            325..326 'e': [&[u8]; 1]
-            340..345 '[arr]': [&[u8]; _]
+            340..345 '[arr]': [&[u8]; 1]
-            341..344 'arr': &[u8; _]
+            341..344 'arr': &[u8; 1]
-            355..356 'f': [&[u8]; _]
+            355..356 'f': [&[u8]; 2]
-            370..378 '[arr; 2]': [&[u8]; _]
+            370..378 '[arr; 2]': [&[u8]; 2]
-            371..374 'arr': &[u8; _]
+            371..374 'arr': &[u8; 1]
            376..377 '2': usize
            388..389 'g': (&[u8], &[u8])
            406..416 '(arr, arr)': (&[u8], &[u8])
-            407..410 'arr': &[u8; _]
+            407..410 'arr': &[u8; 1]
-            412..415 'arr': &[u8; _]
+            412..415 'arr': &[u8; 1]
-        "]],
+        "#]],
    );
 }
@@ -113,17 +113,17 @@ fn infer_let_stmt_coerce() {
            let x: *const [isize] = &[1];
        }
        ",
-        expect![[r"
+        expect![[r#"
            10..75 '{     ...[1]; }': ()
            20..21 'x': &[isize]
-            34..38 '&[1]': &[isize; _]
+            34..38 '&[1]': &[isize; 1]
-            35..38 '[1]': [isize; _]
+            35..38 '[1]': [isize; 1]
            36..37 '1': isize
            48..49 'x': *const [isize]
-            68..72 '&[1]': &[isize; _]
+            68..72 '&[1]': &[isize; 1]
-            69..72 '[1]': [isize; _]
+            69..72 '[1]': [isize; 1]
            70..71 '1': isize
-        "]],
+        "#]],
    );
 }
@@ -159,7 +159,7 @@ fn infer_custom_coerce_unsized() {
        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
        "#,
-        expect![[r"
+        expect![[r#"
            257..258 'x': A<[T]>
            278..283 '{ x }': A<[T]>
            280..281 'x': A<[T]>
@@ -169,23 +169,23 @@ fn infer_custom_coerce_unsized() {
            333..334 'x': C<[T]>
            354..359 '{ x }': C<[T]>
            356..357 'x': C<[T]>
-            369..370 'a': A<[u8; _]>
+            369..370 'a': A<[u8; 2]>
-            384..385 'b': B<[u8; _]>
+            384..385 'b': B<[u8; 2]>
-            399..400 'c': C<[u8; _]>
+            399..400 'c': C<[u8; 2]>
            414..480 '{     ...(c); }': ()
            424..425 'd': A<[{unknown}]>
            428..432 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
            428..435 'foo1(a)': A<[{unknown}]>
-            433..434 'a': A<[u8; _]>
+            433..434 'a': A<[u8; 2]>
            445..446 'e': B<[u8]>
            449..453 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
            449..456 'foo2(b)': B<[u8]>
-            454..455 'b': B<[u8; _]>
+            454..455 'b': B<[u8; 2]>
            466..467 'f': C<[u8]>
            470..474 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
            470..477 'foo3(c)': C<[u8]>
-            475..476 'c': C<[u8; _]>
+            475..476 'c': C<[u8; 2]>
-        "]],
+        "#]],
    );
 }
@@ -208,7 +208,7 @@ fn infer_if_coerce() {
        #[lang = "unsize"]
        pub trait Unsize<T: ?Sized> {}
        "#,
-        expect![[r"
+        expect![[r#"
            10..11 'x': &[T]
            27..38 '{ loop {} }': &[T]
            29..36 'loop {}': !
@@ -220,14 +220,14 @@ fn infer_if_coerce() {
            71..96 '{     ...     }': &[i32]
            81..84 'foo': fn foo<i32>(&[i32]) -> &[i32]
            81..90 'foo(&[1])': &[i32]
-            85..89 '&[1]': &[i32; _]
+            85..89 '&[1]': &[i32; 1]
-            86..89 '[1]': [i32; _]
+            86..89 '[1]': [i32; 1]
            87..88 '1': i32
-            102..122 '{     ...     }': &[i32; _]
+            102..122 '{     ...     }': &[i32; 1]
-            112..116 '&[1]': &[i32; _]
+            112..116 '&[1]': &[i32; 1]
-            113..116 '[1]': [i32; _]
+            113..116 '[1]': [i32; 1]
            114..115 '1': i32
-        "]],
+        "#]],
    );
 }
@@ -254,7 +254,7 @@ fn infer_if_else_coerce() {
        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
        "#,
-        expect![[r"
+        expect![[r#"
            10..11 'x': &[T]
            27..38 '{ loop {} }': &[T]
            29..36 'loop {}': !
@@ -263,17 +263,17 @@ fn infer_if_else_coerce() {
            59..60 'x': &[i32]
            63..122 'if tru...     }': &[i32]
            66..70 'true': bool
-            71..91 '{     ...     }': &[i32; _]
+            71..91 '{     ...     }': &[i32; 1]
-            81..85 '&[1]': &[i32; _]
+            81..85 '&[1]': &[i32; 1]
-            82..85 '[1]': [i32; _]
+            82..85 '[1]': [i32; 1]
            83..84 '1': i32
            97..122 '{     ...     }': &[i32]
            107..110 'foo': fn foo<i32>(&[i32]) -> &[i32]
            107..116 'foo(&[1])': &[i32]
-            111..115 '&[1]': &[i32; _]
+            111..115 '&[1]': &[i32; 1]
-            112..115 '[1]': [i32; _]
+            112..115 '[1]': [i32; 1]
            113..114 '1': i32
-        "]],
+        "#]],
    )
 }
@@ -295,7 +295,7 @@ fn infer_match_first_coerce() {
        #[lang = "unsize"]
        pub trait Unsize<T: ?Sized> {}
        "#,
-        expect![[r"
+        expect![[r#"
            10..11 'x': &[T]
            27..38 '{ loop {} }': &[T]
            29..36 'loop {}': !
@@ -309,19 +309,19 @@ fn infer_match_first_coerce() {
            87..88 '2': i32
            92..95 'foo': fn foo<i32>(&[i32]) -> &[i32]
            92..101 'foo(&[2])': &[i32]
-            96..100 '&[2]': &[i32; _]
+            96..100 '&[2]': &[i32; 1]
-            97..100 '[2]': [i32; _]
+            97..100 '[2]': [i32; 1]
            98..99 '2': i32
            111..112 '1': i32
            111..112 '1': i32
-            116..120 '&[1]': &[i32; _]
+            116..120 '&[1]': &[i32; 1]
-            117..120 '[1]': [i32; _]
+            117..120 '[1]': [i32; 1]
            118..119 '1': i32
            130..131 '_': i32
-            135..139 '&[3]': &[i32; _]
+            135..139 '&[3]': &[i32; 1]
-            136..139 '[3]': [i32; _]
+            136..139 '[3]': [i32; 1]
            137..138 '3': i32
-    "]],
+        "#]],
    );
 }
@@ -348,7 +348,7 @@ fn infer_match_second_coerce() {
        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
        "#,
-        expect![[r"
+        expect![[r#"
            10..11 'x': &[T]
            27..38 '{ loop {} }': &[T]
            29..36 'loop {}': !
@@ -360,21 +360,21 @@ fn infer_match_second_coerce() {
            75..76 'i': i32
            87..88 '1': i32
            87..88 '1': i32
-            92..96 '&[1]': &[i32; _]
+            92..96 '&[1]': &[i32; 1]
-            93..96 '[1]': [i32; _]
+            93..96 '[1]': [i32; 1]
            94..95 '1': i32
            106..107 '2': i32
            106..107 '2': i32
            111..114 'foo': fn foo<i32>(&[i32]) -> &[i32]
            111..120 'foo(&[2])': &[i32]
-            115..119 '&[2]': &[i32; _]
+            115..119 '&[2]': &[i32; 1]
-            116..119 '[2]': [i32; _]
+            116..119 '[2]': [i32; 1]
            117..118 '2': i32
            130..131 '_': i32
-            135..139 '&[3]': &[i32; _]
+            135..139 '&[3]': &[i32; 1]
-            136..139 '[3]': [i32; _]
+            136..139 '[3]': [i32; 1]
            137..138 '3': i32
-    "]],
+        "#]],
    );
 }
@@ -685,15 +685,15 @@ fn coerce_unsize_array() {
            let f: &[usize] = &[1, 2, 3];
        }
        "#,
-        expect![[r"
+        expect![[r#"
            161..198 '{     ... 3]; }': ()
            171..172 'f': &[usize]
-            185..195 '&[1, 2, 3]': &[usize; _]
+            185..195 '&[1, 2, 3]': &[usize; 3]
-            186..195 '[1, 2, 3]': [usize; _]
+            186..195 '[1, 2, 3]': [usize; 3]
            187..188 '1': usize
            190..191 '2': usize
            193..194 '3': usize
-        "]],
+        "#]],
    );
 }
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index f514b3efe..787647e9f 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -243,8 +243,8 @@ fn infer_pattern_match_slice() {
        expect![[r#"
            10..209 '{     ...   } }': ()
            20..25 'slice': &[f64]
-            36..42 '&[0.0]': &[f64; _]
+            36..42 '&[0.0]': &[f64; 1]
-            37..42 '[0.0]': [f64; _]
+            37..42 '[0.0]': [f64; 1]
            38..41 '0.0': f64
            48..207 'match ...     }': ()
            54..59 'slice': &[f64]
@@ -345,19 +345,19 @@ fn infer_pattern_match_arr() {
        "#,
        expect![[r#"
            10..179 '{     ...   } }': ()
-            20..23 'arr': [f64; _]
+            20..23 'arr': [f64; 2]
-            36..46 '[0.0, 1.0]': [f64; _]
+            36..46 '[0.0, 1.0]': [f64; 2]
            37..40 '0.0': f64
            42..45 '1.0': f64
            52..177 'match ...     }': ()
-            58..61 'arr': [f64; _]
+            58..61 'arr': [f64; 2]
-            72..80 '[1.0, a]': [f64; _]
+            72..80 '[1.0, a]': [f64; 2]
            73..76 '1.0': f64
            73..76 '1.0': f64
            78..79 'a': f64
            84..110 '{     ...     }': ()
            98..99 'a': f64
-            120..126 '[b, c]': [f64; _]
+            120..126 '[b, c]': [f64; 2]
            121..122 'b': f64
            124..125 'c': f64
            130..171 '{     ...     }': ()
@@ -732,7 +732,7 @@ fn foo(tuple: (u8, i16, f32)) {
            111..112 'a': u8
            114..115 'b': i16
            124..126 '{}': ()
-            136..142 '(a, b)': (u8, i16, f32)
+            136..142 '(a, b)': (u8, i16)
            137..138 'a': u8
            140..141 'b': i16
            146..161 '{/*too short*/}': ()
diff --git a/crates/hir_ty/src/tests/regression.rs b/crates/hir_ty/src/tests/regression.rs
index d14f5c9bb..431861712 100644
--- a/crates/hir_ty/src/tests/regression.rs
+++ b/crates/hir_ty/src/tests/regression.rs
@@ -99,7 +99,7 @@ fn recursive_vars() {
            10..47 '{     ...&y]; }': ()
            20..21 'y': &{unknown}
            24..31 'unknown': &{unknown}
-            37..44 '[y, &y]': [&&{unknown}; _]
+            37..44 '[y, &y]': [&&{unknown}; 2]
            38..39 'y': &{unknown}
            41..43 '&y': &&{unknown}
            42..43 'y': &{unknown}
@@ -123,7 +123,7 @@ fn recursive_vars_2() {
            24..31 'unknown': &&{unknown}
            41..42 'y': &&{unknown}
            45..52 'unknown': &&{unknown}
-            58..76 '[(x, y..., &x)]': [(&&&{unknown}, &&&{unknown}); _]
+            58..76 '[(x, y..., &x)]': [(&&&{unknown}, &&&{unknown}); 2]
            59..65 '(x, y)': (&&&{unknown}, &&&{unknown})
            60..61 'x': &&{unknown}
            63..64 'y': &&{unknown}
@@ -175,8 +175,8 @@ fn infer_std_crash_2() {
        "#,
        expect![[r#"
            22..52 '{     ...n']; }': ()
-            28..49 '&[0, b...b'\n']': &[u8; _]
+            28..49 '&[0, b...b'\n']': &[u8; 4]
-            29..49 '[0, b'...b'\n']': [u8; _]
+            29..49 '[0, b'...b'\n']': [u8; 4]
            30..31 '0': u8
            33..38 'b'\n'': u8
            40..41 '1': u8
@@ -336,8 +336,8 @@ fn infer_array_macro_call() {
        expect![[r#"
            !0..4 '0u32': u32
            44..69 '{     ...()]; }': ()
-            54..55 'a': [u32; _]
+            54..55 'a': [u32; 1]
-            58..66 '[bar!()]': [u32; _]
+            58..66 '[bar!()]': [u32; 1]
        "#]],
    );
 }
@@ -1050,3 +1050,52 @@ fn test() {
        "#]],
    );
 }
+#[test]
+fn cfg_tail() {
+    // https://github.com/rust-analyzer/rust-analyzer/issues/8378
+    check_infer(
+        r#"
+        fn fake_tail(){
+            { "first" }
+            #[cfg(never)] 9
+        }
+        fn multiple_fake(){
+            { "fake" }
+            { "fake" }
+            { "second" }
+            #[cfg(never)] { 11 }
+            #[cfg(never)] 12;
+            #[cfg(never)] 13
+        }
+        fn no_normal_tail(){
+            { "third" }
+            #[cfg(never)] 14;
+            #[cfg(never)] 15;
+        }
+        fn no_actual_tail(){
+            { "fourth" };
+            #[cfg(never)] 14;
+            #[cfg(never)] 15
+        }
+        "#,
+        expect![[r#"
+            14..53 '{     ...)] 9 }': &str
+            20..31 '{ "first" }': &str
+            22..29 '"first"': &str
+            72..190 '{     ...] 13 }': &str
+            78..88 '{ "fake" }': &str
+            80..86 '"fake"': &str
+            93..103 '{ "fake" }': &str
+            95..101 '"fake"': &str
+            108..120 '{ "second" }': &str
+            110..118 '"second"': &str
+            210..273 '{     ... 15; }': &str
+            216..227 '{ "third" }': &str
+            218..225 '"third"': &str
+            293..357 '{     ...] 15 }': ()
+            299..311 '{ "fourth" }': &str
+            301..309 '"fourth"': &str
+        "#]],
+    )
+}
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index 0eefd70f2..a9cd42186 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -11,7 +11,7 @@ fn test() {
    let x = box 1;
    let t = (x, box x, box &1, box [1]);
    t;
-} //^ (Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32; _]>)
+} //^ (Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32; 1]>)
 //- /std.rs crate:std
 #[prelude_import] use prelude::*;
@@ -36,7 +36,7 @@ fn test() {
    let x = box 1;
    let t = (x, box x, box &1, box [1]);
    t;
-} //^ (Box<i32, {unknown}>, Box<Box<i32, {unknown}>, {unknown}>, Box<&i32, {unknown}>, Box<[i32; _], {unknown}>)
+} //^ (Box<i32, {unknown}>, Box<Box<i32, {unknown}>, {unknown}>, Box<&i32, {unknown}>, Box<[i32; 1], {unknown}>)
 //- /std.rs crate:std
 #[prelude_import] use prelude::*;
@@ -488,23 +488,34 @@ fn infer_literals() {
                mod foo {}
            "#;
            br#"yolo"#;
+            let a = b"a\x20b\
+            c";
+            let b = br"g\
+h";
+            let c = br#"x"\"yb"#;
        }
        "##,
        expect![[r##"
-            10..216 '{     ...o"#; }': ()
+            18..478 '{     ...     }': ()
-            16..20 '5i32': i32
+            32..36 '5i32': i32
-            26..30 '5f32': f32
+            50..54 '5f32': f32
-            36..40 '5f64': f64
+            68..72 '5f64': f64
-            46..53 '"hello"': &str
+            86..93 '"hello"': &str
-            59..67 'b"bytes"': &[u8; _]
+            107..115 'b"bytes"': &[u8; 5]
-            73..76 ''c'': char
+            129..132 ''c'': char
-            82..86 'b'b'': u8
+            146..150 'b'b'': u8
-            92..96 '3.14': f64
+            164..168 '3.14': f64
-            102..106 '5000': i32
+            182..186 '5000': i32
-            112..117 'false': bool
+            200..205 'false': bool
-            123..127 'true': bool
+            219..223 'true': bool
-            133..197 'r#"   ...    "#': &str
+            237..333 'r#"   ...    "#': &str
-            203..213 'br#"yolo"#': &[u8; _]
+            347..357 'br#"yolo"#': &[u8; 4]
+            375..376 'a': &[u8; 4]
+            379..403 'b"a\x2...    c"': &[u8; 4]
+            421..422 'b': &[u8; 4]
+            425..433 'br"g\ h"': &[u8; 4]
+            451..452 'c': &[u8; 6]
+            455..467 'br#"x"\"yb"#': &[u8; 6]
        "##]],
    );
 }
@@ -1260,61 +1271,69 @@ fn infer_array() {
            let b = [a, ["b"]];
            let x: [u8; 0] = [];
+            // FIXME: requires const evaluation/taking type from rhs somehow
+            let y: [u8; 2+2] = [1,2,3,4];
        }
        "#,
        expect![[r#"
            8..9 'x': &str
            17..18 'y': isize
-            27..292 '{     ... []; }': ()
+            27..395 '{     ...,4]; }': ()
-            37..38 'a': [&str; _]
+            37..38 'a': [&str; 1]
-            41..44 '[x]': [&str; _]
+            41..44 '[x]': [&str; 1]
            42..43 'x': &str
-            54..55 'b': [[&str; _]; _]
+            54..55 'b': [[&str; 1]; 2]
-            58..64 '[a, a]': [[&str; _]; _]
+            58..64 '[a, a]': [[&str; 1]; 2]
-            59..60 'a': [&str; _]
+            59..60 'a': [&str; 1]
-            62..63 'a': [&str; _]
+            62..63 'a': [&str; 1]
-            74..75 'c': [[[&str; _]; _]; _]
+            74..75 'c': [[[&str; 1]; 2]; 2]
-            78..84 '[b, b]': [[[&str; _]; _]; _]
+            78..84 '[b, b]': [[[&str; 1]; 2]; 2]
-            79..80 'b': [[&str; _]; _]
+            79..80 'b': [[&str; 1]; 2]
-            82..83 'b': [[&str; _]; _]
+            82..83 'b': [[&str; 1]; 2]
-            95..96 'd': [isize; _]
+            95..96 'd': [isize; 4]
-            99..111 '[y, 1, 2, 3]': [isize; _]
+            99..111 '[y, 1, 2, 3]': [isize; 4]
            100..101 'y': isize
            103..104 '1': isize
            106..107 '2': isize
            109..110 '3': isize
-            121..122 'd': [isize; _]
+            121..122 'd': [isize; 4]
-            125..137 '[1, y, 2, 3]': [isize; _]
+            125..137 '[1, y, 2, 3]': [isize; 4]
            126..127 '1': isize
            129..130 'y': isize
            132..133 '2': isize
            135..136 '3': isize
-            147..148 'e': [isize; _]
+            147..148 'e': [isize; 1]
-            151..154 '[y]': [isize; _]
+            151..154 '[y]': [isize; 1]
            152..153 'y': isize
-            164..165 'f': [[isize; _]; _]
+            164..165 'f': [[isize; 4]; 2]
-            168..174 '[d, d]': [[isize; _]; _]
+            168..174 '[d, d]': [[isize; 4]; 2]
-            169..170 'd': [isize; _]
+            169..170 'd': [isize; 4]
-            172..173 'd': [isize; _]
+            172..173 'd': [isize; 4]
-            184..185 'g': [[isize; _]; _]
+            184..185 'g': [[isize; 1]; 2]
-            188..194 '[e, e]': [[isize; _]; _]
+            188..194 '[e, e]': [[isize; 1]; 2]
-            189..190 'e': [isize; _]
+            189..190 'e': [isize; 1]
-            192..193 'e': [isize; _]
+            192..193 'e': [isize; 1]
-            205..206 'h': [i32; _]
+            205..206 'h': [i32; 2]
-            209..215 '[1, 2]': [i32; _]
+            209..215 '[1, 2]': [i32; 2]
            210..211 '1': i32
            213..214 '2': i32
-            225..226 'i': [&str; _]
+            225..226 'i': [&str; 2]
-            229..239 '["a", "b"]': [&str; _]
+            229..239 '["a", "b"]': [&str; 2]
            230..233 '"a"': &str
            235..238 '"b"': &str
-            250..251 'b': [[&str; _]; _]
+            250..251 'b': [[&str; 1]; 2]
-            254..264 '[a, ["b"]]': [[&str; _]; _]
+            254..264 '[a, ["b"]]': [[&str; 1]; 2]
-            255..256 'a': [&str; _]
+            255..256 'a': [&str; 1]
-            258..263 '["b"]': [&str; _]
+            258..263 '["b"]': [&str; 1]
            259..262 '"b"': &str
-            274..275 'x': [u8; _]
+            274..275 'x': [u8; 0]
-            287..289 '[]': [u8; _]
+            287..289 '[]': [u8; 0]
+            368..369 'y': [u8; _]
+            383..392 '[1,2,3,4]': [u8; 4]
+            384..385 '1': u8
+            386..387 '2': u8
+            388..389 '3': u8
+            390..391 '4': u8
        "#]],
    );
 }
@@ -2409,40 +2428,40 @@ fn infer_operator_overload() {
            320..422 '{     ...     }': V2
            334..335 'x': f32
            338..342 'self': V2
-            338..344 'self.0': [f32; _]
+            338..344 'self.0': [f32; 2]
            338..347 'self.0[0]': {unknown}
            338..358 'self.0...s.0[0]': f32
            345..346 '0': i32
            350..353 'rhs': V2
-            350..355 'rhs.0': [f32; _]
+            350..355 'rhs.0': [f32; 2]
            350..358 'rhs.0[0]': {unknown}
            356..357 '0': i32
            372..373 'y': f32
            376..380 'self': V2
-            376..382 'self.0': [f32; _]
+            376..382 'self.0': [f32; 2]
            376..385 'self.0[1]': {unknown}
            376..396 'self.0...s.0[1]': f32
            383..384 '1': i32
            388..391 'rhs': V2
-            388..393 'rhs.0': [f32; _]
+            388..393 'rhs.0': [f32; 2]
            388..396 'rhs.0[1]': {unknown}
            394..395 '1': i32
-            406..408 'V2': V2([f32; _]) -> V2
+            406..408 'V2': V2([f32; 2]) -> V2
            406..416 'V2([x, y])': V2
-            409..415 '[x, y]': [f32; _]
+            409..415 '[x, y]': [f32; 2]
            410..411 'x': f32
            413..414 'y': f32
            436..519 '{     ... vb; }': ()
            446..448 'va': V2
-            451..453 'V2': V2([f32; _]) -> V2
+            451..453 'V2': V2([f32; 2]) -> V2
            451..465 'V2([0.0, 1.0])': V2
-            454..464 '[0.0, 1.0]': [f32; _]
+            454..464 '[0.0, 1.0]': [f32; 2]
            455..458 '0.0': f32
            460..463 '1.0': f32
            475..477 'vb': V2
-            480..482 'V2': V2([f32; _]) -> V2
+            480..482 'V2': V2([f32; 2]) -> V2
            480..494 'V2([0.0, 1.0])': V2
-            483..493 '[0.0, 1.0]': [f32; _]
+            483..493 '[0.0, 1.0]': [f32; 2]
            484..487 '0.0': f3