Add Constant type/value properties

Cargo.toml

@@ -13,6 +13,7 @@ readme = "./README.md"
 [dependencies]
 trustfall = "0.6.0"
 rustdoc-types = "0.22.0"
+serde_json = "1.0.85"
 
 [dev-dependencies]
 anyhow = "1.0.58"

src/adapter/mod.rs

@@ -141,6 +141,7 @@ impl<'a> Adapter<'a> for RustdocAdapter<'a> {
                 "AssociatedConstant" => {
                     properties::resolve_associated_constant_property(contexts, property_name)
                 }
+                "Constant" => properties::resolve_constant_property(contexts, property_name),
                 _ => unreachable!("resolve_property {type_name} {property_name}"),
             }
         }

src/adapter/properties.rs

@@ -462,6 +462,80 @@ pub(crate) fn resolve_associated_constant_property<'a>(
                 default.clone().into()
             }),
         ),
+        "type_" => resolve_property_with(
+            contexts,
+            field_property!(as_item, inner, {
+                let ItemEnum::AssocConst { type_, .. } = &inner else {
+                    unreachable!("expected to have a AssocConst")
+                };
+                // type_.clone().into() // Type→FieldValue not implemented, use ↓ json
+                serde_json::to_string(&type_.clone()).unwrap().into()
+            }),
+        ),
         _ => unreachable!("AssociatedConstant property {property_name}"),
     }
 }
+
+// const example from rustdocs
+// {"id"           	:"0:9:xx","crate_id":0,
+// "name"          	:"PUB_CONST_NAME",
+// "span"          	:{"filename":"","begin":[5,0],"end":[5,68]},
+// "visibility"    	:"public",
+// "docs"          	:null,
+// "links"         	:{},
+// "attrs"         	:[],
+// "deprecation"   	: null,
+// "inner"         	: { ← &inner will be set to ItemEnum::Constant(c), where c=struct rustdoc_types::Constant
+//   "constant"    	: { rustdoc_types::Constant has type_/expr/value/is_literal fields (docs.rs/rustdoc-types/latest/rustdoc_types/struct.Constant.html)
+//     "type"      	:{"primitive":"i32"}, or ↓ or any of docs.rs/rustdoc-types/latest/rustdoc_types/enum.Type.html
+//     "type"      	:{"borrowed_ref":{"lifetime": "'static","mutable": false,"type":{"primitive": "str"}}},
+//     "type"      	:{"resolved_path":{"name":"Years","id": "0:3:1633","args":{"angle_bracketed":{"args":[],"bindings":[]}}}},
+//     "expr"      	: "_",
+//     "value"     	: null,
+//     "is_literal"	: false}}
+// },
+pub(crate) fn resolve_constant_property<'a>(
+    contexts: ContextIterator<'a, Vertex<'a>>,
+    property_name: &str,
+) -> ContextOutcomeIterator<'a, Vertex<'a>, FieldValue> {
+    match property_name {
+        "type_" => resolve_property_with(
+            contexts,
+            field_property!(as_item, inner, {
+                let ItemEnum::Constant(c) = &inner else {
+                    unreachable!("expected to have a Constant")
+                };
+                // c.type_     .clone().into()}),), // Type→FieldValue not implemented, use ↓ json
+                serde_json::to_string(&c.type_.clone()).unwrap().into()
+            }),
+        ),
+        "expr" => resolve_property_with(
+            contexts,
+            field_property!(as_item, inner, {
+                let ItemEnum::Constant(c) = &inner else {
+                    unreachable!("expected to have a Constant")
+                };
+                c.expr.clone().into()
+            }),
+        ),
+        "value" => resolve_property_with(
+            contexts,
+            field_property!(as_item, inner, {
+                let ItemEnum::Constant(c) = &inner else {
+                    unreachable!("expected to have a Constant")
+                };
+                c.value.clone().into()
+            }),
+        ),
+        "is_literal" => resolve_property_with(
+            contexts,
+            field_property!(as_item, inner, {
+                let ItemEnum::Constant(c) = &inner else {
+                    unreachable!("expected to have a Constant")
+                };
+                c.is_literal.into()
+            }),
+        ),
+        _ => unreachable!("Constant property {property_name}"),
+    }
+}

src/rustdoc_schema.graphql

