Include Const values in decl output (gated with flag)

Summary:
Added an option to also include const values (including enums) in the output of ext_decl.

* For literals, it outputs a normalize form (null, false, true, numbers and a single quoted string).
* For all complex initializers it simply slices the source text and trims it

Reviewed By: nt591

Differential Revision: D52605538

fbshipit-source-id: 71771515efa535b0fec29d853a875fb8d313c845

Author: metaduv

hphp/hack/hhi/ext_decl.hhi

@@ -85,6 +85,7 @@ namespace HH {
   type ExtDeclFileConst = shape(
     'name' => string,
     'type' => TypeExpr,
+    ?'value' => string,
   );
 
   type ExtDeclModule = shape(
@@ -125,6 +126,7 @@ namespace HH {
     'name' => string,
     'type' => TypeExpr,
     ?'is_abstract' => bool,
+    ?'value' => string,
   );
 
   // https://github.com/facebook/hhvm/issues/5594

hphp/hack/src/decl/decl_pos_utils.ml

@@ -383,6 +383,7 @@ struct
       scc_name = positioned_id scc.scc_name;
       scc_type = ty scc.scc_type;
       scc_refs = scc.scc_refs;
+      scc_value = scc.scc_value;
     }
 
   and shallow_typeconst stc =

hphp/hack/src/decl/direct_decl_smart_constructors.rs

@@ -1376,6 +1376,47 @@ impl<'a, 'o, 't, S: SourceTextAllocator<'t, 'a>> DirectDeclSmartConstructors<'a,
         Some(self.alloc(aast::Expr((), pos, expr_)))
     }
 
+    fn node_to_str(&self, node: Node<'a>, semicolon: Node<'a>) -> &'a str {
+        let expr = self.node_to_expr(node);
+        match expr {
+            // Only some nodes have a simple translate to an expression
+            // Since some nodes *are* expressions, we prefer to write the
+            // to_string logic once for expressions
+            Some(expr) => self.expr_to_str(expr),
+
+            // This is usually complex shapes / vec / dict etc. and the
+            // actual value is NOT in the nodes so we have to yank the text
+            None => self
+                .str_from_utf8(self.source_text_at_pos(Pos::from_lnum_bol_offset(
+                    self.arena,
+                    self.filename,
+                    self.get_pos(node).to_start_and_end_lnum_bol_offset().1,
+                    self.get_pos(semicolon).to_start_and_end_lnum_bol_offset().0,
+                )))
+                .trim(),
+        }
+    }
+
+    fn expr_to_str(&self, expr: &aast::Expr<'a, (), ()>) -> &'a str {
+        match expr.2 {
+            // Simple literals (99% of the cases)
+            aast::Expr_::Int(s) => s,
+            aast::Expr_::Float(s) => s,
+            aast::Expr_::String(s) => {
+                // Always use single quotes for strings
+                bumpalo::format!(in self.arena, "'{}'", s).into_bump_str()
+            }
+            aast::Expr_::True => "true",
+            aast::Expr_::False => "false",
+            aast::Expr_::Null => "null",
+
+            // Default to actual text
+            // ... VariableExpression, BinaryExpression, SubscriptExpression,
+            //     FunctionCallExpression, ConditionalExpression ...
+            _ => self.str_from_utf8(self.source_text_at_pos(expr.1)),
+        }
+    }
+
     fn node_to_non_ret_ty(&self, node: Node<'a>) -> Option<&'a Ty<'a>> {
         self.node_to_ty_(node, false)
     }
@@ -3947,12 +3988,18 @@ impl<'a, 'o, 't, S: SourceTextAllocator<'t, 'a>> FlattenSmartConstructors
                             let ty = ty
                                 .or_else(|| self.infer_const(name, initializer))
                                 .unwrap_or(TANY);
+
                             Some(Node::Const(self.alloc(
                                 shallow_decl_defs::ShallowClassConst {
                                     abstract_,
                                     name: id.into(),
                                     type_: ty,
                                     refs,
+                                    value: if self.opts.include_assignment_values {
+                                        Some(self.node_to_str(initializer, semicolon))
+                                    } else {
+                                        None
+                                    },
                                 },
                             )))
                         }
