Bump facebook/hhvm version to latest

src/analyzer/expression_analyzer.rs

@@ -39,7 +39,6 @@ use hakana_type::{
     get_bool, get_false, get_float, get_int, get_literal_int, get_literal_string, get_mixed_any,
     get_null, get_true, wrap_atomic,
 };
-use oxidized::ast::Field;
 use oxidized::pos::Pos;
 use oxidized::{aast, ast_defs};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -142,9 +141,9 @@ pub(crate) fn analyze(
             as_analyzer::analyze(
                 statements_analyzer,
                 expr.pos(),
-                &boxed.0,
-                &boxed.1,
-                boxed.2,
+                &boxed.expr,
+                &boxed.hint,
+                boxed.is_nullable,
                 analysis_data,
                 context,
                 if_body_context,
@@ -502,32 +501,6 @@ pub(crate) fn analyze(
                 );
             }
         }
-        aast::Expr_::Darray(boxed) => {
-            let fields = boxed
-                .1
-                .iter()
-                .map(|(key_expr, value_expr)| Field(key_expr.clone(), value_expr.clone()))
-                .collect::<Vec<_>>();
-
-            collection_analyzer::analyze_keyvals(
-                statements_analyzer,
-                &oxidized::tast::KvcKind::Dict,
-                &fields,
-                expr.pos(),
-                analysis_data,
-                context,
-            )?;
-        }
-        aast::Expr_::Varray(boxed) => {
-            collection_analyzer::analyze_vals(
-                statements_analyzer,
-                &oxidized::tast::VcKind::Vec,
-                &boxed.1,
-                expr.pos(),
-                analysis_data,
-                context,
-            )?;
-        }
         aast::Expr_::ValCollection(boxed) => {
             collection_analyzer::analyze_vals(
                 statements_analyzer,

src/analyzer/stmt/control_analyzer.rs

@@ -466,7 +466,6 @@ pub(crate) fn get_control_actions(
             aast::Stmt_::Using(_) => {}
             aast::Stmt_::Noop => {}
             aast::Stmt_::Markup(_) => {}
-            aast::Stmt_::AssertEnv(_) => {}
             aast::Stmt_::DeclareLocal(_) => {}
             aast::Stmt_::Match(_) => {}
         }

src/analyzer/stmt_analyzer.rs

@@ -219,7 +219,7 @@ pub(crate) fn analyze(
             }
         }
         aast::Stmt_::Fallthrough => {} // do nothing
-        aast::Stmt_::YieldBreak | aast::Stmt_::AssertEnv(_) | aast::Stmt_::Match(_) => {
+        aast::Stmt_::YieldBreak | aast::Stmt_::Match(_) => {
             //println!("{:#?}", stmt);
             analysis_data.maybe_add_issue(
                 Issue::new(

src/code_info_builder/simple_type_inferer.rs

@@ -205,53 +205,6 @@ pub fn infer(
             None
         }
         aast::Expr_::Eif(_) => None,
-        aast::Expr_::Darray(boxed) => {
-            let mut known_items = BTreeMap::new();
-
-            for (key_expr, value_expr) in &boxed.1 {
-                if let aast::Expr_::String(key_value) = &key_expr.2 {
-                    let value_type = infer(value_expr, resolved_names);
-
-                    if let Some(value_type) = value_type {
-                        known_items.insert(
-                            DictKey::String(key_value.to_string()),
-                            (false, Arc::new(value_type)),
-                        );
-                    } else {
-                        return None;
-                    }
-                } else {
-                    return None;
-                }
-            }
-
-            Some(wrap_atomic(TAtomic::TDict {
-                non_empty: !known_items.is_empty(),
-                known_items: Some(known_items),
-                params: None,
-                shape_name: None,
-            }))
-        }
-        aast::Expr_::Varray(boxed) => {
-            let mut entries = BTreeMap::new();
-
-            for (i, entry_expr) in boxed.1.iter().enumerate() {
-                let entry_type = infer(entry_expr, resolved_names);
-
-                if let Some(entry_type) = entry_type {
-                    entries.insert(i, (false, entry_type));
-                } else {
-                    return None;
-                }
-            }
-
-            Some(wrap_atomic(TAtomic::TVec {
-                known_count: Some(entries.len()),
-                known_items: Some(entries),
-                type_param: Box::new(get_nothing()),
-                non_empty: true,
-            }))
-        }
         aast::Expr_::New(..) => None,
         aast::Expr_::Omitted => None,
         _ => {

src/code_info_builder/typehint_resolver.rs

@@ -529,7 +529,6 @@ pub fn get_type_from_hint(
             }
         }
         Hint_::Hmixed => TAtomic::TMixed,
-        Hint_::Hany => TAtomic::TMixedWithFlags(true, false, false, false),
         Hint_::Hshape(shape_info) => {
             get_shape_type_from_hints(shape_info, classlike_name, type_context, resolved_names)
         }
@@ -553,7 +552,22 @@ pub fn get_type_from_hint(
 
             last.unwrap()
         }
-        Hint_::Hlike(_) => panic!(),
+        Hint_::Hlike(inner) => {
+            let union =
+                get_type_from_hint(&inner.1, classlike_name, type_context, resolved_names).unwrap();
+
+            let mut last = None;
+
+            for atomic_type in union.types.into_iter() {
+                if last.is_none() {
+                    last = Some(atomic_type);
+                } else {
+                    types.push(atomic_type);
+                }
+            }
+
+            last.unwrap()
+        }
         Hint_::Hfun(hint_fun) => {
             get_function_type_from_hints(hint_fun, classlike_name, type_context, resolved_names)
         }
@@ -580,7 +594,6 @@ pub fn get_type_from_hint(
         Hint_::Hsoft(hint) => {
             return get_type_from_hint(&hint.1, classlike_name, type_context, resolved_names);
         }
-        Hint_::Herr => panic!(),
         Hint_::Hnonnull => TAtomic::TMixedWithFlags(false, false, false, true),
         Hint_::Habstr(_, _) => panic!(),
         Hint_::HvecOrDict(_, _) => panic!(),