Revert D76614862 D75026944 D75498477 D75470326

Differential Revision: D76664263

fbshipit-source-id: 64ffb830f49c5acce2c0c9f00fe0068fa366bec0

Author: ricklavoie

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

@@ -26,7 +26,6 @@ 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;
@@ -322,7 +321,6 @@ 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()>
@@ -374,7 +372,6 @@ 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,
     };
@@ -480,7 +477,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 tparam_info = assemble_tparam_info(token_iter)?;
+    let shadowed_tparams = assemble_shadowed_tparams(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)?;
@@ -497,7 +494,7 @@ fn assemble_method(token_iter: &mut Lexer<'_>, adata: &AdataMap) -> Result<hhbc:
         attrs,
         params,
         return_type,
-        tparam_info,
+        shadowed_tparams,
         upper_bounds,
         span,
     )?;
@@ -513,28 +510,19 @@ fn assemble_method(token_iter: &mut Lexer<'_>, adata: &AdataMap) -> Result<hhbc:
     })
 }
 
-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_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 assemble_method_flags(token_iter: &mut Lexer<'_>) -> Result<hhbc::MethodFlags> {
@@ -1035,7 +1023,6 @@ 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)?;
@@ -1051,6 +1038,7 @@ 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,
@@ -1059,7 +1047,7 @@ fn assemble_function(token_iter: &mut Lexer<'_>, adata: &AdataMap) -> Result<hhb
         attrs,
         params,
         return_type,
-        tparam_info,
+        shadowed_tparams,
         upper_bounds,
         span,
     )?;
