Revert "Auto merge of #12149 - jonas-schievink:literally-just-a-literal, r=jonas-schievink"

This reverts commit cc9ae2b89e, reversing
changes made to 7dfd1cb572.

crates/syntax/src/ast/expr_ext.rs

@@ -8,7 +8,7 @@ use crate::{
         operators::{ArithOp, BinaryOp, CmpOp, LogicOp, Ordering, RangeOp, UnaryOp},
         support, AstChildren, AstNode,
     },
-    AstToken, SyntaxElement,
+    AstToken,
     SyntaxKind::*,
     SyntaxNode, SyntaxToken, T,
 };
@@ -282,32 +282,30 @@ pub enum LiteralKind {
     String(ast::String),
     ByteString(ast::ByteString),
     IntNumber(ast::IntNumber),
-    FloatNumber(ast::FloatLiteral),
+    FloatNumber(ast::FloatNumber),
     Char(ast::Char),
     Byte(ast::Byte),
     Bool(bool),
 }
 
 impl ast::Literal {
-    pub fn value(&self) -> SyntaxElement {
+    pub fn token(&self) -> SyntaxToken {
         self.syntax()
             .children_with_tokens()
             .find(|e| e.kind() != ATTR && !e.kind().is_trivia())
+            .and_then(|e| e.into_token())
             .unwrap()
     }
+
     pub fn kind(&self) -> LiteralKind {
-        let token = match self.value() {
-            rowan::NodeOrToken::Node(node) => {
-                return LiteralKind::FloatNumber(
-                    ast::FloatLiteral::cast(node).expect("unreachable"),
-                );
-            }
-            rowan::NodeOrToken::Token(token) => token,
-        };
+        let token = self.token();
 
         if let Some(t) = ast::IntNumber::cast(token.clone()) {
             return LiteralKind::IntNumber(t);
         }
+        if let Some(t) = ast::FloatNumber::cast(token.clone()) {
+            return LiteralKind::FloatNumber(t);
+        }
         if let Some(t) = ast::String::cast(token.clone()) {
             return LiteralKind::String(t);
         }
@@ -327,26 +325,6 @@ impl ast::Literal {
             _ => unreachable!(),
         }
     }
-
-    pub fn as_string(&self) -> Option<ast::String> {
-        match self.kind() {
-            LiteralKind::String(it) => Some(it),
-            _ => None,
-        }
-    }
-
-    pub fn as_byte_string(&self) -> Option<ast::ByteString> {
-        match self.kind() {
-            LiteralKind::ByteString(it) => Some(it),
-            _ => None,
-        }
-    }
-}
-
-impl ast::FloatLiteral {
-    pub fn suffix(&self) -> Option<String> {
-        ast::FloatNumberPart::cast(self.syntax().last_token()?)?.suffix().map(|s| s.to_string())
-    }
 }
 
 pub enum BlockModifier {
@@ -386,7 +364,7 @@ impl ast::BlockExpr {
 fn test_literal_with_attr() {
     let parse = ast::SourceFile::parse(r#"const _: &str = { #[attr] "Hello" };"#);
     let lit = parse.tree().syntax().descendants().find_map(ast::Literal::cast).unwrap();
-    assert_eq!(lit.value().to_string(), r#""Hello""#);
+    assert_eq!(lit.token().text(), r#""Hello""#);
 }
 
 impl ast::RecordExprField {

crates/syntax/src/ast/generated/nodes.rs

@@ -1085,26 +1085,6 @@ impl UnderscoreExpr {
     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct FloatLiteral {
-    pub(crate) syntax: SyntaxNode,
-}
-impl FloatLiteral {
-    pub fn float_number_start_0_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, T![float_number_start_0])
-    }
-    pub fn float_number_start_1_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, T![float_number_start_1])
-    }
-    pub fn float_number_start_2_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, T![float_number_start_2])
-    }
-    pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
-    pub fn float_number_part_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, T![float_number_part])
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StmtList {
     pub(crate) syntax: SyntaxNode,
@@ -2739,17 +2719,6 @@ impl AstNode for UnderscoreExpr {
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl AstNode for FloatLiteral {
-    fn can_cast(kind: SyntaxKind) -> bool { kind == FLOAT_LITERAL }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
 impl AstNode for StmtList {
     fn can_cast(kind: SyntaxKind) -> bool { kind == STMT_LIST }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -4639,11 +4608,6 @@ impl std::fmt::Display for UnderscoreExpr {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for FloatLiteral {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Display::fmt(self.syntax(), f)
-    }
-}
 impl std::fmt::Display for StmtList {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)

crates/syntax/src/ast/generated/tokens.rs

@@ -112,16 +112,16 @@ impl AstToken for IntNumber {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct FloatNumberPart {
+pub struct FloatNumber {
     pub(crate) syntax: SyntaxToken,
 }
-impl std::fmt::Display for FloatNumberPart {
+impl std::fmt::Display for FloatNumber {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(&self.syntax, f)
     }
 }
-impl AstToken for FloatNumberPart {
-    fn can_cast(kind: SyntaxKind) -> bool { kind == FLOAT_NUMBER_PART }
+impl AstToken for FloatNumber {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == FLOAT_NUMBER }
     fn cast(syntax: SyntaxToken) -> Option<Self> {
         if Self::can_cast(syntax.kind()) {
             Some(Self { syntax })

crates/syntax/src/ast/make.rs

@@ -799,11 +799,6 @@ pub fn struct_(
     ))
 }
 
-pub fn literal(text: &str) -> ast::Literal {
-    assert_eq!(text.trim(), text);
-    ast_from_text(&format!("fn f() {{ let _ = {}; }}", text))
-}
-
 #[track_caller]
 fn ast_from_text<N: AstNode>(text: &str) -> N {
     let parse = SourceFile::parse(text);
@@ -832,7 +827,7 @@ pub fn token(kind: SyntaxKind) -> SyntaxToken {
 pub mod tokens {
     use once_cell::sync::Lazy;
 
-    use crate::{AstNode, Parse, SourceFile, SyntaxKind::*, SyntaxToken};
+    use crate::{ast, AstNode, Parse, SourceFile, SyntaxKind::*, SyntaxToken};
 
     pub(super) static SOURCE_FILE: Lazy<Parse<SourceFile>> = Lazy::new(|| {
         SourceFile::parse(
@@ -863,6 +858,12 @@ pub mod tokens {
         sf.syntax().first_child_or_token().unwrap().into_token().unwrap()
     }
 
+    pub fn literal(text: &str) -> SyntaxToken {
+        assert_eq!(text.trim(), text);
+        let lit: ast::Literal = super::ast_from_text(&format!("fn f() {{ let _ = {}; }}", text));
+        lit.syntax().first_child_or_token().unwrap().into_token().unwrap()
+    }
+
     pub fn single_newline() -> SyntaxToken {
         let res = SOURCE_FILE
             .tree()

crates/syntax/src/ast/node_ext.rs

@@ -555,9 +555,7 @@ impl ast::FieldExpr {
         self.syntax
             .children_with_tokens()
             // FIXME: Accepting floats here to reject them in validation later
-            .find(|c| {
-                c.kind() == SyntaxKind::INT_NUMBER || c.kind() == SyntaxKind::FLOAT_NUMBER_PART
-            })
+            .find(|c| c.kind() == SyntaxKind::INT_NUMBER || c.kind() == SyntaxKind::FLOAT_NUMBER)
             .as_ref()
             .and_then(SyntaxElement::as_token)
             .cloned()

crates/syntax/src/ast/token_ext.rs

@@ -321,7 +321,7 @@ impl ast::IntNumber {
     }
 }
 
-impl ast::FloatNumberPart {
+impl ast::FloatNumber {
     pub fn suffix(&self) -> Option<&str> {
         let text = self.text();
         let mut indices = text.char_indices();
@@ -355,24 +355,14 @@ impl Radix {
 
 #[cfg(test)]
 mod tests {
-    use crate::ast::{self, make};
+    use crate::ast::{self, make, FloatNumber, IntNumber};
 
     fn check_float_suffix<'a>(lit: &str, expected: impl Into<Option<&'a str>>) {
-        let suffix = match make::literal(lit).kind() {
-            ast::LiteralKind::FloatNumber(f) => f.suffix(),
-            // `1f32` lexes as an INT_NUMBER
-            ast::LiteralKind::IntNumber(i) => i.suffix().map(|s| s.to_string()),
-            e => unreachable!("{e:?}"),
-        };
-        assert_eq!(suffix.as_deref(), expected.into());
+        assert_eq!(FloatNumber { syntax: make::tokens::literal(lit) }.suffix(), expected.into());
     }
 
     fn check_int_suffix<'a>(lit: &str, expected: impl Into<Option<&'a str>>) {
-        let i = match make::literal(lit).kind() {
-            ast::LiteralKind::IntNumber(i) => i,
-            _ => unreachable!(),
-        };
-        assert_eq!(i.suffix(), expected.into());
+        assert_eq!(IntNumber { syntax: make::tokens::literal(lit) }.suffix(), expected.into());
     }
 
     #[test]
@@ -400,11 +390,12 @@ mod tests {
     }
 
     fn check_string_value<'a>(lit: &str, expected: impl Into<Option<&'a str>>) {
-        let s = match make::literal(&format!("\"{}\"", lit)).kind() {
-            ast::LiteralKind::String(s) => s,
-            _ => unreachable!(),
-        };
-        assert_eq!(s.value().as_deref(), expected.into());
+        assert_eq!(
+            ast::String { syntax: make::tokens::literal(&format!("\"{}\"", lit)) }
+                .value()
+                .as_deref(),
+            expected.into()
+        );
     }
 
     #[test]