@@ -3978,8 +4025,18 @@ impl<'a, 'o, 't, S: SourceTextAllocator<'t, 'a>> FlattenSmartConstructors
                                     .node_to_ty(hint)
                                     .or_else(|| self.infer_const(name, initializer))
                                     .unwrap_or_else(|| self.tany_with_pos(id_pos));
+
+                                let const_decl = ConstDecl {
+                                    pos,
+                                    type_: ty,
+                                    value: if self.opts.include_assignment_values {
+                                        Some(self.node_to_str(initializer, semicolon))
+                                    } else {
+                                        None
+                                    },
+                                };
                                 let this = Rc::make_mut(&mut self.state);
-                                this.add_const(id, this.alloc(ConstDecl { pos, type_: ty }));
+                                this.add_const(id, this.alloc(const_decl));
                             }
                         }
                         _ => {}
@@ -4972,7 +5029,7 @@ impl<'a, 'o, 't, S: SourceTextAllocator<'t, 'a>> FlattenSmartConstructors
         name: Self::Output,
         _equal: Self::Output,
         value: Self::Output,
-        _semicolon: Self::Output,
+        semicolon: Self::Output,
     ) -> Self::Output {
         let refs = self.stop_accumulating_const_refs();
         let id = match self.expect_name(name) {
@@ -4988,6 +5045,11 @@ impl<'a, 'o, 't, S: SourceTextAllocator<'t, 'a>> FlattenSmartConstructors
                     .infer_const(name, value)
                     .unwrap_or_else(|| self.tany_with_pos(id.0)),
                 refs,
+                value: if self.opts.include_assignment_values {
+                    Some(self.node_to_str(value, semicolon))
+                } else {
+                    None
+                },
             }),
         )
     }
@@ -5160,8 +5222,8 @@ impl<'a, 'o, 't, S: SourceTextAllocator<'t, 'a>> FlattenSmartConstructors
         modifiers: Self::Output,
         type_: Self::Output,
         name: Self::Output,
-        _initializer: Self::Output,
-        _semicolon: Self::Output,
+        initializer: Self::Output,
+        semicolon: Self::Output,
     ) -> Self::Output {
         let refs = self.stop_accumulating_const_refs();
         let name = match self.expect_name(name) {
@@ -5203,6 +5265,11 @@ impl<'a, 'o, 't, S: SourceTextAllocator<'t, 'a>> FlattenSmartConstructors
             name: name.into(),
             type_,
             refs,
+            value: if self.opts.include_assignment_values {
+                Some(self.node_to_str(initializer, semicolon))
+            } else {
+                None
+            },
         }))
     }
 

hphp/hack/src/decl/shallow_decl_defs.ml

