Rust: store in the DB if a library function or const had a body

When skipping bodies in library code, we lose the information whether a
body was originally present. This can be important, for example when
determining whether a trait method has a default implementation.

With this change that information can be recovered via the
`hasImplementation` predicate.

Author: Paolo Tranquilli

rust/extractor/src/generated/.generated.list

@@ -38,6 +38,7 @@ macro_rules! post_emit {
         $self.extract_macro_call_expanded($node, $label);
     };
     (Function, $self:ident, $node:ident, $label:ident) => {
+        $self.emit_function_has_implementation($node, $label);
         $self.extract_canonical_origin($node, $label.into());
     };
     (Trait, $self:ident, $node:ident, $label:ident) => {
@@ -83,6 +84,9 @@ macro_rules! post_emit {
     (PathSegment, $self:ident, $node:ident, $label:ident) => {
         $self.extract_types_from_path_segment($node, $label.into());
     };
+    (Const, $self:ident, $node:ident, $label:ident) => {
+        $self.emit_const_has_implementation($node, $label);
+    };
     ($($_:tt)*) => {};
 }
 
@@ -761,4 +765,24 @@ impl<'a> Translator<'a> {
             generated::Item::emit_attribute_macro_expansion(label, expanded, &mut self.trap.writer);
         }
     }
+
+    pub(crate) fn emit_function_has_implementation(
+        &mut self,
+        node: &ast::Fn,
+        label: Label<generated::Function>,
+    ) {
+        if node.body().is_some() {
+            generated::Function::emit_has_implementation(label, &mut self.trap.writer);
+        }
+    }
+
+    pub(crate) fn emit_const_has_implementation(
+        &mut self,
+        node: &ast::Const,
+        label: Label<generated::Const>,
+    ) {
+        if node.body().is_some() {
+            generated::Const::emit_has_implementation(label, &mut self.trap.writer);
+        }
+    }
 }

rust/extractor/src/generated/top.rs

@@ -2816,6 +2816,11 @@ const_visibilities(
   int visibility: @visibility ref
 );
 
+#keyset[id]
+const_has_implementation(
+  int id: @const ref
+);
+
 enums(
   unique int id: @enum
 );
@@ -2985,6 +2990,11 @@ function_where_clauses(
   int where_clause: @where_clause ref
 );
 
+#keyset[id]
+function_has_implementation(
+  int id: @function ref
+);
+
 impls(
   unique int id: @impl
 );

rust/extractor/src/translate/base.rs

@@ -951,6 +951,10 @@ class _:
     todo!()
     ```
     """
+    has_implementation: predicate | doc("this constant has an implementation") | desc("""
+      This is the same as `hasBody` for source code, but for library code (for which we always skip
+      the body), this will hold when the body was present in the original code.
+    """) | rust.detach
 
 
 @annotate(ConstArg)
@@ -1882,6 +1886,10 @@ class _:
 class _:
     param_list: drop
     attrs: drop
+    has_implementation: predicate | doc("this function has an implementation") | desc("""
+      This is the same as `hasBody` for source code, but for library code (for which we always skip
+      the body), this will hold when the body was present in the original code.
+    """) | rust.detach
 
 
 @annotate(ClosureExpr, add_bases=[Callable])