fix: split float literal tokens at . to fix parsing of tuple field accesses

crates/hir-def/src/body/lower.rs

@@ -972,7 +972,7 @@ impl From<ast::LiteralKind> for Literal {
                 }
             }
             LiteralKind::FloatNumber(lit) => {
-                let ty = lit.suffix().and_then(BuiltinFloat::from_suffix);
+                let ty = lit.suffix().and_then(|s| BuiltinFloat::from_suffix(&s));
                 Literal::Float(Default::default(), ty)
             }
             LiteralKind::ByteString(bs) => {

crates/hir-expand/src/builtin_fn_macro.rs

@@ -4,10 +4,7 @@ use base_db::{AnchoredPath, Edition, FileId};
 use cfg::CfgExpr;
 use either::Either;
 use mbe::{parse_exprs_with_sep, parse_to_token_tree};
-use syntax::{
-    ast::{self, AstToken},
-    SmolStr,
-};
+use syntax::{ast, SmolStr};
 
 use crate::{db::AstDatabase, name, quote, ExpandError, ExpandResult, MacroCallId, MacroCallLoc};
 
@@ -358,14 +355,7 @@ fn unreachable_expand(
 }
 
 fn unquote_str(lit: &tt::Literal) -> Option<String> {
-    let lit = ast::make::tokens::literal(&lit.to_string());
-    let token = ast::String::cast(lit)?;
-    token.value().map(|it| it.into_owned())
-}
-
-fn unquote_byte_string(lit: &tt::Literal) -> Option<Vec<u8>> {
-    let lit = ast::make::tokens::literal(&lit.to_string());
-    let token = ast::ByteString::cast(lit)?;
+    let token = ast::make::literal(&lit.to_string()).as_string()?;
     token.value().map(|it| it.into_owned())
 }
 
@@ -442,12 +432,16 @@ fn concat_bytes_expand(
     for (i, t) in tt.token_trees.iter().enumerate() {
         match t {
             tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) => {
-                let token = ast::make::tokens::literal(&lit.to_string());
-                match token.kind() {
-                    syntax::SyntaxKind::BYTE => bytes.push(token.text().to_string()),
-                    syntax::SyntaxKind::BYTE_STRING => {
-                        let components = unquote_byte_string(lit).unwrap_or_else(Vec::new);
-                        components.into_iter().for_each(|x| bytes.push(x.to_string()));
+                let lit = ast::make::literal(&lit.to_string());
+                match lit.kind() {
+                    ast::LiteralKind::ByteString(s) => {
+                        s.value()
+                            .unwrap_or_default()
+                            .into_iter()
+                            .for_each(|x| bytes.push(x.to_string()));
+                    }
+                    ast::LiteralKind::Byte(_) => {
+                        bytes.push(lit.to_string());
                     }
                     _ => {
                         err.get_or_insert(mbe::ExpandError::UnexpectedToken.into());
@@ -481,10 +475,10 @@ fn concat_bytes_expand_subtree(
     for (ti, tt) in tree.token_trees.iter().enumerate() {
         match tt {
             tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) => {
-                let lit = ast::make::tokens::literal(&lit.to_string());
+                let lit = ast::make::literal(&lit.to_string());
                 match lit.kind() {
-                    syntax::SyntaxKind::BYTE | syntax::SyntaxKind::INT_NUMBER => {
-                        bytes.push(lit.text().to_string())
+                    ast::LiteralKind::IntNumber(_) | ast::LiteralKind::Byte(_) => {
+                        bytes.push(lit.to_string());
                     }
                     _ => {
                         return Err(mbe::ExpandError::UnexpectedToken.into());

crates/hir-ty/src/tests/simple.rs

@@ -2733,3 +2733,14 @@ fn f() {
     "#,
     );
 }
+
+#[test]
+fn nested_tuple_index() {
+    check_no_mismatches(
+        r#"
+fn main() {
+    let fld: i32 = ((0,),).0.0;
+}
+"#,
+    );
+}

crates/ide-completion/src/completions/dot.rs

@@ -785,4 +785,24 @@ fn main() {
 ",
         )
     }
+
+    #[test]
+    fn tuple_index_completion() {
+        check(
+            r#"
+struct I;
+impl I {
+    fn i_method(&self) {}
+}
+struct S((), I);
+
+fn f(s: S) {
+    s.1.$0
+}
+"#,
+            expect![[r#"
+                me i_method() fn(&self)
+            "#]],
+        );
+    }
 }

crates/ide-completion/src/completions/postfix.rs

@@ -5,7 +5,7 @@ mod format_like;
 use hir::{Documentation, HasAttrs};
 use ide_db::{imports::insert_use::ImportScope, ty_filter::TryEnum, SnippetCap};
 use syntax::{
-    ast::{self, AstNode, AstToken},
+    ast::{self, AstNode, LiteralKind},
     SyntaxKind::{EXPR_STMT, STMT_LIST},
     TextRange, TextSize,
 };
@@ -191,7 +191,7 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     }
 
     if let ast::Expr::Literal(literal) = dot_receiver.clone() {
-        if let Some(literal_text) = ast::String::cast(literal.token()) {
+        if let LiteralKind::String(literal_text) = literal.kind() {
             add_format_like_completions(acc, ctx, &dot_receiver, cap, &literal_text);
         }
     }

crates/ide-completion/src/patterns.rs

@@ -230,7 +230,7 @@ pub(crate) fn determine_location(
                 let receiver = find_in_original_file(it.expr(), original_file);
                 let receiver_is_ambiguous_float_literal = if let Some(ast::Expr::Literal(l)) = &receiver {
                     match l.kind() {
-                        ast::LiteralKind::FloatNumber { .. } => l.token().text().ends_with('.'),
+                        ast::LiteralKind::FloatNumber { .. } => l.to_string().ends_with('.'),
                         _ => false,
                     }
                 } else {

crates/ide/src/syntax_highlighting/highlight.rs

@@ -30,7 +30,15 @@ pub(super) fn token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Optio
         INT_NUMBER if token.ancestors().nth(1).map(|it| it.kind()) == Some(FIELD_EXPR) => {
             SymbolKind::Field.into()
         }
-        INT_NUMBER | FLOAT_NUMBER => HlTag::NumericLiteral.into(),
+        INT_NUMBER | FLOAT_NUMBER_PART | FLOAT_NUMBER_START_0 | FLOAT_NUMBER_START_1
+        | FLOAT_NUMBER_START_2 => HlTag::NumericLiteral.into(),
+        DOT if matches!(
+            token.prev_token().map(|n| n.kind()),
+            Some(FLOAT_NUMBER_START_1 | FLOAT_NUMBER_START_2)
+        ) =>
+        {
+            HlTag::NumericLiteral.into()
+        }
         BYTE => HlTag::ByteLiteral.into(),
         CHAR => HlTag::CharLiteral.into(),
         IDENT if token.parent().and_then(ast::TokenTree::cast).is_some() => {