@@ -182,6 +182,9 @@ type shallow_class_const = {
       (** This is a list of all scope-resolution operators "A::B" that are mentioned in the const initializer,
       for members of regular-enums and enum-class-enums to detect circularity of initializers.
       We don't yet have a similar mechanism for top-level const initializers. *)
+  scc_value: string option;
+      (** If DeclParserConfig option include_assignment_values is true,
+      The string value for the constant *)
 }
 [@@deriving eq, show]
 

hphp/hack/src/decl/shallow_decl_defs.mli

@@ -83,6 +83,7 @@ type shallow_class_const = {
   scc_name: Typing_defs.pos_id;
   scc_type: decl_ty;
   scc_refs: Typing_defs.class_const_ref list;
+  scc_value: string option;
 }
 [@@deriving eq, show]
 

hphp/hack/src/hackc/ffi_bridge/compiler_ffi.rs

@@ -109,6 +109,7 @@ mod ffi {
         enable_xhp_class_modifier: bool,
         php5_compat_mode: bool,
         hhvm_compat_mode: bool,
+        include_assignment_values: bool,
     }
 
     pub struct DeclsAndBlob {
@@ -247,13 +248,15 @@ mod ffi {
     pub struct ExtDeclFileConst {
         name: String,
         type_: String,
+        value: String,
     }
 
     #[derive(Debug, PartialEq)]
     pub struct ExtDeclClassConst {
         name: String,
         type_: String,
         is_abstract: bool,
+        value: String,
     }
     pub struct ExtDeclClassConstVec {
         pub vec: Vec<ExtDeclClassConst>,
@@ -713,6 +716,7 @@ pub fn parse_decls(
         enable_xhp_class_modifier: config.enable_xhp_class_modifier,
         php5_compat_mode: config.php5_compat_mode,
         hhvm_compat_mode: config.hhvm_compat_mode,
+        include_assignment_values: config.include_assignment_values,
         keep_user_attributes: true,
         ..Default::default()
     };

hphp/hack/src/hackc/ffi_bridge/ext_decl.rs

@@ -76,6 +76,7 @@ pub fn get_file_consts(parsed_file: &ParsedFile<'_>, name: &str) -> Vec<ExtDeclF
         .map(|(cname, decl)| ExtDeclFileConst {
             name: fmt_type(cname),
             type_: extract_type_name(decl.type_),
+            value: str_or_empty(decl.value),
         })
         .collect()
 }
@@ -399,6 +400,7 @@ fn get_consts(consts: &[&ShallowClassConst<'_>], name: &str) -> Vec<ExtDeclClass
             name: fmt_type(c.name.1),
             type_: extract_type_name(c.type_),
             is_abstract: c.abstract_ != ClassConstKind::CCConcrete,
+            value: str_or_empty(c.value),
         })
         .collect()
 }

hphp/hack/src/hackrs/ty/decl/from_oxidized.rs

@@ -356,6 +356,7 @@ impl<R: Reason> From<&obr::shallow_decl_defs::ShallowClassConst<'_>>
             name: scc.name.into(),
             ty: scc.type_.into(),
             refs: slice(scc.refs),
+            value: scc.value.map(Into::into),
         }
     }
 }
@@ -513,6 +514,7 @@ impl<R: Reason> From<&obr::shallow_decl_defs::ConstDecl<'_>> for shallow::ConstD
         Self {
             pos: x.pos.into(),
             ty: x.type_.into(),
+            value: x.value.map(Into::into),
         }
     }
 }

hphp/hack/src/hackrs/ty/decl/shallow.rs

@@ -67,6 +67,10 @@ pub struct ShallowClassConst<R: Reason> {
     /// to detect circularity of initializers. We don't yet have a similar mechanism
     /// for top-level const initializers.
     pub refs: Box<[ClassConstRef]>,
+
+    /// If DeclParserConfig option include_assignment_values is true,
+    /// The string value for the constant
+    pub value: Option<String>,
 }
 
 walkable!(ShallowClassConst<R> => [ty]);

hphp/hack/src/hackrs/ty/decl/to_oxidized.rs

@@ -654,12 +654,14 @@ impl<'a, R: Reason> ToOxidized<'a> for shallow::ShallowClassConst<R> {
             name,
             ty,
             refs,
+            value,
         } = self;
         arena.alloc(obr::shallow_decl_defs::ShallowClassConst {
             abstract_: *kind,
             name: name.to_oxidized(arena),
             type_: ty.to_oxidized(arena),
             refs: refs.to_oxidized(arena),
+            value: value.as_deref().to_oxidized(arena),
         })
     }
 }
@@ -839,10 +841,11 @@ impl<'a, R: Reason> ToOxidized<'a> for shallow::ConstDecl<R> {
     type Output = &'a obr::shallow_decl_defs::ConstDecl<'a>;
 
     fn to_oxidized(&self, arena: &'a bumpalo::Bump) -> Self::Output {
-        let Self { pos, ty } = self;
+        let Self { pos, ty, value } = self;
         arena.alloc(obr::shallow_decl_defs::ConstDecl {
             pos: pos.to_oxidized(arena),
             type_: ty.to_oxidized(arena),
+            value: value.as_deref().to_oxidized(arena),
         })
     }
 }