fix: f32 and f64 representation during lowering

Author: feniljain

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

@@ -968,7 +968,7 @@ impl From<ast::LiteralKind> for Literal {
             // 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) {
-                    Literal::Float(Default::default(), builtin)
+                    Literal::Float(lit.float_value().unwrap_or(Default::default()), builtin)
                 } else if let builtin @ Some(_) = lit.suffix().and_then(BuiltinInt::from_suffix) {
                     Literal::Int(lit.value().unwrap_or(0) as i128, builtin)
                 } else {
@@ -978,7 +978,7 @@ impl From<ast::LiteralKind> for Literal {
             }
             LiteralKind::FloatNumber(lit) => {
                 let ty = lit.suffix().and_then(BuiltinFloat::from_suffix);
-                Literal::Float(Default::default(), ty)
+                Literal::Float(lit.value().unwrap_or(Default::default()), ty)
             }
             LiteralKind::ByteString(bs) => {
                 let text = bs.value().map(Box::from).unwrap_or_else(Default::default);

crates/hir-def/src/expr.rs

@@ -23,6 +23,8 @@ use crate::{
     BlockId,
 };
 
+use syntax::ast::FloatTypeWrapper;
+
 pub use syntax::ast::{ArithOp, BinaryOp, CmpOp, LogicOp, Ordering, RangeOp, UnaryOp};
 
 pub type ExprId = Idx<Expr>;
@@ -46,7 +48,10 @@ pub enum Literal {
     Bool(bool),
     Int(i128, Option<BuiltinInt>),
     Uint(u128, Option<BuiltinUint>),
-    Float(u64, Option<BuiltinFloat>), // FIXME: f64 is not Eq
+    // Here we are using a wrapper around float because f32 and f64 do not implement Eq, so they
+    // could not be used directly here, to understand how the wrapper works go to definition of
+    // FloatTypeWrapper
+    Float(FloatTypeWrapper, Option<BuiltinFloat>),
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]

crates/ide/src/hover/tests.rs

@@ -3598,6 +3598,52 @@ const FOO$0: u8 = b'\x61';
             This is a doc
         "#]],
     );
+
+    // show float literal
+    check(
+        r#"
+    /// This is a doc
+    const FOO$0: f64 = 1.0234;
+    "#,
+        expect![[r#"
+            *FOO*
+
+            ```rust
+            test
+            ```
+
+            ```rust
+            const FOO: f64 = 1.0234
+            ```
+
+            ---
+
+            This is a doc
+        "#]],
+    );
+
+    //show float typecasted
+    check(
+        r#"
+/// This is a doc
+const FOO$0: f32 = 1f32;
+"#,
+        expect![[r#"
+            *FOO*
+
+            ```rust
+            test
+            ```
+
+            ```rust
+            const FOO: f32 = 1
+            ```
+
+            ---
+
+            This is a doc
+        "#]],
+    );
 }
 
 #[test]

crates/syntax/src/ast.rs

@@ -25,7 +25,10 @@ pub use self::{
         SlicePatComponents, StructKind, TypeBoundKind, TypeOrConstParam, VisibilityKind,
     },
     operators::{ArithOp, BinaryOp, CmpOp, LogicOp, Ordering, RangeOp, UnaryOp},
-    token_ext::{CommentKind, CommentPlacement, CommentShape, IsString, QuoteOffsets, Radix},
+    token_ext::{
+        CommentKind, CommentPlacement, CommentShape, FloatTypeWrapper, IsString, QuoteOffsets,
+        Radix,
+    },
     traits::{
         AttrDocCommentIter, DocCommentIter, HasArgList, HasAttrs, HasDocComments, HasGenericParams,
         HasLoopBody, HasModuleItem, HasName, HasTypeBounds, HasVisibility,

crates/syntax/src/ast/token_ext.rs

@@ -319,6 +319,30 @@ impl ast::IntNumber {
             Some(suffix)
         }
     }
+
+    pub fn float_value(&self) -> Option<FloatTypeWrapper> {
+        let (_, text, _) = self.split_into_parts();
+        let float_value = text.parse::<f64>().ok()?;
+        Some(FloatTypeWrapper::new(float_value))
+    }
+}
+
+// We convert float values into bits and that's how we don't need to deal with f32 and f64.
+// For PartialEq, bits comparison should work, as ordering is not important
+// https://github.com/rust-lang/rust-analyzer/issues/12380#issuecomment-1137284360
+#[derive(Default, Debug, Clone, Eq, PartialEq)]
+pub struct FloatTypeWrapper(u64);
+
+impl FloatTypeWrapper {
+    fn new(value: f64) -> Self {
+        Self(value.to_bits())
+    }
+}
+
+impl std::fmt::Display for FloatTypeWrapper {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", f64::from_bits(self.0))
+    }
 }
 
 impl ast::FloatNumber {
@@ -331,6 +355,11 @@ impl ast::FloatNumber {
         }
         Some(&text[suffix_start..])
     }
+
+    pub fn value(&self) -> Option<FloatTypeWrapper> {
+        let float_value = self.text().parse::<f64>().ok()?;
+        Some(FloatTypeWrapper::new(float_value))
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]