@@ -1115,15 +1103,6 @@ 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),*> ")");
@@ -1395,7 +1374,7 @@ fn assemble_body(
     attrs: hhbc::Attr,
     params: Vec<ParamEntry>,
     return_type: Maybe<hhbc::TypeInfo>,
-    tparam_info: Vec<TParamInfo>,
+    shadowed_tparams: Vec<ClassName>,
     upper_bounds: Vec<hhbc::UpperBound>,
     span: hhbc::Span,
 ) -> Result<hhbc::Body> {
@@ -1457,7 +1436,7 @@ fn assemble_body(
         is_memoize_wrapper_lsb,
         doc_comment,
         return_type,
-        tparam_info: tparam_info.into(),
+        shadowed_tparams: shadowed_tparams.into(),
         upper_bounds: upper_bounds.into(),
         span,
         repr: hhbc::BcRepr {

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

@@ -46,7 +46,6 @@ use hhbc::Span;
 use hhbc::SrcLoc;
 use hhbc::StringId;
 use hhbc::SymbolRefs;
-use hhbc::TParamInfo;
 use hhbc::TraitReqKind;
 use hhbc::TypeConstant;
 use hhbc::TypeInfo;
@@ -330,7 +329,6 @@ 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(
@@ -526,19 +524,11 @@ fn print_enum_includes(w: &mut dyn Write, enum_includes: &[ClassName]) -> Result
     write_bytes!(w, " enum_includes ({})", fmt_separated(" ", enum_includes))
 }
 
-fn print_tparam_info(w: &mut dyn Write, tparam_info: &[TParamInfo]) -> Result<()> {
-    if tparam_info.is_empty() {
-        return Ok(());
-    }
+fn print_shadowed_tparams(w: &mut dyn Write, shadowed_tparams: &[ClassName]) -> Result<()> {
     write_bytes!(
         w,
-        "<{}> ",
-        fmt_separated(
-            ",",
-            tparam_info
-                .iter()
-                .map(|t| { format!("[{} {}]", t.name.as_str(), t.shadows_class_tparam) })
-        )
+        "{{{}}}",
+        fmt_separated(", ", shadowed_tparams.iter().map(|s| s.as_str()))
     )
 }
 
@@ -551,7 +541,7 @@ fn print_method_def(
     let body = &method_def.body;
     newline(w)?;
     w.write_all(b"  .method ")?;
-    print_tparam_info(w, &body.tparam_info)?;
+    print_shadowed_tparams(w, &body.shadowed_tparams)?;
     print_upper_bounds_(w, &body.upper_bounds)?;
     w.write_all(b" ")?;
     print_special_and_user_attrs(
@@ -592,17 +582,6 @@ 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,
@@ -611,7 +590,6 @@ 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,7 +29,6 @@ use hhbc::Param;
 use hhbc::ParamEntry;
 use hhbc::Span;
 use hhbc::StringId;
-use hhbc::TParamInfo;
 use hhbc::TypeInfo;
 use hhbc::TypedValue;
 use hhbc::UpperBound;
@@ -116,7 +115,7 @@ pub fn emit_body<'b, 'd>(
         args.class_tparam_names,
         args.flags.contains(Flags::SKIP_AWAITABLE),
     );
-    let tparam_info = emit_tparam_info(args.immediate_tparams, args.class_tparam_names);
+    let shadowed_tparams = emit_shadowed_tparams(args.immediate_tparams, args.class_tparam_names);
     let decl_vars = make_decl_vars(
         emitter,
         &scope,
@@ -179,7 +178,7 @@ pub fn emit_body<'b, 'd>(
             false, // is_memoize_wrapper
             false, // is_memoize_wrapper_lsb
             upper_bounds,
-            tparam_info,
+            shadowed_tparams,
             attributes,
             attrs,
             coeffects,
@@ -389,7 +388,7 @@ pub fn make_body<'a, 'd>(
     is_memoize_wrapper: bool,
     is_memoize_wrapper_lsb: bool,
     upper_bounds: Vec<UpperBound>,
-    tparam_info: Vec<TParamInfo>,
+    shadowed_tparams: Vec<String>,
     attributes: Vec<Attribute>,
     attrs: Attr,
     coeffects: Coeffects,
@@ -454,7 +453,10 @@ pub fn make_body<'a, 'd>(
         is_memoize_wrapper,
         is_memoize_wrapper_lsb,
         upper_bounds: upper_bounds.into(),
-        tparam_info: tparam_info.into(),
+        shadowed_tparams: shadowed_tparams
+            .into_iter()
+            .map(|s| ClassName::intern(&s))
+            .collect(),
         return_type: return_type.into(),
         doc_comment: doc_comment
             .map(|(_, comment)| comment.into_bytes().into())
@@ -757,22 +759,18 @@ pub fn emit_generics_upper_bounds(
         .collect::<Vec<_>>()
 }
 
-fn emit_tparam_info(
+fn emit_shadowed_tparams(
     immediate_tparams: &[ast::Tparam],
     class_tparam_names: &[&str],
-) -> Vec<TParamInfo> {
-    let s1 = get_tp_names(immediate_tparams);
+) -> Vec<String> {
+    let s1 = get_tp_names_set(immediate_tparams);
     let s2: HashSet<&str> = class_tparam_names.iter().cloned().collect();
-    let r: Vec<TParamInfo> = s1
-        .iter()
-        .map(|name| {
-            let shadows_class_tparam = s2.contains(name);
-            TParamInfo {
-                name: ClassName::intern(name),
-                shadows_class_tparam,
-            }
-        })
-        .collect();
+    // TODO(hrust): remove sort after Rust emitter released
+    let mut r = s1
+        .intersection(&s2)
+        .map(|s| (*s).into())
+        .collect::<Vec<_>>();
+    r.sort();
     r
 }
 
@@ -792,6 +790,10 @@ 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![], // tparam_info
+        vec![], // shadowed_tparams
         vec![], // attributes
         attrs,
         coeffects,
@@ -816,7 +816,6 @@ 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![], /* tparam_info */
+            vec![], /* shadowed_params */
             vec![], /* attributes */
             attrs,
             Coeffects::default(),

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

@@ -12,7 +12,6 @@ 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;
@@ -24,7 +23,6 @@ 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;
@@ -83,14 +81,6 @@ 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));
@@ -138,7 +128,6 @@ pub(crate) fn emit_wrapper_function<'a, 'd>(
         decl_vars,
         instrs,
         Span::from_pos(&f.span),
-        tparam_info,
     )?;
 
     let mut flags = FunctionFlags::empty();
@@ -399,7 +388,6 @@ 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,
@@ -408,7 +396,7 @@ fn make_wrapper_body<'a, 'd>(
         true,   /* is_memoize_wrapper */
         false,  /* is_memoize_wrapper_lsb */
         vec![], /* upper_bounds */
-        tparam_info,
+        vec![], /* shadowed_tparams */
         attributes,
         Attr::AttrNone,
         coeffects,