From 52c4fb6e1bb86e77590c0ae59096686bd994fdae Mon Sep 17 00:00:00 2001 From: Wilfred Hughes Date: Mon, 9 Aug 2021 16:25:04 -0700 Subject: [PATCH] Use 'ast' naming consistently Summary: Don't use 'tast' when we're not talking about the TAST. We removed the equivalent pattern in OCaml in D27994474 (https://github.com/facebook/hhvm/commit/9b74d889465c870e26b421870b9cd814ae530d9a). Reviewed By: vsiles, shayne-fletcher Differential Revision: D30146639 fbshipit-source-id: f1e1821e8d4792f0085a18c20be3483b84356fa2 --- .../src/hhbc/hhbc_by_ref/ast_constant_folder.rs | 80 +-- hphp/hack/src/hhbc/hhbc_by_ref/compile.rs | 12 +- hphp/hack/src/hhbc/hhbc_by_ref/emit_body.rs | 94 ++-- hphp/hack/src/hhbc/hhbc_by_ref/emit_class.rs | 79 +-- hphp/hack/src/hhbc/hhbc_by_ref/emit_constant.rs | 8 +- hphp/hack/src/hhbc/hhbc_by_ref/emit_expression.rs | 578 ++++++++++----------- .../src/hhbc/hhbc_by_ref/emit_file_attributes.rs | 8 +- hphp/hack/src/hhbc/hhbc_by_ref/emit_function.rs | 14 +- .../src/hhbc/hhbc_by_ref/emit_native_opcode.rs | 16 +- hphp/hack/src/hhbc/hhbc_by_ref/emit_program.rs | 6 +- hphp/hack/src/hhbc/hhbc_by_ref/emit_property.rs | 26 +- hphp/hack/src/hhbc/hhbc_by_ref/emit_statement.rs | 192 ++++--- hphp/hack/src/hhbc/hhbc_by_ref/emit_typedef.rs | 6 +- hphp/hack/src/hhbc/hhbc_by_ref/env.rs | 33 +- hphp/hack/src/hhbc/hhbc_by_ref/generator.rs | 18 +- hphp/hack/src/hhbc/hhbc_by_ref/hhas_class.rs | 4 +- hphp/hack/src/hhbc/hhbc_by_ref/hhas_constant.rs | 6 +- .../src/hhbc/hhbc_by_ref/hhas_xhp_attribute.rs | 12 +- hphp/hack/src/hhbc/hhbc_by_ref/label_rewriter.rs | 21 +- hphp/hack/src/hhbc/hhbc_by_ref/rewrite_program.rs | 8 +- hphp/hack/src/hhbc/hhbc_by_ref/rewrite_xml.rs | 16 +- 21 files changed, 611 insertions(+), 626 deletions(-) diff --git a/hphp/hack/src/hhbc/hhbc_by_ref/ast_constant_folder.rs b/hphp/hack/src/hhbc/hhbc_by_ref/ast_constant_folder.rs index e199e437f07..54f43de5f0d 100644 --- a/hphp/hack/src/hhbc/hhbc_by_ref/ast_constant_folder.rs +++ b/hphp/hack/src/hhbc/hhbc_by_ref/ast_constant_folder.rs @@ -18,7 +18,7 @@ use naming_special_names_rust::{math, members, special_functions, typehints}; use oxidized::{ aast, aast_visitor::{visit_mut, AstParams, NodeMut, VisitorMut}, - ast as tast, ast_defs, + ast, ast_defs, pos::Pos, }; @@ -96,8 +96,8 @@ fn try_type_intlike(s: &str) -> Option { fn class_const_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, emitter: &Emitter<'arena, 'decl, D>, - cid: &tast::ClassId, - id: &tast::Pstring, + cid: &ast::ClassId, + id: &ast::Pstring, ) -> Result, Error> { if id.1 == members::M_CLASS { let cexpr = ast_class_expr::ClassExpr::class_id_to_class_expr( @@ -126,7 +126,7 @@ fn class_const_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl fn varray_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, emitter: &Emitter<'arena, 'decl, D>, - fields: &[tast::Expr], + fields: &[ast::Expr], ) -> Result, Error> { let tv_fields = alloc.alloc_slice_fill_iter( fields @@ -141,7 +141,7 @@ fn varray_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( fn darray_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, emitter: &Emitter<'arena, 'decl, D>, - fields: &[(tast::Expr, tast::Expr)], + fields: &[(ast::Expr, ast::Expr)], ) -> Result, Error> { //TODO: Improve. It's a bit silly having to use a std::vector::Vec // here. @@ -162,10 +162,10 @@ fn darray_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( fn set_afield_to_typed_value_pair<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, e: &Emitter<'arena, 'decl, D>, - afield: &tast::Afield, + afield: &ast::Afield, ) -> Result<(TypedValue<'local_arena>, TypedValue<'local_arena>), Error> { match afield { - tast::Afield::AFvalue(v) => set_afield_value_to_typed_value_pair(alloc, e, v), + ast::Afield::AFvalue(v) => set_afield_value_to_typed_value_pair(alloc, e, v), _ => Err(Error::unrecoverable( "set_afield_to_typed_value_pair: unexpected key=>value", )), @@ -175,7 +175,7 @@ fn set_afield_to_typed_value_pair<'local_arena, 'arena, 'decl, D: DeclProvider<' fn set_afield_value_to_typed_value_pair<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, e: &Emitter<'arena, 'decl, D>, - v: &tast::Expr, + v: &ast::Expr, ) -> Result<(TypedValue<'local_arena>, TypedValue<'local_arena>), Error> { let tv = key_expr_to_typed_value(alloc, e, v)?; Ok((tv.clone(), tv)) @@ -184,21 +184,21 @@ fn set_afield_value_to_typed_value_pair<'local_arena, 'arena, 'decl, D: DeclProv fn afield_to_typed_value_pair<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, emitter: &Emitter<'arena, 'decl, D>, - afield: &tast::Afield, + afield: &ast::Afield, ) -> Result<(TypedValue<'local_arena>, TypedValue<'local_arena>), Error> { match afield { - tast::Afield::AFvalue(_) => Err(Error::unrecoverable( + ast::Afield::AFvalue(_) => Err(Error::unrecoverable( "afield_to_typed_value_pair: unexpected value", )), - tast::Afield::AFkvalue(key, value) => kv_to_typed_value_pair(alloc, emitter, key, value), + ast::Afield::AFkvalue(key, value) => kv_to_typed_value_pair(alloc, emitter, key, value), } } fn kv_to_typed_value_pair<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, emitter: &Emitter<'arena, 'decl, D>, - key: &tast::Expr, - value: &tast::Expr, + key: &ast::Expr, + value: &ast::Expr, ) -> Result<(TypedValue<'local_arena>, TypedValue<'local_arena>), Error> { Ok(( key_expr_to_typed_value(alloc, emitter, key)?, @@ -209,11 +209,11 @@ fn kv_to_typed_value_pair<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( fn value_afield_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, emitter: &Emitter<'arena, 'decl, D>, - afield: &tast::Afield, + afield: &ast::Afield, ) -> Result, Error> { match afield { - tast::Afield::AFvalue(e) => expr_to_typed_value(alloc, emitter, e), - tast::Afield::AFkvalue(_, _) => Err(Error::unrecoverable( + ast::Afield::AFvalue(e) => expr_to_typed_value(alloc, emitter, e), + ast::Afield::AFkvalue(_, _) => Err(Error::unrecoverable( "value_afield_to_typed_value: unexpected key=>value", )), } @@ -222,7 +222,7 @@ fn value_afield_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'dec fn key_expr_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, emitter: &Emitter<'arena, 'decl, D>, - expr: &tast::Expr, + expr: &ast::Expr, ) -> Result, Error> { let tv = expr_to_typed_value(alloc, emitter, expr)?; let fold_lc = emitter @@ -240,7 +240,7 @@ fn key_expr_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( fn keyset_value_afield_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, emitter: &Emitter<'arena, 'decl, D>, - afield: &tast::Afield, + afield: &ast::Afield, ) -> Result, Error> { let tv = value_afield_to_typed_value(alloc, emitter, afield)?; let fold_lc = emitter @@ -258,7 +258,7 @@ fn keyset_value_afield_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvid fn shape_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, emitter: &Emitter<'arena, 'decl, D>, - fields: &[(tast::ShapeFieldName, tast::Expr)], + fields: &[(ast::ShapeFieldName, ast::Expr)], ) -> Result, Error> { let a = alloc.alloc_slice_fill_iter( fields @@ -288,10 +288,10 @@ fn shape_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( class_const_to_typed_value( alloc, emitter, - &tast::ClassId( + &ast::ClassId( (), Pos::make_none(), - tast::ClassId_::CI(class_id.clone()), + ast::ClassId_::CI(class_id.clone()), ), id, )? @@ -308,7 +308,7 @@ fn shape_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( pub fn vec_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, e: &Emitter<'arena, 'decl, D>, - fields: &[tast::Afield], + fields: &[ast::Afield], ) -> Result, Error> { //TODO: Improve. It's a bit silly having to use a std::vector::Vec // here. @@ -323,7 +323,7 @@ pub fn vec_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( pub fn expr_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, e: &Emitter<'arena, 'decl, D>, - expr: &tast::Expr, + expr: &ast::Expr, ) -> Result, Error> { expr_to_typed_value_( alloc, e, expr, false, /*allow_maps*/ @@ -334,7 +334,7 @@ pub fn expr_to_typed_value<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( pub fn expr_to_typed_value_<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'local_arena bumpalo::Bump, emitter: &Emitter<'arena, 'decl, D>, - expr: &tast::Expr, + expr: &ast::Expr, allow_maps: bool, force_class_const: bool, ) -> Result, Error> { @@ -342,7 +342,7 @@ pub fn expr_to_typed_value_<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>> // TODO: ML equivalent has this as an implicit parameter that defaults to false. match &expr.2 { Int(s) => int_expr_to_typed_value(s), - tast::Expr_::True => Ok(TypedValue::Bool(true)), + ast::Expr_::True => Ok(TypedValue::Bool(true)), False => Ok(TypedValue::Bool(false)), Null => Ok(TypedValue::Null), String(s) => { @@ -373,7 +373,7 @@ pub fn expr_to_typed_value_<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>> .map_or(false, |x| x.1 == special_functions::HHAS_ADATA) => { match id.2[..] { - [tast::Expr(_, _, tast::Expr_::String(ref data))] => { + [ast::Expr(_, _, ast::Expr_::String(ref data))] => { // FIXME: This is not safe--string literals are binary strings. // There's no guarantee that they're valid UTF-8. Ok(TypedValue::mk_hhas_adata( @@ -438,7 +438,7 @@ pub fn expr_to_typed_value_<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>> alloc.alloc_slice_fill_iter(v.into_iter()), )) } - ValCollection(x) if x.0 == tast::VcKind::Vec || x.0 == tast::VcKind::Vector => { + ValCollection(x) if x.0 == ast::VcKind::Vec || x.0 == ast::VcKind::Vector => { let v: Vec<_> = x.2.iter() .map(|e| expr_to_typed_value(alloc, emitter, e)) @@ -447,7 +447,7 @@ pub fn expr_to_typed_value_<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>> alloc.alloc_slice_fill_iter(v.into_iter()), )) } - ValCollection(x) if x.0 == tast::VcKind::Keyset => { + ValCollection(x) if x.0 == ast::VcKind::Keyset => { let keys = alloc.alloc_slice_fill_iter( x.2.iter() .map(|e| { @@ -473,7 +473,7 @@ pub fn expr_to_typed_value_<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>> ); Ok(TypedValue::mk_keyset(keys)) } - ValCollection(x) if x.0 == tast::VcKind::Set || x.0 == tast::VcKind::ImmSet => { + ValCollection(x) if x.0 == ast::VcKind::Set || x.0 == ast::VcKind::ImmSet => { let values = alloc.alloc_slice_fill_iter(update_duplicates_in_map( x.2.iter() .map(|e| set_afield_value_to_typed_value_pair(alloc, emitter, e)) @@ -525,11 +525,11 @@ fn update_duplicates_in_map<'local_arena>( fn cast_value<'local_arena>( alloc: &'local_arena bumpalo::Bump, - hint: &tast::Hint_, + hint: &ast::Hint_, v: TypedValue<'local_arena>, ) -> Result, Error> { match hint { - tast::Hint_::Happly(ast_defs::Id(_, id), args) if args.is_empty() => { + ast::Hint_::Happly(ast_defs::Id(_, id), args) if args.is_empty() => { let id = string_utils::strip_hh_ns(id); if id == typehints::BOOL { v.cast_to_bool() @@ -583,8 +583,8 @@ fn binop_on_values<'local_arena>( } #[allow(clippy::needless_lifetimes)] -fn value_to_expr_<'local_arena>(v: TypedValue<'local_arena>) -> Result { - use tast::*; +fn value_to_expr_<'local_arena>(v: TypedValue<'local_arena>) -> Result { + use ast::*; use TypedValue::*; Ok(match v { Int(i) => Expr_::Int(i.to_string()), @@ -622,18 +622,18 @@ impl<'ast, 'decl, D: DeclProvider<'decl>> VisitorMut<'ast> for FolderVisitor<'_, self } - fn visit_expr_(&mut self, c: &mut (), p: &mut tast::Expr_) -> Result<(), Error> { + fn visit_expr_(&mut self, c: &mut (), p: &mut ast::Expr_) -> Result<(), Error> { p.recurse(c, self.object())?; let new_p = match p { - tast::Expr_::Cast(e) => expr_to_typed_value(self.alloc, self.emitter, &e.1) + ast::Expr_::Cast(e) => expr_to_typed_value(self.alloc, self.emitter, &e.1) .and_then(|v| cast_value(self.alloc, &(e.0).1, v)) .map(value_to_expr_) .ok(), - tast::Expr_::Unop(e) => expr_to_typed_value(self.alloc, self.emitter, &e.1) + ast::Expr_::Unop(e) => expr_to_typed_value(self.alloc, self.emitter, &e.1) .and_then(|v| unop_on_value(self.alloc, &e.0, v)) .map(value_to_expr_) .ok(), - tast::Expr_::Binop(e) => expr_to_typed_value(self.alloc, self.emitter, &e.1) + ast::Expr_::Binop(e) => expr_to_typed_value(self.alloc, self.emitter, &e.1) .and_then(|v1| { expr_to_typed_value(self.alloc, self.emitter, &e.2).and_then(|v2| { binop_on_values(self.alloc, &e.0, v1, v2).map(value_to_expr_) @@ -650,7 +650,7 @@ impl<'ast, 'decl, D: DeclProvider<'decl>> VisitorMut<'ast> for FolderVisitor<'_, } pub fn fold_expr<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( - expr: &mut tast::Expr, + expr: &mut ast::Expr, alloc: &'local_arena bumpalo::Bump, e: &mut Emitter<'arena, 'decl, D>, ) -> Result<(), Error> { @@ -658,7 +658,7 @@ pub fn fold_expr<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( } pub fn fold_program<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( - p: &mut tast::Program, + p: &mut ast::Program, alloc: &'local_arena bumpalo::Bump, e: &mut Emitter<'arena, 'decl, D>, ) -> Result<(), Error> { @@ -666,7 +666,7 @@ pub fn fold_program<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( } pub fn literals_from_exprs<'local_arena, 'arena, 'decl, D: DeclProvider<'decl>>( - exprs: &mut [tast::Expr], + exprs: &mut [ast::Expr], alloc: &'local_arena bumpalo::Bump, e: &mut Emitter<'arena, 'decl, D>, ) -> Result>, Error> { diff --git a/hphp/hack/src/hhbc/hhbc_by_ref/compile.rs b/hphp/hack/src/hhbc/hhbc_by_ref/compile.rs index ee20bb95b4c..375ba355367 100644 --- a/hphp/hack/src/hhbc/hhbc_by_ref/compile.rs +++ b/hphp/hack/src/hhbc/hhbc_by_ref/compile.rs @@ -26,7 +26,7 @@ use itertools::{Either, Either::*}; use ocamlrep::{rc::RcOc, FromError, FromOcamlRep, Value}; use ocamlrep_derive::{FromOcamlRep, ToOcamlRep}; use oxidized::{ - ast as Tast, namespace_env::Env as NamespaceEnv, parser_options::ParserOptions, pos::Pos, + ast, namespace_env::Env as NamespaceEnv, parser_options::ParserOptions, pos::Pos, relative_path::RelativePath, }; use parser_core_types::{ @@ -430,7 +430,7 @@ fn rewrite_and_emit<'p, 'arena, 'decl, D: DeclProvider<'decl>, S: AsRef>( emitter: &mut Emitter<'arena, 'decl, D>, env: &Env, namespace_env: RcOc, - ast: &'p mut Tast::Program, + ast: &'p mut ast::Program, ) -> Result, Error> { // First rewrite. let result = rewrite(alloc, emitter, ast, RcOc::clone(&namespace_env)); // Modifies `ast` in place. @@ -449,7 +449,7 @@ fn rewrite_and_emit<'p, 'arena, 'decl, D: DeclProvider<'decl>, S: AsRef>( fn rewrite<'p, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'arena bumpalo::Bump, emitter: &mut Emitter<'arena, 'decl, D>, - ast: &'p mut Tast::Program, + ast: &'p mut ast::Program, namespace_env: RcOc, ) -> Result<(), Error> { rewrite_program(alloc, emitter, ast, namespace_env) @@ -460,7 +460,7 @@ fn emit<'p, 'arena, 'decl, D: DeclProvider<'decl>, S: AsRef>( emitter: &mut Emitter<'arena, 'decl, D>, env: &Env, namespace: RcOc, - ast: &'p mut Tast::Program, + ast: &'p mut ast::Program, ) -> Result, Error> { let mut flags = FromAstFlags::empty(); if env.flags.contains(EnvFlags::IS_EVALED) { @@ -557,7 +557,7 @@ fn parse_file( source_text: SourceText, elaborate_namespaces: bool, namespace_env: RcOc, -) -> Either<(Pos, String, bool), Tast::Program> { +) -> Either<(Pos, String, bool), ast::Program> { let aast_env = AastEnv { codegen: true, fail_open: false, @@ -637,7 +637,7 @@ fn time(f: impl FnOnce() -> T) -> (T, f64) { (r, t.as_secs_f64()) } -pub fn expr_to_string_lossy>(env: &Env, expr: &Tast::Expr) -> String { +pub fn expr_to_string_lossy>(env: &Env, expr: &ast::Expr) -> String { let opts = Options::from_configs(&env.config_jsons, &env.config_list).expect("Malformed options"); diff --git a/hphp/hack/src/hhbc/hhbc_by_ref/emit_body.rs b/hphp/hack/src/hhbc/hhbc_by_ref/emit_body.rs index 44b819cb0f5..7bb1d48b5f3 100644 --- a/hphp/hack/src/hhbc/hhbc_by_ref/emit_body.rs +++ b/hphp/hack/src/hhbc/hhbc_by_ref/emit_body.rs @@ -47,9 +47,7 @@ use hhbc_by_ref_unique_id_builder::*; use naming_special_names_rust::user_attributes as ua; use ocamlrep::rc::RcOc; -use oxidized::{ - aast, aast_defs, ast as tast, ast_defs, doc_comment::DocComment, namespace_env, pos::Pos, -}; +use oxidized::{aast, aast_defs, ast, ast_defs, doc_comment::DocComment, namespace_env, pos::Pos}; use ffi::{Maybe, Maybe::*, Pair, Slice, Str}; @@ -61,10 +59,10 @@ static THIS: &'static str = "$this"; /// Optional arguments for emit_body; use Args::default() for defaults pub struct Args<'a, 'arena> { - pub immediate_tparams: &'a Vec, + pub immediate_tparams: &'a Vec, pub class_tparam_names: &'a [&'a str], - pub ast_params: &'a Vec, - pub ret: Option<&'a tast::Hint>, + pub ast_params: &'a Vec, + pub ret: Option<&'a ast::Hint>, pub pos: &'a Pos, pub deprecation_info: &'a Option<&'a [TypedValue<'arena>]>, pub doc_comment: Option, @@ -89,7 +87,7 @@ pub fn emit_body_with_default_args<'b, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'arena bumpalo::Bump, emitter: &mut Emitter<'arena, 'decl, D>, namespace: RcOc, - body: &'b tast::Program, + body: &'b ast::Program, return_value: InstrSeq<'arena>, ) -> Result> { let args = Args { @@ -129,7 +127,7 @@ pub fn emit_body<'b, 'arena, 'decl, D: DeclProvider<'decl>>( .get_tparams() .into_iter() .map(|tp| tp.clone()) - .collect::>(); + .collect::>(); let mut tp_names = get_tp_names(&tparams); let (is_generator, is_pair_generator) = generator::is_function_generator(&body); @@ -235,14 +233,14 @@ pub fn emit_body<'b, 'arena, 'decl, D: DeclProvider<'decl>>( fn make_body_instrs<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, env: &mut Env<'a, 'arena>, - params: &[(HhasParam<'arena>, Option<(Label, tast::Expr)>)], - tparams: &[tast::Tparam], + params: &[(HhasParam<'arena>, Option<(Label, ast::Expr)>)], + tparams: &[ast::Tparam], decl_vars: &[String], body: AstBody, is_generator: bool, deprecation_info: Option<&[TypedValue<'arena>]>, pos: &Pos, - ast_params: &[tast::FunParam], + ast_params: &[ast::FunParam], flags: Flags, ) -> Result> { let alloc = env.arena; @@ -287,13 +285,13 @@ fn make_body_instrs<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn make_header_content<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, env: &mut Env<'a, 'arena>, - params: &[(HhasParam<'arena>, Option<(Label, tast::Expr)>)], - tparams: &[tast::Tparam], + params: &[(HhasParam<'arena>, Option<(Label, ast::Expr)>)], + tparams: &[ast::Tparam], _decl_vars: &[String], is_generator: bool, deprecation_info: Option<&[TypedValue<'arena>]>, pos: &Pos, - ast_params: &[tast::FunParam], + ast_params: &[ast::FunParam], flags: Flags, ) -> Result> { let alloc = env.arena; @@ -321,8 +319,8 @@ fn make_header_content<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn make_decl_vars<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, scope: &Scope<'a>, - immediate_tparams: &[tast::Tparam], - params: &[(HhasParam<'arena>, Option<(Label, tast::Expr)>)], + immediate_tparams: &[ast::Tparam], + params: &[(HhasParam<'arena>, Option<(Label, ast::Expr)>)], body: &AstBody, arg_flags: Flags, ) -> Result> { @@ -352,7 +350,7 @@ fn make_decl_vars<'a, 'arena, 'decl, D: DeclProvider<'decl>>( if !arg_flags.contains(Flags::CLOSURE_BODY) && immediate_tparams .iter() - .any(|t| t.reified != tast::ReifyKind::Erased) + .any(|t| t.reified != ast::ReifyKind::Erased) { decl_vars.insert(0, string_utils::reified::GENERICS_LOCAL_NAME.into()); } @@ -413,10 +411,10 @@ fn make_params<'a, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'arena bumpalo::Bump, emitter: &mut Emitter<'arena, 'decl, D>, tp_names: &mut Vec<&str>, - ast_params: &[tast::FunParam], + ast_params: &[ast::FunParam], scope: &Scope<'a>, flags: Flags, -) -> Result, Option<(Label, tast::Expr)>)>> { +) -> Result, Option<(Label, ast::Expr)>)>> { let generate_defaults = !flags.contains(Flags::MEMOIZE); emit_param::from_asts( alloc, @@ -438,7 +436,7 @@ pub fn make_body<'a, 'arena, 'decl, D: DeclProvider<'decl>>( num_closures: u32, upper_bounds: Vec<(String, Vec>)>, shadowed_tparams: Vec, - mut params: Vec<(HhasParam<'arena>, Option<(Label, tast::Expr)>)>, + mut params: Vec<(HhasParam<'arena>, Option<(Label, ast::Expr)>)>, return_type_info: Option>, doc_comment: Option, opt_env: Option<&Env<'a, 'arena>>, @@ -538,13 +536,13 @@ fn emit_ast_body<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn emit_defs<'a, 'arena, 'decl, D: DeclProvider<'decl>>( env: &mut Env<'a, 'arena>, emitter: &mut Emitter<'arena, 'decl, D>, - prog: &[tast::Def], + prog: &[ast::Def], ) -> Result> { - use tast::Def; + use ast::Def; fn emit_def<'a, 'arena, 'decl, D: DeclProvider<'decl>>( env: &mut Env<'a, 'arena>, emitter: &mut Emitter<'arena, 'decl, D>, - def: &tast::Def, + def: &ast::Def, ) -> Result> { let alloc = env.arena; match def { @@ -556,7 +554,7 @@ fn emit_defs<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn aux<'a, 'arena, 'decl, D: DeclProvider<'decl>>( env: &mut Env<'a, 'arena>, emitter: &mut Emitter<'arena, 'decl, D>, - defs: &[tast::Def], + defs: &[ast::Def], ) -> Result> { let alloc = env.arena; match defs { @@ -612,8 +610,8 @@ fn emit_defs<'a, 'arena, 'decl, D: DeclProvider<'decl>>( pub fn has_type_constraint<'a, 'arena>( env: &Env<'a, 'arena>, ti: Option<&HhasTypeInfo>, - ast_param: &tast::FunParam, -) -> (RGH::ReificationLevel, Option) { + ast_param: &ast::FunParam, +) -> (RGH::ReificationLevel, Option) { use RGH::ReificationLevel as L; match (ti, &ast_param.type_hint.1) { (Some(ti), Some(h)) if ti.has_type_constraint() => { @@ -631,10 +629,10 @@ pub fn has_type_constraint<'a, 'arena>( mod atom_helpers { use crate::*; use aast_defs::ReifyKind::Erased; + use ast::Tparam; use ast_defs::Id; use hhbc_by_ref_instruction_sequence::{instr, unrecoverable, InstrSeq, Result}; use hhbc_by_ref_local::Local::Named; - use tast::Tparam; fn strip_ns(name: &str) -> &str { match name.chars().next() { @@ -700,8 +698,8 @@ fn atom_instrs<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, env: &mut Env<'a, 'arena>, param: &HhasParam<'arena>, - ast_param: &tast::FunParam, - tparams: &[tast::Tparam], + ast_param: &ast::FunParam, + tparams: &[ast::Tparam], ) -> Result>> { let alloc = env.arena; if !param @@ -746,7 +744,7 @@ fn atom_instrs<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emit_expression::emit_expr( emitter, env, - &(tast::Expr( + &(ast::Expr( (), Pos::make_none(), aast::Expr_::String( @@ -759,7 +757,7 @@ fn atom_instrs<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emit_expression::emit_expr( emitter, env, - &(tast::Expr( + &(ast::Expr( (), Pos::make_none(), aast::Expr_::True, @@ -776,7 +774,7 @@ fn atom_instrs<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emit_expression::emit_expr( emitter, env, - &(tast::Expr( + &(ast::Expr( (), Pos::make_none(), aast::Expr_::String( @@ -899,13 +897,13 @@ pub fn emit_method_prolog<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, env: &mut Env<'a, 'arena>, pos: &Pos, - params: &[(HhasParam<'arena>, Option<(Label, tast::Expr)>)], - ast_params: &[tast::FunParam], - tparams: &[tast::Tparam], + params: &[(HhasParam<'arena>, Option<(Label, ast::Expr)>)], + ast_params: &[ast::FunParam], + tparams: &[ast::Tparam], ) -> Result> { let alloc = env.arena; let mut make_param_instr = - |(param, ast_param): (&HhasParam<'arena>, &tast::FunParam)| -> Result>> { + |(param, ast_param): (&HhasParam<'arena>, &ast::FunParam)| -> Result>> { let param_name = ¶m.name; let param_name = || ParamId::ParamNamed(Str::new_str(alloc, param_name)); if param.is_variadic { @@ -993,13 +991,13 @@ pub fn emit_deprecation_info<'a, 'arena>( Ok(match deprecation_info { None => instr::empty(alloc), Some(args) => { - fn strip_id<'a>(id: &'a tast::Id) -> &'a str { + fn strip_id<'a>(id: &'a ast::Id) -> &'a str { string_utils::strip_global_ns(id.1.as_str()) } let (class_name, trait_instrs, concat_instruction): (String, _, _) = match scope.get_class() { None => ("".into(), instr::empty(alloc), instr::empty(alloc)), - Some(c) if c.get_kind() == tast::ClassishKind::Ctrait => ( + Some(c) if c.get_kind() == ast::ClassishKind::Ctrait => ( "::".into(), InstrSeq::gather(alloc, vec![instr::self_(alloc), instr::classname(alloc)]), instr::concat(alloc), @@ -1087,9 +1085,9 @@ fn set_emit_statement_state<'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'arena bumpalo::Bump, emitter: &mut Emitter<'arena, 'decl, D>, default_return_value: InstrSeq<'arena>, - params: &[(HhasParam<'arena>, Option<(Label, tast::Expr)>)], + params: &[(HhasParam<'arena>, Option<(Label, ast::Expr)>)], return_type_info: &HhasTypeInfo, - return_type: Option<&tast::Hint>, + return_type: Option<&ast::Hint>, pos: &Pos, default_dropthrough: Option>, flags: Flags, @@ -1134,7 +1132,7 @@ fn set_emit_statement_state<'arena, 'decl, D: DeclProvider<'decl>>( fn emit_verify_out<'arena>( alloc: &'arena bumpalo::Bump, - params: &[(HhasParam<'arena>, Option<(Label, tast::Expr)>)], + params: &[(HhasParam<'arena>, Option<(Label, ast::Expr)>)], ) -> (usize, InstrSeq<'arena>) { let param_instrs: Vec> = params .iter() @@ -1171,11 +1169,11 @@ fn emit_verify_out<'arena>( pub fn emit_generics_upper_bounds<'arena>( alloc: &'arena bumpalo::Bump, - immediate_tparams: &[tast::Tparam], + immediate_tparams: &[ast::Tparam], class_tparam_names: &[&str], skip_awaitable: bool, ) -> Vec<(String, Vec>)> { - let constraint_filter = |(kind, hint): &(ast_defs::ConstraintKind, tast::Hint)| { + let constraint_filter = |(kind, hint): &(ast_defs::ConstraintKind, ast::Hint)| { if let ast_defs::ConstraintKind::ConstraintAs = &kind { let mut tparam_names = get_tp_names(immediate_tparams); tparam_names.extend_from_slice(class_tparam_names); @@ -1192,7 +1190,7 @@ pub fn emit_generics_upper_bounds<'arena>( None } }; - let tparam_filter = |tparam: &tast::Tparam| { + let tparam_filter = |tparam: &ast::Tparam| { let ubs = tparam .constraints .iter() @@ -1210,7 +1208,7 @@ pub fn emit_generics_upper_bounds<'arena>( } fn emit_shadowed_tparams( - immediate_tparams: &[tast::Tparam], + immediate_tparams: &[ast::Tparam], class_tparam_names: &[&str], ) -> Vec { let s1 = get_tp_names_set(immediate_tparams); @@ -1231,16 +1229,16 @@ fn move_this(vars: &mut Vec) { } } -fn get_tp_name(tparam: &tast::Tparam) -> &str { +fn get_tp_name(tparam: &ast::Tparam) -> &str { let ast_defs::Id(_, name) = &tparam.name; name } -pub fn get_tp_names(tparams: &[tast::Tparam]) -> Vec<&str> { +pub fn get_tp_names(tparams: &[ast::Tparam]) -> Vec<&str> { tparams.iter().map(get_tp_name).collect() } -pub fn get_tp_names_set(tparams: &[tast::Tparam]) -> HashSet<&str> { +pub fn get_tp_names_set(tparams: &[ast::Tparam]) -> HashSet<&str> { tparams.iter().map(get_tp_name).collect() } diff --git a/hphp/hack/src/hhbc/hhbc_by_ref/emit_class.rs b/hphp/hack/src/hhbc/hhbc_by_ref/emit_class.rs index 896f87b28cc..6b451916af8 100644 --- a/hphp/hack/src/hhbc/hhbc_by_ref/emit_class.rs +++ b/hphp/hack/src/hhbc/hhbc_by_ref/emit_class.rs @@ -38,7 +38,8 @@ use hhbc_by_ref_local::Local; use hhbc_by_ref_runtime::TypedValue; use naming_special_names_rust as special_names; use oxidized::{ - ast::{self as tast, Hint, ReifyKind, Visibility}, + ast, + ast::{Hint, ReifyKind, Visibility}, namespace_env, pos::Pos, }; @@ -126,7 +127,7 @@ fn from_extends<'arena>( alloc: &'arena bumpalo::Bump, is_enum: bool, is_enum_class: bool, - extends: &[tast::Hint], + extends: &[ast::Hint], ) -> Option> { if is_enum { // Do not use special_names:: as there's a prefix \ which breaks HHVM @@ -147,7 +148,7 @@ fn from_extends<'arena>( fn from_implements<'arena>( alloc: &'arena bumpalo::Bump, - implements: &[tast::Hint], + implements: &[ast::Hint], ) -> Vec> { implements .iter() @@ -157,7 +158,7 @@ fn from_implements<'arena>( fn from_includes<'arena>( alloc: &'arena bumpalo::Bump, - includes: &[tast::Hint], + includes: &[ast::Hint], ) -> Vec> { includes .iter() @@ -168,19 +169,19 @@ fn from_includes<'arena>( fn from_type_constant<'a, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'arena bumpalo::Bump, emitter: &mut Emitter<'arena, 'decl, D>, - tc: &'a tast::ClassTypeconstDef, + tc: &'a ast::ClassTypeconstDef, ) -> Result> { - use tast::ClassTypeconst::*; + use ast::ClassTypeconst::*; let name = tc.name.1.to_string(); let initializer = match &tc.kind { - TCAbstract(tast::ClassAbstractTypeconst { default: None, .. }) => None, - TCAbstract(tast::ClassAbstractTypeconst { + TCAbstract(ast::ClassAbstractTypeconst { default: None, .. }) => None, + TCAbstract(ast::ClassAbstractTypeconst { default: Some(init), .. }) - | TCPartiallyAbstract(tast::ClassPartiallyAbstractTypeconst { type_: init, .. }) - | TCConcrete(tast::ClassConcreteTypeconst { c_tc_type: init }) => { + | TCPartiallyAbstract(ast::ClassPartiallyAbstractTypeconst { type_: init, .. }) + | TCConcrete(ast::ClassConcreteTypeconst { c_tc_type: init }) => { // TODO: Deal with the constraint // Type constants do not take type vars hence tparams:[] Some(emit_type_constant::hint_to_type_constant( @@ -207,17 +208,17 @@ fn from_type_constant<'a, 'arena, 'decl, D: DeclProvider<'decl>>( }) } -fn from_ctx_constant(tc: &tast::ClassTypeconstDef) -> Result { - use tast::ClassTypeconst::*; +fn from_ctx_constant(tc: &ast::ClassTypeconstDef) -> Result { + use ast::ClassTypeconst::*; let name = tc.name.1.to_string(); let coeffects = match &tc.kind { - TCAbstract(tast::ClassAbstractTypeconst { default: None, .. }) => (vec![], vec![]), + TCAbstract(ast::ClassAbstractTypeconst { default: None, .. }) => (vec![], vec![]), TCPartiallyAbstract(_) => (vec![], vec![]), // does not parse - TCAbstract(tast::ClassAbstractTypeconst { + TCAbstract(ast::ClassAbstractTypeconst { default: Some(hint), .. }) - | TCConcrete(tast::ClassConcreteTypeconst { c_tc_type: hint }) => { + | TCConcrete(ast::ClassConcreteTypeconst { c_tc_type: hint }) => { HhasCoeffects::from_ctx_constant(hint) } }; @@ -235,7 +236,7 @@ fn from_ctx_constant(tc: &tast::ClassTypeconstDef) -> Result { fn from_class_elt_classvars<'a, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'arena bumpalo::Bump, emitter: &mut Emitter<'arena, 'decl, D>, - ast_class: &'a tast::Class_, + ast_class: &'a ast::Class_, class_is_const: bool, tparams: &[&str], ) -> Result>> { @@ -279,7 +280,7 @@ fn from_class_elt_classvars<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn from_class_elt_constants<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - class_: &'a tast::Class_, + class_: &'a ast::Class_, ) -> Result>> { use oxidized::aast::ClassConstKind::*; class_ @@ -297,7 +298,7 @@ fn from_class_elt_constants<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn from_class_elt_requirements<'a, 'arena>( alloc: &'arena bumpalo::Bump, - class_: &'a tast::Class_, + class_: &'a ast::Class_, ) -> Vec<(hhbc_id::class::ClassType<'arena>, TraitReqKind)> { class_ .reqs @@ -315,7 +316,7 @@ fn from_class_elt_requirements<'a, 'arena>( fn from_enum_type<'arena>( alloc: &'arena bumpalo::Bump, - opt: Option<&tast::Enum_>, + opt: Option<&ast::Enum_>, ) -> Result>> { use hhbc_by_ref_hhas_type::constraint::*; opt.map(|e| { @@ -332,7 +333,7 @@ fn from_enum_type<'arena>( .transpose() } -fn validate_class_name(ns: &namespace_env::Env, tast::Id(p, class_name): &tast::Id) -> Result<()> { +fn validate_class_name(ns: &namespace_env::Env, ast::Id(p, class_name): &ast::Id) -> Result<()> { let is_global_namespace = |ns: &namespace_env::Env| ns.name.is_none(); let is_hh_namespace = |ns: &namespace_env::Env| { ns.name @@ -372,7 +373,7 @@ fn validate_class_name(ns: &namespace_env::Env, tast::Id(p, class_name): &tast:: fn emit_reified_extends_params<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - ast_class: &'a tast::Class_, + ast_class: &'a ast::Class_, ) -> Result> { let alloc = env.arena; match &ast_class.extends[..] { @@ -403,7 +404,7 @@ fn emit_reified_init_body<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, num_reified: usize, - ast_class: &'a tast::Class_, + ast_class: &'a ast::Class_, ) -> Result> { use string_utils::reified::{INIT_METH_NAME, INIT_METH_PARAM_NAME, PROP_NAME}; @@ -476,7 +477,7 @@ fn emit_reified_init_body<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn emit_reified_init_method<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - ast_class: &'a tast::Class_, + ast_class: &'a ast::Class_, ) -> Result>> { use hhbc_by_ref_hhas_type::{constraint::*, Info}; @@ -571,7 +572,7 @@ where pub fn emit_class<'a, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'arena bumpalo::Bump, emitter: &mut Emitter<'arena, 'decl, D>, - ast_class: &'a tast::Class_, + ast_class: &'a ast::Class_, ) -> Result> { let namespace = &ast_class.namespace; validate_class_name(namespace, &ast_class.name)?; @@ -594,14 +595,14 @@ pub fn emit_class<'a, 'arena, 'decl, D: DeclProvider<'decl>>( // it on. let no_dynamic_props = is_const; let name = class::ClassType::from_ast_name(alloc, &ast_class.name.1); - let is_trait = ast_class.kind == tast::ClassishKind::Ctrait; - let is_interface = ast_class.kind == tast::ClassishKind::Cinterface; + let is_trait = ast_class.kind == ast::ClassishKind::Ctrait; + let is_interface = ast_class.kind == ast::ClassishKind::Cinterface; let uses = ast_class .uses .iter() .filter_map(|x| match x.1.as_ref() { - tast::Hint_::Happly(tast::Id(_, name), _) => { + ast::Hint_::Happly(ast::Id(_, name), _) => { if is_interface { Some(Err(emit_fatal::raise_fatal_parse( &x.0, @@ -616,11 +617,11 @@ pub fn emit_class<'a, 'arena, 'decl, D: DeclProvider<'decl>>( .collect::>>()?; let elaborate_namespace_id = - |x: &'a tast::Id| hhbc_id::class::ClassType::from_ast_name(alloc, x.name()); + |x: &'a ast::Id| hhbc_id::class::ClassType::from_ast_name(alloc, x.name()); let use_aliases = ast_class .use_as_alias .iter() - .map(|tast::UseAsAlias(ido1, id, ido2, vis)| { + .map(|ast::UseAsAlias(ido1, id, ido2, vis)| { let id1 = ido1.as_ref().map(|x| elaborate_namespace_id(x)); let id2 = ido2.as_ref().map(|x| (alloc, x.1.as_ref()).into()); (id1, (alloc, id.1.as_ref()).into(), id2, vis) @@ -630,7 +631,7 @@ pub fn emit_class<'a, 'arena, 'decl, D: DeclProvider<'decl>>( let use_precedences = ast_class .insteadof_alias .iter() - .map(|tast::InsteadofAlias(id1, id2, ids)| { + .map(|ast::InsteadofAlias(id1, id2, ids)| { let id1 = elaborate_namespace_id(id1); let id2: hhbc_by_ref_hhbc_id::class::ClassType<'arena> = (alloc, id2.1.as_ref()).into(); let ids = ids.iter().map(|x| elaborate_namespace_id(x)).collect(); @@ -639,20 +640,20 @@ pub fn emit_class<'a, 'arena, 'decl, D: DeclProvider<'decl>>( .collect(); let enum_type = match ast_class.kind { - tast::ClassishKind::Cenum | tast::ClassishKind::CenumClass => { + ast::ClassishKind::Cenum | ast::ClassishKind::CenumClass => { from_enum_type(alloc, ast_class.enum_.as_ref())? } _ => None, }; let is_enum_class = match ast_class.kind { - tast::ClassishKind::CenumClass => true, + ast::ClassishKind::CenumClass => true, _ => false, }; let xhp_attributes: Vec<_> = ast_class .xhp_attrs .iter() .map( - |tast::XhpAttr(type_, class_var, tag, maybe_enum)| HhasXhpAttribute { + |ast::XhpAttr(type_, class_var, tag, maybe_enum)| HhasXhpAttribute { type_: type_.1.as_ref(), class_var, tag: *tag, @@ -668,7 +669,7 @@ pub fn emit_class<'a, 'arena, 'decl, D: DeclProvider<'decl>>( .map(|(p, c)| (p, c.iter().map(|x| &x.1).collect())); let is_abstract = match ast_class.kind { - tast::ClassishKind::Cclass(k) => k.is_abstract(), + ast::ClassishKind::Cclass(k) => k.is_abstract(), _ => false, }; let is_final = ast_class.final_ || is_trait; @@ -707,8 +708,8 @@ pub fn emit_class<'a, 'arena, 'decl, D: DeclProvider<'decl>>( &ast_class.implements }; let implements = from_implements(alloc, implements); - let enum_includes = if ast_class.kind == tast::ClassishKind::Cenum - || ast_class.kind == tast::ClassishKind::CenumClass + let enum_includes = if ast_class.kind == ast::ClassishKind::Cenum + || ast_class.kind == ast::ClassishKind::CenumClass { match &ast_class.enum_ { None => vec![], @@ -945,11 +946,11 @@ pub fn emit_class<'a, 'arena, 'decl, D: DeclProvider<'decl>>( pub fn emit_classes_from_program<'a, 'arena, 'decl, D: DeclProvider<'decl>>( alloc: &'arena bumpalo::Bump, emitter: &mut Emitter<'arena, 'decl, D>, - tast: &'a [tast::Def], + ast: &'a [ast::Def], ) -> Result>> { - tast.iter() + ast.iter() .filter_map(|class| { - if let tast::Def::Class(cd) = class { + if let ast::Def::Class(cd) = class { Some(emit_class(alloc, emitter, cd)) } else { None diff --git a/hphp/hack/src/hhbc/hhbc_by_ref/emit_constant.rs b/hphp/hack/src/hhbc/hhbc_by_ref/emit_constant.rs index ec723a38d17..847aa973a2b 100644 --- a/hphp/hack/src/hhbc/hhbc_by_ref/emit_constant.rs +++ b/hphp/hack/src/hhbc/hhbc_by_ref/emit_constant.rs @@ -15,12 +15,12 @@ use hhbc_by_ref_hhas_pos::Span; use hhbc_by_ref_hhbc_id::{r#const, function, Id}; use hhbc_by_ref_hhbc_string_utils::strip_global_ns; use hhbc_by_ref_instruction_sequence::{instr, InstrSeq, Result}; -use oxidized::ast as tast; +use oxidized::ast; fn emit_constant_cinit<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &mut Env<'a, 'arena>, - constant: &'a tast::Gconst, + constant: &'a ast::Gconst, c: &HhasConstant<'arena>, ) -> Result>> { let alloc = env.arena; @@ -84,7 +84,7 @@ fn emit_constant_cinit<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn emit_constant<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &mut Env<'a, 'arena>, - constant: &'a tast::Gconst, + constant: &'a ast::Gconst, ) -> Result<(HhasConstant<'arena>, Option>)> { let c = hhas_constant::from_ast(e, env, &constant.name, false, Some(&constant.value))?; let f = emit_constant_cinit(e, env, constant, &c)?; @@ -94,7 +94,7 @@ fn emit_constant<'a, 'arena, 'decl, D: DeclProvider<'decl>>( pub fn emit_constants_from_program<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &mut Env<'a, 'arena>, - defs: &'a [tast::Def], + defs: &'a [ast::Def], ) -> Result<(Vec>, Vec>)> { let const_tuples = defs .iter() diff --git a/hphp/hack/src/hhbc/hhbc_by_ref/emit_expression.rs b/hphp/hack/src/hhbc/hhbc_by_ref/emit_expression.rs index 07f47ac0e88..b5dbf5d6bb1 100644 --- a/hphp/hack/src/hhbc/hhbc_by_ref/emit_expression.rs +++ b/hphp/hack/src/hhbc/hhbc_by_ref/emit_expression.rs @@ -36,7 +36,7 @@ use naming_special_names_rust::{ use oxidized::{ aast, aast_defs, aast_visitor::{visit, visit_mut, AstParams, Node, NodeMut, Visitor, VisitorMut}, - ast as tast, ast_defs, local_id, + ast, ast_defs, local_id, pos::Pos, }; use regex::Regex; @@ -83,7 +83,7 @@ pub fn is_local_this<'a, 'arena>(env: &Env<'a, 'arena>, lid: &local_id::LocalId) mod inout_locals { use crate::*; use hash::HashMap; - use oxidized::{aast_defs::Lid, aast_visitor, aast_visitor::Node, ast as tast, ast_defs}; + use oxidized::{aast_defs::Lid, aast_visitor, aast_visitor::Node, ast, ast_defs}; use std::marker::PhantomData; pub(super) struct AliasInfo { @@ -168,7 +168,7 @@ mod inout_locals { pub(super) fn collect_written_variables<'ast, 'arena>( env: &Env<'ast, 'arena>, - args: &'ast [tast::Expr], + args: &'ast [ast::Expr], ) -> AliasInfoMap<'ast> { let mut acc = HashMap::default(); args.iter() @@ -181,10 +181,10 @@ mod inout_locals { env: &Env<'ast, 'arena>, is_top: bool, i: usize, - arg: &'ast tast::Expr, + arg: &'ast ast::Expr, acc: &mut AliasInfoMap<'ast>, ) { - use tast::{Expr, Expr_}; + use ast::{Expr, Expr_}; let Expr(_, _, e) = arg; // inout $v if let Some((ast_defs::ParamKind::Pinout, Expr(_, _, Expr_::Lvar(lid)))) = e.as_callconv() { @@ -229,10 +229,10 @@ mod inout_locals { fn visit_expr_( &mut self, c: &mut Ctx<'r, 'ast, 'arena>, - p: &'ast tast::Expr_, + p: &'ast ast::Expr_, ) -> std::result::Result<(), ()> { // f(inout $v) or f(&$v) - if let tast::Expr_::Call(expr) = p { + if let ast::Expr_::Call(expr) = p { let (_, _, args, uarg) = &**expr; args.iter() .for_each(|arg| handle_arg(&c.env, false, c.i, arg, &mut c.state)); @@ -244,14 +244,14 @@ mod inout_locals { p.recurse(c, self.object())?; Ok(match p { // lhs op= _ - tast::Expr_::Binop(expr) => { + ast::Expr_::Binop(expr) => { let (bop, left, _) = &**expr; if let ast_defs::Bop::Eq(_) = bop { collect_lvars_hs(c, left) } } // $i++ or $i-- - tast::Expr_::Unop(expr) => { + ast::Expr_::Unop(expr) => { let (uop, e) = &**expr; match uop { ast_defs::Uop::Uincr | ast_defs::Uop::Udecr => collect_lvars_hs(c, e), @@ -259,7 +259,7 @@ mod inout_locals { } } // $v - tast::Expr_::Lvar(expr) => { + ast::Expr_::Lvar(expr) => { let Lid(_, (_, id)) = &**expr; add_use(id, &mut c.state); } @@ -270,17 +270,17 @@ mod inout_locals { } // impl<'ast, 'a, 'arena> aast_visitor::Visitor<'ast> for Visitor<'a, 'arena> // collect lvars on the left hand side of '=' operator - fn collect_lvars_hs<'r, 'ast, 'arena>(ctx: &mut Ctx<'r, 'ast, 'arena>, expr: &'ast tast::Expr) { - let tast::Expr(_, _, e) = expr; + fn collect_lvars_hs<'r, 'ast, 'arena>(ctx: &mut Ctx<'r, 'ast, 'arena>, expr: &'ast ast::Expr) { + let ast::Expr(_, _, e) = expr; match &*e { - tast::Expr_::Lvar(lid) => { + ast::Expr_::Lvar(lid) => { let Lid(_, lid) = &**lid; if !is_local_this(&ctx.env, &lid) { add_use(lid.1.as_str(), &mut ctx.state); add_write(lid.1.as_str(), ctx.i, &mut ctx.state); } } - tast::Expr_::List(exprs) => exprs.iter().for_each(|expr| collect_lvars_hs(ctx, expr)), + ast::Expr_::List(exprs) => exprs.iter().for_each(|expr| collect_lvars_hs(ctx, expr)), _ => {} } } @@ -377,12 +377,12 @@ enum ArrayGetBase<'arena> { pub fn emit_expr<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - expression: &tast::Expr, + expression: &ast::Expr, ) -> Result> { use aast_defs::Lid; - use tast::Expr_; + use ast::Expr_; let alloc = env.arena; - let tast::Expr(_, pos, expr) = expression; + let ast::Expr(_, pos, expr) = expression; match expr { Expr_::Float(_) | Expr_::EnumClassLabel(_) @@ -477,7 +477,7 @@ pub fn emit_expr<'a, 'arena, 'decl, D: DeclProvider<'decl>>( &fields .to_owned() .into_iter() - .map(|tast::Field(e1, e2)| (e1, e2)) + .map(|ast::Field(e1, e2)| (e1, e2)) .collect::>() .as_slice(), ); @@ -549,7 +549,7 @@ pub fn emit_expr<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn emit_exprs<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - exprs: &[tast::Expr], + exprs: &[ast::Expr], ) -> Result> { let alloc = env.arena; if exprs.is_empty() { @@ -568,7 +568,7 @@ fn emit_exprs<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn emit_id<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - id: &tast::Sid, + id: &ast::Sid, ) -> Result> { use pseudo_consts::*; use InstructLitConst::*; @@ -604,7 +604,7 @@ fn emit_id<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn emit_exit<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - expr_opt: Option<&tast::Expr>, + expr_opt: Option<&ast::Expr>, ) -> Result> { let alloc = env.arena; Ok(InstrSeq::gather( @@ -620,11 +620,11 @@ fn emit_yield<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - af: &tast::Afield, + af: &ast::Afield, ) -> Result> { let alloc = env.arena; Ok(match af { - tast::Afield::AFvalue(v) => InstrSeq::gather( + ast::Afield::AFvalue(v) => InstrSeq::gather( alloc, vec![ emit_expr(e, env, v)?, @@ -632,7 +632,7 @@ fn emit_yield<'a, 'arena, 'decl, D: DeclProvider<'decl>>( instr::yield_(alloc), ], ), - tast::Afield::AFkvalue(k, v) => InstrSeq::gather( + ast::Afield::AFkvalue(k, v) => InstrSeq::gather( alloc, vec![ emit_expr(e, env, k)?, @@ -644,15 +644,15 @@ fn emit_yield<'a, 'arena, 'decl, D: DeclProvider<'decl>>( }) } -fn parse_include<'arena>(alloc: &'arena bumpalo::Bump, e: &tast::Expr) -> IncludePath<'arena> { +fn parse_include<'arena>(alloc: &'arena bumpalo::Bump, e: &ast::Expr) -> IncludePath<'arena> { fn strip_backslash(s: &mut String) { if s.starts_with('/') { *s = s[1..].into() } } - fn split_var_lit(e: &tast::Expr) -> (String, String) { + fn split_var_lit(e: &ast::Expr) -> (String, String) { match &e.2 { - tast::Expr_::Binop(x) if x.0.is_dot() => { + ast::Expr_::Binop(x) if x.0.is_dot() => { let (v, l) = split_var_lit(&x.2); if v.is_empty() { let (var, lit) = split_var_lit(&x.1); @@ -661,7 +661,7 @@ fn parse_include<'arena>(alloc: &'arena bumpalo::Bump, e: &tast::Expr) -> Includ (v, String::new()) } } - tast::Expr_::String(lit) => (String::new(), lit.to_string()), + ast::Expr_::String(lit) => (String::new(), lit.to_string()), _ => (text_of_expr(e), String::new()), } } @@ -682,13 +682,13 @@ fn parse_include<'arena>(alloc: &'arena bumpalo::Bump, e: &tast::Expr) -> Includ } } -fn text_of_expr(e: &tast::Expr) -> String { +fn text_of_expr(e: &ast::Expr) -> String { match &e.2 { - tast::Expr_::String(s) => format!("\'{}\'", s), - tast::Expr_::Id(id) => id.1.to_string(), - tast::Expr_::Lvar(lid) => local_id::get_name(&lid.1).to_string(), - tast::Expr_::ArrayGet(x) => match ((x.0).2.as_lvar(), x.1.as_ref()) { - (Some(tast::Lid(_, id)), Some(e_)) => { + ast::Expr_::String(s) => format!("\'{}\'", s), + ast::Expr_::Id(id) => id.1.to_string(), + ast::Expr_::Lvar(lid) => local_id::get_name(&lid.1).to_string(), + ast::Expr_::ArrayGet(x) => match ((x.0).2.as_lvar(), x.1.as_ref()) { + (Some(ast::Lid(_, id)), Some(e_)) => { format!("{}[{}]", local_id::get_name(&id), text_of_expr(e_)) } _ => "unknown".into(), @@ -697,20 +697,20 @@ fn text_of_expr(e: &tast::Expr) -> String { } } -fn text_of_class_id(cid: &tast::ClassId) -> String { +fn text_of_class_id(cid: &ast::ClassId) -> String { match &cid.2 { - tast::ClassId_::CIparent => "parent".into(), - tast::ClassId_::CIself => "self".into(), - tast::ClassId_::CIstatic => "static".into(), - tast::ClassId_::CIexpr(e) => text_of_expr(e), - tast::ClassId_::CI(ast_defs::Id(_, id)) => id.into(), + ast::ClassId_::CIparent => "parent".into(), + ast::ClassId_::CIself => "self".into(), + ast::ClassId_::CIstatic => "static".into(), + ast::ClassId_::CIexpr(e) => text_of_expr(e), + ast::ClassId_::CI(ast_defs::Id(_, id)) => id.into(), } } -fn text_of_prop(prop: &tast::ClassGetExpr) -> String { +fn text_of_prop(prop: &ast::ClassGetExpr) -> String { match prop { - tast::ClassGetExpr::CGstring((_, s)) => s.into(), - tast::ClassGetExpr::CGexpr(e) => text_of_expr(e), + ast::ClassGetExpr::CGstring((_, s)) => s.into(), + ast::ClassGetExpr::CGexpr(e) => text_of_expr(e), } } @@ -718,10 +718,10 @@ fn emit_import<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - flavor: &tast::ImportFlavor, - expr: &tast::Expr, + flavor: &ast::ImportFlavor, + expr: &ast::Expr, ) -> Result> { - use tast::ImportFlavor; + use ast::ImportFlavor; let alloc = env.arena; let inc = parse_include(alloc, expr); emit_symbol_refs::add_include(alloc, e, inc.clone()); @@ -732,8 +732,7 @@ fn emit_import<'a, 'arena, 'decl, D: DeclProvider<'decl>>( ImportFlavor::RequireOnce => { match inc.into_doc_root_relative(alloc, e.options().hhvm.include_roots.get()) { IncludePath::DocRootRelative(path) => { - let expr = - tast::Expr((), pos.clone(), tast::Expr_::String(path.as_str().into())); + let expr = ast::Expr((), pos.clone(), ast::Expr_::String(path.as_str().into())); (emit_expr(e, env, &expr)?, instr::reqdoc(alloc)) } _ => (emit_expr(e, env, expr)?, instr::reqonce(alloc)), @@ -750,7 +749,7 @@ fn emit_string2<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - es: &[tast::Expr], + es: &[ast::Expr], ) -> Result> { let alloc = env.arena; if es.is_empty() { @@ -795,7 +794,7 @@ fn emit_string2<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn emit_clone<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - expr: &tast::Expr, + expr: &ast::Expr, ) -> Result> { let alloc = env.arena; Ok(InstrSeq::gather( @@ -807,7 +806,7 @@ fn emit_clone<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn emit_lambda<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - fndef: &tast::Fun_, + fndef: &ast::Fun_, ids: &[aast_defs::Lid], ) -> Result> { let alloc = env.arena; @@ -825,7 +824,7 @@ fn emit_lambda<'a, 'arena, 'decl, D: DeclProvider<'decl>>( InstrSeq::gather( alloc, ids.iter() - .map(|tast::Lid(pos, id)| { + .map(|ast::Lid(pos, id)| { match string_utils::reified::is_captured_generic(local_id::get_name(id)) { Some((is_fun, i)) => { if is_in_lambda { @@ -869,9 +868,9 @@ pub fn emit_await<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - expr: &tast::Expr, + expr: &ast::Expr, ) -> Result> { - let tast::Expr(_, _, e) = expr; + let ast::Expr(_, _, e) = expr; let alloc = env.arena; let cant_inline_gen_functions = !emitter .options() @@ -879,7 +878,7 @@ pub fn emit_await<'a, 'arena, 'decl, D: DeclProvider<'decl>>( .flags .contains(HhvmFlags::JIT_ENABLE_RENAME_FUNCTION); match e.as_call() { - Some((tast::Expr(_, _, tast::Expr_::Id(id)), _, args, None)) + Some((ast::Expr(_, _, ast::Expr_::Id(id)), _, args, None)) if (cant_inline_gen_functions && args.len() == 1 && string_utils::strip_global_ns(&(*id.1)) == "gena") => @@ -889,7 +888,7 @@ pub fn emit_await<'a, 'arena, 'decl, D: DeclProvider<'decl>>( _ => { let after_await = emitter.label_gen_mut().next_regular(); let instrs = match e { - tast::Expr_::Call(c) => { + ast::Expr_::Call(c) => { emit_call_expr(emitter, env, pos, Some(after_await.clone()), &*c)? } _ => emit_expr(emitter, env, expr)?, @@ -913,7 +912,7 @@ pub fn emit_await<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn inline_gena_call<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - arg: &tast::Expr, + arg: &ast::Expr, ) -> Result> { let alloc = env.arena; let load_arr = emit_expr(emitter, env, arg)?; @@ -1030,18 +1029,18 @@ fn emit_iter< fn emit_shape<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emitter: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - expr: &tast::Expr, - fl: &[(ast_defs::ShapeFieldName, tast::Expr)], + expr: &ast::Expr, + fl: &[(ast_defs::ShapeFieldName, ast::Expr)], ) -> Result> { fn extract_shape_field_name_pstring<'a, 'arena>( env: &Env<'a, 'arena>, pos: &Pos, field: &ast_defs::ShapeFieldName, - ) -> Result { + ) -> Result { use ast_defs::ShapeFieldName as SF; Ok(match field { - SF::SFlitInt(s) => tast::Expr_::mk_int(s.1.clone()), - SF::SFlitStr(s) => tast::Expr_::mk_string(s.1.clone()), + SF::SFlitInt(s) => ast::Expr_::mk_int(s.1.clone()), + SF::SFlitStr(s) => ast::Expr_::mk_string(s.1.clone()), SF::SFclassConst(id, p) => { if is_reified_tparam(env, true, &id.1).is_some() || is_reified_tparam(env, false, &id.1).is_some() @@ -1051,8 +1050,8 @@ fn emit_shape<'a, 'arena, 'decl, D: DeclProvider<'decl>>( "Reified generics cannot be used in shape keys", )); } else { - tast::Expr_::mk_class_const( - tast::ClassId((), pos.clone(), tast::ClassId_::CI(id.clone())), + ast::Expr_::mk_class_const( + ast::ClassId((), pos.clone(), ast::ClassId_::CI(id.clone())), p.clone(), ) } @@ -1065,7 +1064,7 @@ fn emit_shape<'a, 'arena, 'decl, D: DeclProvider<'decl>>( .iter() .map(|(f, e)| { Ok(( - tast::Expr( + ast::Expr( (), pos.clone(), extract_shape_field_name_pstring(env, pos, f)?, @@ -1077,7 +1076,7 @@ fn emit_shape<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emit_expr( emitter, env, - &tast::Expr((), pos.clone(), tast::Expr_::mk_darray(None, fl)), + &ast::Expr((), pos.clone(), ast::Expr_::mk_darray(None, fl)), ) } @@ -1085,7 +1084,7 @@ fn emit_vec_collection<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - fields: &[tast::Afield], + fields: &[ast::Afield], ) -> Result> { let alloc = env.arena; match ast_constant_folder::vec_to_typed_value(alloc, e, fields) { @@ -1098,8 +1097,8 @@ fn emit_named_collection<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - expr: &tast::Expr, - fields: &[tast::Afield], + expr: &ast::Expr, + fields: &[ast::Afield], collection_type: CollectionType, ) -> Result> { let alloc = env.arena; @@ -1143,7 +1142,7 @@ fn emit_named_collection<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fields .iter() .map(|f| match f { - tast::Afield::AFvalue(v) => emit_expr(e, env, v), + ast::Afield::AFvalue(v) => emit_expr(e, env, v), _ => Err(unrecoverable("impossible Pair argument")), }) .collect::>()?, @@ -1158,11 +1157,11 @@ fn emit_named_collection<'a, 'arena, 'decl, D: DeclProvider<'decl>>( fn emit_named_collection_str<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - expr: &tast::Expr, + expr: &ast::Expr, (ast_defs::Id(pos, name), _, fields): &( - tast::Sid, - Option, - Vec, + ast::Sid, + Option, + Vec, ), ) -> Result> { let name = string_utils::strip_ns(name); @@ -1189,25 +1188,25 @@ fn emit_named_collection_str<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emit_named_collection(e, env, pos, expr, fields, ctype) } -fn mk_afkvalues(es: &[(tast::Expr, tast::Expr)]) -> Vec { +fn mk_afkvalues(es: &[(ast::Expr, ast::Expr)]) -> Vec { es.to_owned() .into_iter() - .map(|(e1, e2)| tast::Afield::mk_afkvalue(e1, e2)) + .map(|(e1, e2)| ast::Afield::mk_afkvalue(e1, e2)) .collect() } -fn mk_afvalues(es: &[tast::Expr]) -> Vec { +fn mk_afvalues(es: &[ast::Expr]) -> Vec { es.to_owned() .into_iter() - .map(tast::Afield::mk_afvalue) + .map(ast::Afield::mk_afvalue) .collect() } fn emit_collection<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - expr: &tast::Expr, - fields: &[tast::Afield], + expr: &ast::Expr, + fields: &[ast::Afield], transform_to_collection: Option, ) -> Result> { let alloc = env.arena; @@ -1248,11 +1247,11 @@ fn expr_and_new<'a, 'arena, 'decl, D: DeclProvider<'decl>>( pos: &Pos, instr_to_add_new: InstrSeq<'arena>, instr_to_add: InstrSeq<'arena>, - field: &tast::Afield, + field: &ast::Afield, ) -> Result> { let alloc = env.arena; match field { - tast::Afield::AFvalue(v) => Ok(InstrSeq::gather( + ast::Afield::AFvalue(v) => Ok(InstrSeq::gather( alloc, vec![ emit_expr(e, env, v)?, @@ -1260,7 +1259,7 @@ fn expr_and_new<'a, 'arena, 'decl, D: DeclProvider<'decl>>( instr_to_add_new, ], )), - tast::Afield::AFkvalue(k, v) => Ok(InstrSeq::gather( + ast::Afield::AFkvalue(k, v) => Ok(InstrSeq::gather( alloc, vec![emit_two_exprs(e, env, &k.1, k, v)?, instr_to_add], )), @@ -1271,7 +1270,7 @@ fn emit_keyvalue_collection<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - fields: &[tast::Afield], + fields: &[ast::Afield], ctype: CollectionType, constructor: InstructLitConst<'arena>, ) -> Result> { @@ -1387,19 +1386,19 @@ fn non_numeric(s: &str) -> bool { fn is_struct_init<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - fields: &[tast::Afield], + fields: &[ast::Afield], allow_numerics: bool, ) -> Result { let alloc = env.arena; let mut are_all_keys_non_numeric_strings = true; let mut uniq_keys = HashSet::::default(); for f in fields.iter() { - if let tast::Afield::AFkvalue(key, _) = f { + if let ast::Afield::AFkvalue(key, _) = f { // TODO(hrust): if key is String, don't clone and call fold_expr let mut key = key.clone(); ast_constant_folder::fold_expr(&mut key, alloc, e) .map_err(|e| unrecoverable(format!("{}", e)))?; - if let tast::Expr(_, _, tast::Expr_::String(s)) = key { + if let ast::Expr(_, _, ast::Expr_::String(s)) = key { are_all_keys_non_numeric_strings = are_all_keys_non_numeric_strings && non_numeric( // FIXME: This is not safe--string literals are binary strings. @@ -1436,15 +1435,15 @@ fn emit_struct_array< e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - fields: &[tast::Afield], + fields: &[ast::Afield], ctor: C, ) -> Result> { - use tast::{Expr as E, Expr_ as E_}; + use ast::{Expr as E, Expr_ as E_}; let alloc = env.arena; let (keys, value_instrs): (Vec, _) = fields .iter() .map(|f| match f { - tast::Afield::AFkvalue(k, v) => match k { + ast::Afield::AFkvalue(k, v) => match k { E(_, _, E_::String(s)) => Ok(( // FIXME: This is not safe--string literals are binary strings. // There's no guarantee that they're valid UTF-8. @@ -1490,8 +1489,8 @@ fn emit_struct_array< fn emit_dynamic_collection<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, - expr: &tast::Expr, - fields: &[tast::Afield], + expr: &ast::Expr, + fields: &[ast::Afield], ) -> Result> { let alloc = env.arena; let pos = &expr.1; @@ -1523,45 +1522,45 @@ fn emit_dynamic_collection<'a, 'arena, 'decl, D: DeclProvider<'decl>>( emit_keyvalue_collection(e, env, pos, fields, ctype, ctor) } }; - use tast::Expr_ as E_; + use ast::Expr_ as E_; match &expr.2 { - E_::ValCollection(v) if v.0 == tast::VcKind::Vec => { + E_::ValCollection(v) if v.0 == ast::VcKind::Vec => { emit_value_only_collection(e, env, pos, fields, InstructLitConst::NewVec) } E_::Collection(v) if (v.0).1 == "vec" => { emit_value_only_collection(e, env, pos, fields, InstructLitConst::NewVec) } E_::Tuple(_) => emit_value_only_collection(e, env, pos, fields, InstructLitConst::NewVec), - E_::ValCollection(v) if v.0 == tast::VcKind::Keyset => { + E_::ValCollection(v) if v.0 == ast::VcKind::Keyset => { emit_value_only_collection(e, env, pos, fields, InstructLitConst::NewKeysetArray) } E_::Collection(v) if (v.0).1 == "keyset" => { emit_value_only_collection(e, env, pos, fields, InstructLitConst::NewKeysetArray) } E_::Collection(v) if (v.0).1 == "dict" => emit_dict(e), - E_::KeyValCollection(v) if v.0 == tast::KvcKind::Dict => emit_dict(e), + E_::KeyValCollection(v) if v.0 == ast::KvcKind::Dict => emit_dict(e), E_::Collection(v) if string_utils::strip_ns(&(v.0).1) == "Set" => { emit_collection_helper(e, CollectionType::Set) } - E_::ValCollection(v) if v.0 == tast::VcKind::Set => { + E_::ValCollection(v) if v.0 == ast::VcKind::Set => { emit_collection_helper(e, CollectionType::Set) } E_::Collection(v) if string_utils::strip_ns(&(v.0).1) == "ImmSet" => { emit_collection_helper(e, CollectionType::ImmSet) } - E_::ValCollection(v) if v.0 == tast::VcKind::ImmSet => { + E_::ValCollection(v) if v.0 == ast::VcKind::ImmSet => { emit_collection_helper(e, CollectionType::ImmSet) } E_::Collection(v) if string_utils::strip_ns(&(v.0).1) == "Map" => { emit_collection_helper(e, CollectionType::Map) } - E_::KeyValCollection(v) if v.0 == tast::KvcKind::Map => { + E_::KeyValCollection(v) if v.0 == ast::KvcKind::Map => { emit_collection_helper(e, CollectionType::Map) } E_::Collection(v) if string_utils::strip_ns(&(v.0).1) == "ImmMap" => { emit_collection_helper(e, CollectionType::ImmMap) } - E_::KeyValCollection(v) if v.0 == tast::KvcKind::ImmMap => { + E_::KeyValCollection(v) if v.0 == ast::KvcKind::ImmMap => { emit_collection_helper(e, CollectionType::ImmMap) } E_::Varray(_) => { @@ -1596,7 +1595,7 @@ fn emit_value_only_collection< e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - fields: &[tast::Afield], + fields: &[ast::Afield], constructor: F, ) -> Result> { let alloc = env.arena; @@ -1604,7 +1603,7 @@ fn emit_value_only_collection< let inline = | alloc: &'arena bumpalo::Bump, e: &mut Emitter<'arena, 'decl, D>, - exprs: &[tast::Afield], + exprs: &[ast::Afield], | -> Result> { let mut instrs = vec![]; for expr in exprs.iter() { @@ -1623,7 +1622,7 @@ fn emit_value_only_collection< let outofline = | alloc: &'arena bumpalo::Bump, e: &mut Emitter<'arena, 'decl, D>, - exprs: &[tast::Afield], + exprs: &[ast::Afield], | -> Result> { let mut instrs = vec![]; for expr in exprs.iter() { @@ -1648,7 +1647,7 @@ fn emit_record<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - (cid, es): &(tast::Sid, Vec<(tast::Expr, tast::Expr)>), + (cid, es): &(ast::Sid, Vec<(ast::Expr, ast::Expr)>), ) -> Result> { let alloc = env.arena; let es = mk_afkvalues(es); @@ -1663,7 +1662,7 @@ fn emit_call_isset_expr<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, outer_pos: &Pos, - expr: &tast::Expr, + expr: &ast::Expr, ) -> Result> { let alloc = env.arena; let pos = &expr.1; @@ -1734,7 +1733,7 @@ fn emit_call_isset_exprs<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - exprs: &[tast::Expr], + exprs: &[ast::Expr], ) -> Result> { let alloc = env.arena; match exprs { @@ -1786,7 +1785,7 @@ fn emit_tag_provenance_here<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - es: &[tast::Expr], + es: &[ast::Expr], ) -> Result> { let alloc = env.arena; let pop = if es.len() == 1 { @@ -1804,7 +1803,7 @@ fn emit_array_mark_legacy<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - es: &[tast::Expr], + es: &[ast::Expr], legacy: bool, ) -> Result> { let alloc = env.arena; @@ -1828,7 +1827,7 @@ fn emit_idx<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - es: &[tast::Expr], + es: &[ast::Expr], ) -> Result> { let alloc = env.arena; let default = if es.len() == 2 { @@ -1851,10 +1850,10 @@ fn emit_call<'a, 'arena, 'decl, D: DeclProvider<'decl>>( e: &mut Emitter<'arena, 'decl, D>, env: &Env<'a, 'arena>, pos: &Pos, - expr: &tast::Expr, - targs: &[tast::Targ], - args: &[tast::Expr], - uarg: Option<&tast::Expr>, + expr: &ast::Expr, + targs: &[ast::Targ], + args: &[ast::Expr], + uarg: Option<&ast::Expr>, async_eager_label: Option