Back out "Revert D76614862 D75026944 D75498477 D75470326" + fix

Summary:
Original commit changeset: 64ffb830f49c

Original Phabricator Diff: D76664263

S531313 was caused due to an error that was introduced in emit_memoize_method.rs in the original diff (D75026944): {F1979284836}

The tparams variable, which is used to identify the generics in the function's scope, was mistakenly updated to include only the generics defined on the function.

New changes on top of the backout of the revert:
1. hphp/hack/src/hackc/emitter/emit_memoize_function.rs
2. hphp/test/quick/memoize_generic.php  + expect

Reviewed By: jano

Differential Revision: D76681690

fbshipit-source-id: a26546e8342721d69e5dc4d97e74c6819f264483

Author: Niharika Devanathan

hphp/hack/src/hackc/assemble/assemble.rs

@@ -26,6 +26,7 @@ use hhbc::ModuleName;
 use hhbc::ParamEntry;
 use hhbc::StringId;
 use hhbc::StringIdMap;
+use hhbc::TParamInfo;
 use hhbc::TypedValue;
 use hhvm_types_ffi::Attr;
 use log::trace;
@@ -321,6 +322,7 @@ fn assemble_typedef(token_iter: &mut Lexer<'_>, case_type: bool) -> Result<hhbc:
 
 fn assemble_class(token_iter: &mut Lexer<'_>, adata: &AdataMap) -> Result<hhbc::Class> {
     parse!(token_iter, ".class"
+       <tparams:assemble_tparams()>
        <upper_bounds:assemble_upper_bounds()>
        <attr:assemble_special_and_user_attrs()>
        <name:assemble_class_name()>
@@ -372,6 +374,7 @@ fn assemble_class(token_iter: &mut Lexer<'_>, adata: &AdataMap) -> Result<hhbc::
         ctx_constants: ctx_constants.into(),
         requirements: requirements.into(),
         upper_bounds: upper_bounds.into(),
+        tparams: tparams.into(),
         doc_comment,
         flags,
     };
@@ -477,7 +480,7 @@ fn assemble_const_or_type_const(
 fn assemble_method(token_iter: &mut Lexer<'_>, adata: &AdataMap) -> Result<hhbc::Method> {
     let method_tok = token_iter.peek().copied();
     token_iter.expect_str(Token::is_decl, ".method")?;
-    let shadowed_tparams = assemble_shadowed_tparams(token_iter)?;
+    let tparam_info = assemble_tparam_info(token_iter)?;
     let upper_bounds = assemble_upper_bounds(token_iter)?;
     let (attrs, attributes) = assemble_special_and_user_attrs(token_iter)?;
     let span = assemble_span(token_iter)?;
@@ -494,7 +497,7 @@ fn assemble_method(token_iter: &mut Lexer<'_>, adata: &AdataMap) -> Result<hhbc:
         attrs,
         params,
         return_type,
-        shadowed_tparams,
+        tparam_info,
         upper_bounds,
         span,
     )?;
@@ -510,19 +513,28 @@ fn assemble_method(token_iter: &mut Lexer<'_>, adata: &AdataMap) -> Result<hhbc:
     })
 }
 
-fn assemble_shadowed_tparams(token_iter: &mut Lexer<'_>) -> Result<Vec<ClassName>> {
-    token_iter.expect(Token::is_open_curly)?;
-    let mut stp = Vec::new();
-    while token_iter.peek_is(Token::is_identifier) {
-        stp.push(ClassName::intern(
-            token_iter.expect(Token::is_identifier)?.as_str()?,
-        ));
-        if !token_iter.peek_is(Token::is_close_curly) {
-            token_iter.expect(Token::is_comma)?;
-        }
-    }
-    token_iter.expect(Token::is_close_curly)?;
-    Ok(stp)
+fn parse_bool(token_iter: &mut Lexer<'_>) -> Result<bool> {
+    let tok = token_iter.expect(Token::is_identifier)?;
+    let id = tok.as_str()?;
+    let b = id.parse()?;
+    Ok(b)
+}
+
+fn assemble_single_tparam_info(token_iter: &mut Lexer<'_>) -> Result<TParamInfo> {
+    parse!(token_iter, "[" <name:assemble_class_name()> <shadows_class_tparam:parse_bool> "]");
+    Ok(TParamInfo {
+        name,
+        shadows_class_tparam,
+    })
+}
+
+fn assemble_tparam_info(token_iter: &mut Lexer<'_>) -> Result<Vec<TParamInfo>> {
+    Ok(if token_iter.peek_is(Token::is_lt) {
+        parse!(token_iter, "<" <tparams:assemble_single_tparam_info(),*> ">");
+        tparams
+    } else {
+        Vec::new()
+    })
 }
 
 fn assemble_method_flags(token_iter: &mut Lexer<'_>) -> Result<hhbc::MethodFlags> {
@@ -1025,6 +1037,7 @@ where
 /// .function {upper bounds} [special_and_user_attrs] (span) <type_info> name (params) flags? {body}
 fn assemble_function(token_iter: &mut Lexer<'_>, adata: &AdataMap) -> Result<hhbc::Function> {
     token_iter.expect_str(Token::is_decl, ".function")?;
+    let tparam_info = assemble_tparam_info(token_iter)?;
     let upper_bounds = assemble_upper_bounds(token_iter)?;
     // Special and user attrs may or may not be specified. If not specified, no [] printed
     let (attrs, attributes) = assemble_special_and_user_attrs(token_iter)?;
@@ -1040,7 +1053,6 @@ fn assemble_function(token_iter: &mut Lexer<'_>, adata: &AdataMap) -> Result<hhb
     let mut decl_map = DeclMap::default();
     let params = assemble_params(token_iter, &mut decl_map)?;
     let flags = assemble_function_flags(name, token_iter)?;
-    let shadowed_tparams = Default::default();
     let body = assemble_body(
         token_iter,
         &mut decl_map,
@@ -1049,7 +1061,7 @@ fn assemble_function(token_iter: &mut Lexer<'_>, adata: &AdataMap) -> Result<hhb
         attrs,
         params,
         return_type,
-        shadowed_tparams,
+        tparam_info,
         upper_bounds,
         span,
     )?;
@@ -1105,6 +1117,15 @@ fn assemble_upper_bounds(token_iter: &mut Lexer<'_>) -> Result<Vec<hhbc::UpperBo
     Ok(ubs)
 }
 
+fn assemble_tparams(token_iter: &mut Lexer<'_>) -> Result<Vec<ClassName>> {
+    Ok(if token_iter.peek_is(Token::is_lt) {
+        parse!(token_iter, "<" <tparams:assemble_class_name(),*> ">");
+        tparams
+    } else {
+        Vec::new()
+    })
+}
+
 /// Ex: (T as <"HH\\int" "HH\\int" upper_bound>)
 fn assemble_upper_bound(token_iter: &mut Lexer<'_>) -> Result<hhbc::UpperBound> {
     parse!(token_iter, "(" <id:id> "as" <tis:assemble_type_info(TypeInfoKind::NotEnumOrTypeDef),*> ")");
@@ -1376,7 +1397,7 @@ fn assemble_body(
     attrs: hhbc::Attr,
     params: Vec<ParamEntry>,
     return_type: Maybe<hhbc::TypeInfo>,
-    shadowed_tparams: Vec<ClassName>,
+    tparam_info: Vec<TParamInfo>,
     upper_bounds: Vec<hhbc::UpperBound>,
     span: hhbc::Span,
 ) -> Result<hhbc::Body> {
@@ -1438,7 +1459,7 @@ fn assemble_body(
         is_memoize_wrapper_lsb,
         doc_comment,
         return_type,
-        shadowed_tparams: shadowed_tparams.into(),
+        tparam_info: tparam_info.into(),
         upper_bounds: upper_bounds.into(),
         span,
         repr: hhbc::BcRepr {

hphp/hack/src/hackc/bytecode_printer/print.rs

@@ -46,6 +46,7 @@ use hhbc::Span;
 use hhbc::SrcLoc;
 use hhbc::StringId;
 use hhbc::SymbolRefs;
+use hhbc::TParamInfo;
 use hhbc::TraitReqKind;
 use hhbc::TypeConstant;
 use hhbc::TypeInfo;
@@ -329,6 +330,7 @@ fn print_fun_def(
     let body = &fun_def.body;
     newline(w)?;
     w.write_all(b".function ")?;
+    print_tparam_info(w, &body.tparam_info)?;
     print_upper_bounds_(w, &body.upper_bounds)?;
     w.write_all(b" ")?;
     print_special_and_user_attrs(
@@ -524,11 +526,19 @@ fn print_enum_includes(w: &mut dyn Write, enum_includes: &[ClassName]) -> Result
     write_bytes!(w, " enum_includes ({})", fmt_separated(" ", enum_includes))
 }
 
-fn print_shadowed_tparams(w: &mut dyn Write, shadowed_tparams: &[ClassName]) -> Result<()> {
+fn print_tparam_info(w: &mut dyn Write, tparam_info: &[TParamInfo]) -> Result<()> {
+    if tparam_info.is_empty() {
+        return Ok(());
+    }
     write_bytes!(
         w,
-        "{{{}}}",
-        fmt_separated(", ", shadowed_tparams.iter().map(|s| s.as_str()))
+        "<{}> ",
+        fmt_separated(
+            ",",
+            tparam_info
+                .iter()
+                .map(|t| { format!("[{} {}]", t.name.as_str(), t.shadows_class_tparam) })
+        )
     )
 }
 
@@ -541,7 +551,7 @@ fn print_method_def(
     let body = &method_def.body;
     newline(w)?;
     w.write_all(b"  .method ")?;
-    print_shadowed_tparams(w, &body.shadowed_tparams)?;
+    print_tparam_info(w, &body.tparam_info)?;
     print_upper_bounds_(w, &body.upper_bounds)?;
     w.write_all(b" ")?;
     print_special_and_user_attrs(
@@ -582,6 +592,17 @@ fn print_method_def(
     })
 }
 
+fn print_tparams(w: &mut dyn Write, tparams: &[ClassName]) -> Result<()> {
+    if tparams.is_empty() {
+        return Ok(());
+    }
+    write_bytes!(
+        w,
+        "<{}> ",
+        fmt_separated(",", tparams.iter().map(|s| s.as_str()))
+    )
+}
+
 fn print_class_def(
     ctx: &Context<'_>,
     w: &mut dyn Write,
@@ -590,6 +611,7 @@ fn print_class_def(
 ) -> Result<()> {
     newline(w)?;
     w.write_all(b".class ")?;
+    print_tparams(w, class_def.tparams.as_ref())?;
     print_upper_bounds(w, class_def.upper_bounds.as_ref())?;
     w.write_all(b" ")?;
     print_special_and_user_attrs(

hphp/hack/src/hackc/emitter/emit_body.rs

@@ -29,6 +29,7 @@ use hhbc::Param;
 use hhbc::ParamEntry;
 use hhbc::Span;
 use hhbc::StringId;
+use hhbc::TParamInfo;
 use hhbc::TypeInfo;
 use hhbc::TypedValue;
 use hhbc::UpperBound;
@@ -115,7 +116,7 @@ pub fn emit_body<'b, 'd>(
         args.class_tparam_names,
         args.flags.contains(Flags::SKIP_AWAITABLE),
     );
-    let shadowed_tparams = emit_shadowed_tparams(args.immediate_tparams, args.class_tparam_names);
+    let tparam_info = emit_tparam_info(args.immediate_tparams, args.class_tparam_names);
     let decl_vars = make_decl_vars(
         emitter,
         &scope,
@@ -178,7 +179,7 @@ pub fn emit_body<'b, 'd>(
             false, // is_memoize_wrapper
             false, // is_memoize_wrapper_lsb
             upper_bounds,
-            shadowed_tparams,
+            tparam_info,
             attributes,
             attrs,
             coeffects,
@@ -388,7 +389,7 @@ pub fn make_body<'a, 'd>(
     is_memoize_wrapper: bool,
     is_memoize_wrapper_lsb: bool,
     upper_bounds: Vec<UpperBound>,
-    shadowed_tparams: Vec<String>,
+    tparam_info: Vec<TParamInfo>,
     attributes: Vec<Attribute>,
     attrs: Attr,
     coeffects: Coeffects,
@@ -453,10 +454,7 @@ pub fn make_body<'a, 'd>(
         is_memoize_wrapper,
         is_memoize_wrapper_lsb,
         upper_bounds: upper_bounds.into(),
-        shadowed_tparams: shadowed_tparams
-            .into_iter()
-            .map(|s| ClassName::intern(&s))
-            .collect(),
+        tparam_info: tparam_info.into(),
         return_type: return_type.into(),
         doc_comment: doc_comment
             .map(|(_, comment)| comment.into_bytes().into())
@@ -759,18 +757,22 @@ pub fn emit_generics_upper_bounds(
         .collect::<Vec<_>>()
 }
 
-fn emit_shadowed_tparams(
+fn emit_tparam_info(
     immediate_tparams: &[ast::Tparam],
     class_tparam_names: &[&str],
-) -> Vec<String> {
-    let s1 = get_tp_names_set(immediate_tparams);
+) -> Vec<TParamInfo> {
+    let s1 = get_tp_names(immediate_tparams);
     let s2: HashSet<&str> = class_tparam_names.iter().cloned().collect();
-    // TODO(hrust): remove sort after Rust emitter released
-    let mut r = s1
-        .intersection(&s2)
-        .map(|s| (*s).into())
-        .collect::<Vec<_>>();
-    r.sort();
+    let r: Vec<TParamInfo> = s1
+        .iter()
+        .map(|name| {
+            let shadows_class_tparam = s2.contains(name);
+            TParamInfo {
+                name: ClassName::intern(name),
+                shadows_class_tparam,
+            }
+        })
+        .collect();
     r
 }
 
@@ -790,10 +792,6 @@ pub fn get_tp_names(tparams: &[ast::Tparam]) -> Vec<&str> {
     tparams.iter().map(get_tp_name).collect()
 }
 
-pub fn get_tp_names_set(tparams: &[ast::Tparam]) -> HashSet<&str> {
-    tparams.iter().map(get_tp_name).collect()
-}
-
 fn modify_prog_for_debugger_eval(_: &mut InstrSeq) {
     unimplemented!() // SF(2021-03-17): I found it like this.
 }

hphp/hack/src/hackc/emitter/emit_class.rs

@@ -116,7 +116,7 @@ fn make_86method<'d>(
         method_is_memoize_wrapper,
         method_is_memoize_wrapper_lsb,
         vec![], // upper_bounds
-        vec![], // shadowed_tparams
+        vec![], // tparam_info
         vec![], // attributes
         attrs,
         coeffects,
@@ -816,6 +816,7 @@ pub fn emit_class<'a, 'd>(emitter: &mut Emitter<'d>, ast_class: &'a ast::Class_)
         methods: methods.into(),
         enum_type: Maybe::from(enum_type),
         upper_bounds: upper_bounds.into(),
+        tparams: tparams.into_iter().map(ClassName::intern).collect(),
         properties: Vec::from_iter(properties.into_iter().map(|p| p.prop)).into(),
         requirements: requirements.into(),
         type_constants: type_constants.into(),

hphp/hack/src/hackc/emitter/emit_constant.rs

@@ -62,7 +62,7 @@ fn emit_constant_cinit<'a, 'd>(
             false,  /* is_memoize_wrapper */
             false,  /* is_memoize_wrapper_lsb */
             vec![], /* upper_bounds */
-            vec![], /* shadowed_params */
+            vec![], /* tparam_info */
             vec![], /* attributes */
             attrs,
             Coeffects::default(),

hphp/hack/src/hackc/emitter/emit_memoize_function.rs

@@ -12,6 +12,7 @@ use env::emitter::Emitter;
 use error::Result;
 use hhbc::Attribute;
 use hhbc::Body;
+use hhbc::ClassName;
 use hhbc::Coeffects;
 use hhbc::FCallArgs;
 use hhbc::FCallArgsFlags;
@@ -23,6 +24,7 @@ use hhbc::LocalRange;
 use hhbc::Param;
 use hhbc::Span;
 use hhbc::StringId;
+use hhbc::TParamInfo;
 use hhbc::TypeInfo;
 use hhbc::TypedValue;
 use hhbc_string_utils::reified;
@@ -81,6 +83,14 @@ pub(crate) fn emit_wrapper_function<'a, 'd>(
         .iter()
         .map(|tp| tp.name.1.as_str())
         .collect::<Vec<_>>();
+    let tparam_info = fd
+        .tparams
+        .iter()
+        .map(|s| TParamInfo {
+            name: ClassName::intern(s.name.1.as_str()),
+            shadows_class_tparam: false,
+        })
+        .collect::<Vec<_>>();
     let params = emit_param::from_asts(emitter, &mut tparams, true, &scope, &f.params)?;
     let mut attributes = emit_attribute::from_asts(emitter, &f.user_attributes)?;
     attributes.extend(emit_attribute::add_reified_attribute(&fd.tparams));
@@ -128,6 +138,7 @@ pub(crate) fn emit_wrapper_function<'a, 'd>(
         decl_vars,
         instrs,
         Span::from_pos(&f.span),
+        tparam_info,
     )?;
 
     let mut flags = FunctionFlags::empty();
@@ -388,6 +399,7 @@ fn make_wrapper_body<'a, 'd>(
     decl_vars: Vec<StringId>,
     instrs: InstrSeq,
     span: Span,
+    tparam_info: Vec<TParamInfo>,
 ) -> Result<Body> {
     emit_body::make_body(
         emitter,
@@ -396,7 +408,7 @@ fn make_wrapper_body<'a, 'd>(
         true,   /* is_memoize_wrapper */
         false,  /* is_memoize_wrapper_lsb */
         vec![], /* upper_bounds */
-        vec![], /* shadowed_tparams */
+        tparam_info,
         attributes,
         Attr::AttrNone,
         coeffects,