@@ -695,6 +695,72 @@ type Constant implements Item & Importable & GlobalValue {
   attrs: [String!]!
   visibility_limit: String!
 
+  # properties for Constant
+  """
+  A type represented in the "raw" rustdoc JSON representation (see `interface RawType`)<br>
+  Currently serialized as a serde_json String instead of a proper RawType
+  ```rust
+  //                               // rustdocs type field
+  const MIN   : usize = 16       ; // {"primitive":"usize"}
+  const LOG_AS: &str  = "batch"  ; // {"borrowed_ref":{"lifetime":null,"mutable":false,"type":{"primitive":"str"}}}
+  const YEAR  : Years = Years(42); // {"resolved_path":{"name":"Years","id":"0:3:1633","args":{"angle_bracketed":{"args":[],"bindings":[]}}}}
+  ```
+  """
+  type_: String
+  """
+  The expression of the constant, if any, as a Rust literal or `"_"`. For example:
+  ```rust
+  //                                 // expr
+  const MIN     : usize = 16       ; // 16
+  const MIN_SIZE: usize = MIN      ; // "MIN", referring to the other constant's name
+  const LOG_AS  : &str  = "batch"  ; // "\"batch\"", including escaped quotes
+  const YEAR    : Years = Years(42); // "_"
+  const EXPR_2_2: i32   = 2 + 2    ; // "_"
+  const FN_FIVE : i32   = five()   ; // "_"
+  const fn five() -> i32 { 5 };
+  struct Years(i32);
+  ```
+  If the constant is set:
+
+    - to be equal to another constant, `expr` holds the name of that other constant.
+    - by evaluating a `const` expression, such as `2 + 2` or a `const fn` call, `expr` is `"_"` instead of including the full expression.
+  """
+  expr: String
+  """
+  The value of the constant, if any, as a Rust literal. For example:
+  ```rust
+  //                                 // value
+  const MIN     : usize = 16       ; // "16usize"
+  const MIN_SIZE: usize = MIN      ; // "16usize"
+  const LOG_AS  : &str  = "batch"  ; // None
+  const YEAR    : Years = Years(42); // None
+  const EXPR_2_2: i32   = 2 + 2    ; // "4i32"
+  const FN_FIVE : i32   = five()   ; // "5i32"
+  const fn five() -> i32 { 5 };
+  struct Years(i32);
+  ```
+  If the  If the constant is set:
+
+    - to be equal to another constant, `value` holds the value of that other constant.
+    - by evaluating a `const` expression, such as `2 + 2` or a `const fn` call, `value` is evaluated
+  """
+  value: String
+  """
+  The literal flag of the constant. For example:
+  ```rust
+  //                                 // is_literal
+  const MIN     : usize = 16       ; // true
+  const MIN_SIZE: usize = MIN      ; // false
+  const LOG_AS  : &str  = "batch"  ; // true
+  const YEAR    : Years = Years(42); // false
+  const EXPR_2_2: i32   = 2 + 2    ; // false
+  const FN_FIVE : i32   = five()   ; // false
+  const fn five() -> i32 { 5 };
+  struct Years(i32);
+  ```
+  """
+  is_literal: Boolean
+
   # edges from Item
   span: Span
   attribute: [Attribute!]
@@ -878,25 +944,45 @@ type AssociatedConstant implements Item {
 
   # properties for AssociatedConstant
   """
+  A type represented in the "raw" rustdoc JSON representation (see `interface RawType`)<br>
+  Currently serialized as a serde_json String instead of a proper RawType
+  ```rust
+  const fn five() -> i32 { 5 };
+  struct Years(i32);
+  trait BatchIterator<const MIN: usize> {	    // rustdocs type field
+    const MIN     : usize        = 16       ; // {"primitive":"usize"}
+    const MIN_SIZE: usize        = MIN      ; // {"primitive":"usize"}
+    const LOG_AS  : &'static str = "batch"  ; // {"borrowed_ref":{"lifetime":null,"mutable":false,"type":{"primitive":"str"}}}
+    const YEAR    : Years        = Years(42); // {"resolved_path":{"name":"Years","id":"0:3:1633","args":{"angle_bracketed":{"args":[],"bindings":[]}}}}
+    const EXPR2_2 : i32          = 2+2      ; // {"primitive":"i32"}
+    const FN_FIVE : i32          = five()   ; // {"primitive":"i32"}
+  }
+  ```
+  """
+  type_: String
+  """
   The default value of the constant, if any, as a Rust literal, expression, or `"_"`.
 
   For example:
   ```rust
-  trait BatchIterator<const MIN: usize> {
-    const SIZE: usize = 16;  // `"16"` is the default
-    const LOG_AS: &'static str = "batch";  // `"\"batch\""` is the default, including escaped quotes
-    const MIN_SIZE: usize = MIN;  // "MIN" is the default, referring to the other constant's name
+  const fn five() -> i32 { 5 };
+  struct Years(i32);
+  trait BatchIterator<const MIN: usize> {	    // rustdocs default field
+    const MIN     : usize        = 16       ; // `"16"`
+    const MIN_SIZE: usize        = MIN      ; // `"MIN"`, referring to the other constant's name
+    const LOG_AS  : &'static str = "batch"  ; // `"\"batch\""`, including escaped quotes
+    const EXPR2_2 : i32          = 2+2      ; // `"_"`
+    const FN_FIVE : i32          = five()   ; // `"_"`
+    const YEAR    : Years        = Years(42); // `"_"`
   }
   ```
 
-  If the associated constant is on a type's inherent impl, the default is always required to be set.
+  If the associated constant is on a type's inherent impl, `default` is always required to be set.
 
-  If the associated constant is set to be equal to another constant, the default holds the name
-  of that other constant.
+  If the associated constant is set
 
-  If the associated constant is set by evaluating a `const` expression, such as `2 + 2` or
-  a `const fn` call, rustdoc's current behavior is to show a default value of `"_"`
-  instead of evaluating the constant value or including the full expression.
+    - to be equal to another constant, `default` holds the name of that other constant.
+    - by evaluating a `const` expression, such as `2 + 2` or a `const fn` call, `default` is `"_"` instead of evaluating the constant value or including the full expression.
   """
   default: String