feat: LSP hover for integer literals (#7368)

Co-authored-by: Tom French <[email protected]>
Co-authored-by: jfecher <[email protected]>

Author: 3 people

Cargo.lock

@@ -162,25 +162,25 @@ pub trait Visitor {
         true
     }
 
-    fn visit_literal_array(&mut self, _: &ArrayLiteral) -> bool {
+    fn visit_literal_array(&mut self, _: &ArrayLiteral, _: Span) -> bool {
         true
     }
 
-    fn visit_literal_slice(&mut self, _: &ArrayLiteral) -> bool {
+    fn visit_literal_slice(&mut self, _: &ArrayLiteral, _: Span) -> bool {
         true
     }
 
-    fn visit_literal_bool(&mut self, _: bool) {}
+    fn visit_literal_bool(&mut self, _: bool, _: Span) {}
 
-    fn visit_literal_integer(&mut self, _value: FieldElement, _negative: bool) {}
+    fn visit_literal_integer(&mut self, _value: FieldElement, _negative: bool, _: Span) {}
 
-    fn visit_literal_str(&mut self, _: &str) {}
+    fn visit_literal_str(&mut self, _: &str, _: Span) {}
 
-    fn visit_literal_raw_str(&mut self, _: &str, _: u8) {}
+    fn visit_literal_raw_str(&mut self, _: &str, _: u8, _: Span) {}
 
-    fn visit_literal_fmt_str(&mut self, _: &[FmtStrFragment], _length: u32) {}
+    fn visit_literal_fmt_str(&mut self, _: &[FmtStrFragment], _length: u32, _: Span) {}
 
-    fn visit_literal_unit(&mut self) {}
+    fn visit_literal_unit(&mut self, _: Span) {}
 
     fn visit_block_expression(&mut self, _: &BlockExpression, _: Option<Span>) -> bool {
         true
@@ -262,18 +262,19 @@ pub trait Visitor {
         true
     }
 
-    fn visit_array_literal(&mut self, _: &ArrayLiteral) -> bool {
+    fn visit_array_literal(&mut self, _: &ArrayLiteral, _: Span) -> bool {
         true
     }
 
-    fn visit_array_literal_standard(&mut self, _: &[Expression]) -> bool {
+    fn visit_array_literal_standard(&mut self, _: &[Expression], _: Span) -> bool {
         true
     }
 
     fn visit_array_literal_repeated(
         &mut self,
         _repeated_element: &Expression,
         _length: &Expression,
+        _: Span,
     ) -> bool {
         true
     }
@@ -927,28 +928,32 @@ impl Expression {
 impl Literal {
     pub fn accept(&self, span: Span, visitor: &mut impl Visitor) {
         if visitor.visit_literal(self, span) {
-            self.accept_children(visitor);
+            self.accept_children(span, visitor);
         }
     }
 
-    pub fn accept_children(&self, visitor: &mut impl Visitor) {
+    pub fn accept_children(&self, span: Span, visitor: &mut impl Visitor) {
         match self {
             Literal::Array(array_literal) => {
-                if visitor.visit_literal_array(array_literal) {
-                    array_literal.accept(visitor);
+                if visitor.visit_literal_array(array_literal, span) {
+                    array_literal.accept(span, visitor);
                 }
             }
             Literal::Slice(array_literal) => {
-                if visitor.visit_literal_slice(array_literal) {
-                    array_literal.accept(visitor);
+                if visitor.visit_literal_slice(array_literal, span) {
+                    array_literal.accept(span, visitor);
                 }
             }
-            Literal::Bool(value) => visitor.visit_literal_bool(*value),
-            Literal::Integer(value, negative) => visitor.visit_literal_integer(*value, *negative),
-            Literal::Str(str) => visitor.visit_literal_str(str),
-            Literal::RawStr(str, length) => visitor.visit_literal_raw_str(str, *length),
-            Literal::FmtStr(fragments, length) => visitor.visit_literal_fmt_str(fragments, *length),
-            Literal::Unit => visitor.visit_literal_unit(),
+            Literal::Bool(value) => visitor.visit_literal_bool(*value, span),
+            Literal::Integer(value, negative) => {
+                visitor.visit_literal_integer(*value, *negative, span);
+            }
+            Literal::Str(str) => visitor.visit_literal_str(str, span),
+            Literal::RawStr(str, length) => visitor.visit_literal_raw_str(str, *length, span),
+            Literal::FmtStr(fragments, length) => {
+                visitor.visit_literal_fmt_str(fragments, *length, span);
+            }
+            Literal::Unit => visitor.visit_literal_unit(span),
         }
     }
 }
@@ -1120,21 +1125,21 @@ impl Lambda {
 }
 
 impl ArrayLiteral {
-    pub fn accept(&self, visitor: &mut impl Visitor) {
-        if visitor.visit_array_literal(self) {
-            self.accept_children(visitor);
+    pub fn accept(&self, span: Span, visitor: &mut impl Visitor) {
+        if visitor.visit_array_literal(self, span) {
+            self.accept_children(span, visitor);
         }
     }
 
-    pub fn accept_children(&self, visitor: &mut impl Visitor) {
+    pub fn accept_children(&self, span: Span, visitor: &mut impl Visitor) {
         match self {
             ArrayLiteral::Standard(expressions) => {
-                if visitor.visit_array_literal_standard(expressions) {
+                if visitor.visit_array_literal_standard(expressions, span) {
                     visit_expressions(expressions, visitor);
                 }
             }
             ArrayLiteral::Repeated { repeated_element, length } => {
-                if visitor.visit_array_literal_repeated(repeated_element, length) {
+                if visitor.visit_array_literal_repeated(repeated_element, length, span) {
                     repeated_element.accept(visitor);
                     length.accept(visitor);
                 }

compiler/noirc_frontend/src/ast/visitor.rs

@@ -32,6 +32,7 @@ fm.workspace = true
 rayon.workspace = true
 fxhash.workspace = true
 convert_case = "0.6.0"
+num-bigint.workspace = true
 
 [target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies]
 wasm-bindgen.workspace = true