diff --git a/src/parse.y b/src/parse.y
index 03a9f4cb68..189b72d660 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -112,12 +112,14 @@ extern int brolex();
 #define YYLLOC_DEFAULT(Current, Rhs, N) \
 	(Current) = (Rhs)[(N)];
 
+using namespace zeek;
+using namespace zeek::detail;
+
 /*
  * Part of the module facility: while parsing, keep track of which
  * module to put things in.
  */
 std::string zeek::detail::current_module = GLOBAL_MODULE_NAME;
-std::string& current_module = zeek::detail::current_module;
 
 bool is_export = false; // true if in an export {} block
 
@@ -125,7 +127,7 @@ bool is_export = false; // true if in an export {} block
  * When parsing an expression for the debugger, where to put the result
  * (obviously not reentrant).
  */
-extern zeek::detail::Expr* g_curr_debug_expr;
+extern Expr* g_curr_debug_expr;
 extern bool in_debug;
 extern const char* g_curr_debug_error;
 
@@ -139,9 +141,9 @@ bool resolving_global_ID = false;
 bool defining_global_ID = false;
 std::vector<int> saved_in_init;
 
-static zeek::detail::Location func_hdr_location;
-zeek::EnumType* cur_enum_type = nullptr;
-static zeek::detail::ID* cur_decl_type_id = nullptr;
+static Location func_hdr_location;
+EnumType* cur_enum_type = nullptr;
+static ID* cur_decl_type_id = nullptr;
 
 static void parse_new_enum (void)
 	{
@@ -150,14 +152,14 @@ static void parse_new_enum (void)
 
 	if ( cur_decl_type_id )
 		{
-		auto name = zeek::detail::make_full_var_name(current_module.c_str(), cur_decl_type_id->Name());
-		cur_enum_type = new zeek::EnumType(name);
+		auto name = make_full_var_name(current_module.c_str(), cur_decl_type_id->Name());
+		cur_enum_type = new EnumType(name);
 		}
 	else
-		zeek::reporter->FatalError("incorrect syntax for enum type declaration");
+		reporter->FatalError("incorrect syntax for enum type declaration");
 	}
 
-static void parse_redef_enum (zeek::detail::ID* id)
+static void parse_redef_enum (ID* id)
 	{
 	/* Redef an enum. id points to the enum to be redefined.
 	   Let cur_enum_type point to it. */
@@ -165,19 +167,19 @@ static void parse_redef_enum (zeek::detail::ID* id)
 
 	// abort on errors; enums need to be accessible to continue parsing
 	if ( ! id->GetType() )
-		zeek::reporter->FatalError("unknown enum identifier \"%s\"", id->Name());
+		reporter->FatalError("unknown enum identifier \"%s\"", id->Name());
 	else
 		{
-		if ( ! id->GetType() || id->GetType()->Tag() != zeek::TYPE_ENUM )
-			zeek::reporter->FatalError("identifier \"%s\" is not an enum", id->Name());
+		if ( ! id->GetType() || id->GetType()->Tag() != TYPE_ENUM )
+			reporter->FatalError("identifier \"%s\" is not an enum", id->Name());
 		cur_enum_type = id->GetType()->AsEnumType();
 		}
 	}
 
-static void extend_record(zeek::detail::ID* id, std::unique_ptr<zeek::type_decl_list> fields,
-                          std::unique_ptr<std::vector<zeek::detail::AttrPtr>> attrs)
+static void extend_record(ID* id, std::unique_ptr<type_decl_list> fields,
+                          std::unique_ptr<std::vector<AttrPtr>> attrs)
 	{
-	const auto& types = zeek::Type::Aliases(id->Name());
+	const auto& types = Type::Aliases(id->Name());
 
 	if ( types.empty() )
 		{
@@ -189,7 +191,7 @@ static void extend_record(zeek::detail::ID* id, std::unique_ptr<zeek::type_decl_
 
 	if ( attrs )
 		for ( const auto& at : *attrs )
-			if ( at->Tag() == zeek::detail::ATTR_LOG )
+			if ( at->Tag() == ATTR_LOG )
 				{
 				add_log_attr = true;
 				break;
@@ -207,22 +209,22 @@ static void extend_record(zeek::detail::ID* id, std::unique_ptr<zeek::type_decl_
 		}
 	}
 
-static zeek::detail::AttributesPtr
-make_attributes(std::vector<zeek::detail::AttrPtr>* attrs,
-                zeek::TypePtr t, bool in_record, bool is_global)
+static AttributesPtr
+make_attributes(std::vector<AttrPtr>* attrs,
+                TypePtr t, bool in_record, bool is_global)
 	{
 	if ( ! attrs )
 		return nullptr;
 
-	auto rval = zeek::make_intrusive<zeek::detail::Attributes>(std::move(*attrs), std::move(t),
+	auto rval = make_intrusive<Attributes>(std::move(*attrs), std::move(t),
 	                                       in_record, is_global);
 	delete attrs;
 	return rval;
 	}
 
-static bool expr_is_table_type_name(const zeek::detail::Expr* expr)
+static bool expr_is_table_type_name(const Expr* expr)
 	{
-	if ( expr->Tag() != zeek::detail::EXPR_NAME )
+	if ( expr->Tag() != EXPR_NAME )
 		return false;
 
 	const auto& type = expr->GetType();
@@ -230,7 +232,7 @@ static bool expr_is_table_type_name(const zeek::detail::Expr* expr)
 	if ( type->IsTable() )
 		return true;
 
-	if ( type->Tag() == zeek::TYPE_TYPE )
+	if ( type->Tag() == TYPE_TYPE )
 		return type->AsTypeType()->GetType()->IsTable();
 
 	return false;
@@ -269,14 +271,14 @@ static bool expr_is_table_type_name(const zeek::detail::Expr* expr)
 zeek:
 		decl_list stmt_list
 			{
-			if ( zeek::detail::stmts )
-				zeek::detail::stmts->AsStmtList()->Stmts().push_back($2);
+			if ( stmts )
+				stmts->AsStmtList()->Stmts().push_back($2);
 			else
-				zeek::detail::stmts = $2;
+				stmts = $2;
 
 			// Any objects creates from here on out should not
 			// have file positions associated with them.
-			zeek::detail::set_location(zeek::detail::no_location);
+			set_location(no_location);
 			}
 	|
 		/* Silly way of allowing the debugger to call yyparse()
@@ -308,58 +310,58 @@ when_condition:
 expr:
 		'(' expr ')'
 			{
-			zeek::detail::set_location(@1, @3);
+			set_location(@1, @3);
 			$$ = $2; $$->MarkParen();
 			}
 
 	|	TOK_COPY '(' expr ')'
 			{
-			zeek::detail::set_location(@1, @4);
-			$$ = new zeek::detail::CloneExpr({zeek::AdoptRef{}, $3});
+			set_location(@1, @4);
+			$$ = new CloneExpr({AdoptRef{}, $3});
 			}
 
 	|	TOK_INCR expr
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::IncrExpr(zeek::detail::EXPR_INCR, {zeek::AdoptRef{}, $2});
+			set_location(@1, @2);
+			$$ = new IncrExpr(EXPR_INCR, {AdoptRef{}, $2});
 			}
 
 	|	TOK_DECR expr
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::IncrExpr(zeek::detail::EXPR_DECR, {zeek::AdoptRef{}, $2});
+			set_location(@1, @2);
+			$$ = new IncrExpr(EXPR_DECR, {AdoptRef{}, $2});
 			}
 
 	|	'!' expr
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::NotExpr({zeek::AdoptRef{}, $2});
+			set_location(@1, @2);
+			$$ = new NotExpr({AdoptRef{}, $2});
 			}
 
 	|	'~' expr
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::ComplementExpr({zeek::AdoptRef{}, $2});
+			set_location(@1, @2);
+			$$ = new ComplementExpr({AdoptRef{}, $2});
 			}
 
 	|	'-' expr	%prec '!'
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::NegExpr({zeek::AdoptRef{}, $2});
+			set_location(@1, @2);
+			$$ = new NegExpr({AdoptRef{}, $2});
 
 			if ( ! $$->IsError() && $2->IsConst() )
 				{
 				auto v = $2->ExprVal();
 				auto tag = v->GetType()->Tag();
 
-				if ( tag == zeek::TYPE_COUNT )
+				if ( tag == TYPE_COUNT )
 					{
 					auto c = v->AsCount();
 					uint64_t int_max = static_cast<uint64_t>(INT64_MAX) + 1;
 
 					if ( c <= int_max )
 						{
-						auto ce = new zeek::detail::ConstExpr(zeek::val_mgr->Int(-c));
+						auto ce = new ConstExpr(val_mgr->Int(-c));
 						Unref($$);
 						$$ = ce;
 						}
@@ -371,7 +373,7 @@ expr:
 					}
 				else
 					{
-					auto ce = new zeek::detail::ConstExpr($$->Eval(nullptr));
+					auto ce = new ConstExpr($$->Eval(nullptr));
 					Unref($$);
 					$$ = ce;
 					}
@@ -380,164 +382,164 @@ expr:
 
 	|	'+' expr	%prec '!'
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::PosExpr({zeek::AdoptRef{}, $2});
+			set_location(@1, @2);
+			$$ = new PosExpr({AdoptRef{}, $2});
 			}
 
 	|	expr '+' expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::AddExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new AddExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_ADD_TO expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::AddToExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new AddToExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '-' expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::SubExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new SubExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_REMOVE_FROM expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::RemoveFromExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new RemoveFromExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '*' expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::TimesExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new TimesExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '/' expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::DivideExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new DivideExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '%' expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::ModExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new ModExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '&' expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::BitExpr(zeek::detail::EXPR_AND, {zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new BitExpr(EXPR_AND, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '|' expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::BitExpr(zeek::detail::EXPR_OR, {zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new BitExpr(EXPR_OR, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '^' expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::BitExpr(zeek::detail::EXPR_XOR, {zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new BitExpr(EXPR_XOR, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_AND_AND expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::BoolExpr(zeek::detail::EXPR_AND_AND, {zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new BoolExpr(EXPR_AND_AND, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_OR_OR expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::BoolExpr(zeek::detail::EXPR_OR_OR, {zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new BoolExpr(EXPR_OR_OR, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_EQ expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::EqExpr(zeek::detail::EXPR_EQ, {zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new EqExpr(EXPR_EQ, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_NE expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::EqExpr(zeek::detail::EXPR_NE, {zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new EqExpr(EXPR_NE, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '<' expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::RelExpr(zeek::detail::EXPR_LT, {zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new RelExpr(EXPR_LT, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_LE expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::RelExpr(zeek::detail::EXPR_LE, {zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new RelExpr(EXPR_LE, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '>' expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::RelExpr(zeek::detail::EXPR_GT, {zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new RelExpr(EXPR_GT, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_GE expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::RelExpr(zeek::detail::EXPR_GE, {zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new RelExpr(EXPR_GE, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '?' expr ':' expr
 			{
-			zeek::detail::set_location(@1, @5);
-			$$ = new zeek::detail::CondExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3}, {zeek::AdoptRef{}, $5});
+			set_location(@1, @5);
+			$$ = new CondExpr({AdoptRef{}, $1}, {AdoptRef{}, $3}, {AdoptRef{}, $5});
 			}
 
 	|	expr '=' expr
 			{
-			zeek::detail::set_location(@1, @3);
+			set_location(@1, @3);
 
-			if ( $1->Tag() == zeek::detail::EXPR_INDEX && $1->AsIndexExpr()->IsSlice() )
-				zeek::reporter->Error("index slice assignment may not be used"
+			if ( $1->Tag() == EXPR_INDEX && $1->AsIndexExpr()->IsSlice() )
+				reporter->Error("index slice assignment may not be used"
 				                      " in arbitrary expression contexts, only"
 				                      " as a statement");
 
-			$$ = zeek::detail::get_assign_expr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3}, in_init).release();
+			$$ = get_assign_expr({AdoptRef{}, $1}, {AdoptRef{}, $3}, in_init).release();
 			}
 
 	|	TOK_LOCAL local_id '=' expr
 			{
-			zeek::detail::set_location(@2, @4);
-			$$ = zeek::detail::add_and_assign_local({zeek::AdoptRef{}, $2}, {zeek::AdoptRef{}, $4},
-			                                        zeek::val_mgr->True()).release();
+			set_location(@2, @4);
+			$$ = add_and_assign_local({AdoptRef{}, $2}, {AdoptRef{}, $4},
+			                                        val_mgr->True()).release();
 			}
 
 	|	expr '[' expr_list ']'
 			{
-			zeek::detail::set_location(@1, @4);
+			set_location(@1, @4);
 			if ( in_when_cond > 0 )
-				$$ = new zeek::detail::IndexExprWhen({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+				$$ = new IndexExprWhen({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			else
-				$$ = new zeek::detail::IndexExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+				$$ = new IndexExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	index_slice
 
 	|	expr '$' TOK_ID
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::FieldExpr({zeek::AdoptRef{}, $1}, $3);
+			set_location(@1, @3);
+			$$ = new FieldExpr({AdoptRef{}, $1}, $3);
 			}
 
 	|	'$' TOK_ID '=' expr
 			{
-			zeek::detail::set_location(@1, @4);
-			$$ = new zeek::detail::FieldAssignExpr($2, {zeek::AdoptRef{}, $4});
+			set_location(@1, @4);
+			$$ = new FieldAssignExpr($2, {AdoptRef{}, $4});
 			}
 
 	|	'$' TOK_ID begin_lambda '='
@@ -547,26 +549,26 @@ expr:
 			}
 		 lambda_body
 			{
-			$$ = new zeek::detail::FieldAssignExpr($2, zeek::IntrusivePtr{zeek::AdoptRef{}, $6});
+			$$ = new FieldAssignExpr($2, IntrusivePtr{AdoptRef{}, $6});
 			}
 
 	|	expr TOK_IN expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::InExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new InExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_NOT_IN expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::NotExpr(zeek::make_intrusive<zeek::detail::InExpr>(
-			        zeek::detail::ExprPtr{zeek::AdoptRef{}, $1},
-			        zeek::detail::ExprPtr{zeek::AdoptRef{}, $3}));
+			set_location(@1, @3);
+			$$ = new NotExpr(make_intrusive<InExpr>(
+			        ExprPtr{AdoptRef{}, $1},
+			        ExprPtr{AdoptRef{}, $3}));
 			}
 
 	|	'[' expr_list ']'
 			{
-			zeek::detail::set_location(@1, @3);
+			set_location(@1, @3);
 
 			bool is_record_ctor = true;
 
@@ -576,7 +578,7 @@ expr:
 
 			for ( int i = 0; i < $2->Exprs().length(); ++i )
 				{
-				if ( $2->Exprs()[i]->Tag() != zeek::detail::EXPR_FIELD_ASSIGN )
+				if ( $2->Exprs()[i]->Tag() != EXPR_FIELD_ASSIGN )
 					{
 					is_record_ctor = false;
 					break;
@@ -584,7 +586,7 @@ expr:
 				}
 
 			if ( is_record_ctor )
-				$$ = new zeek::detail::RecordConstructorExpr({zeek::AdoptRef{}, $2});
+				$$ = new RecordConstructorExpr({AdoptRef{}, $2});
 			else
 				$$ = $2;
 			}
@@ -592,35 +594,35 @@ expr:
 	|	'[' ']'
 			{
 			// We interpret this as an empty record constructor.
-			$$ = new zeek::detail::RecordConstructorExpr(zeek::make_intrusive<zeek::detail::ListExpr>());
+			$$ = new RecordConstructorExpr(make_intrusive<ListExpr>());
 			}
 
 
 	|	TOK_RECORD '(' expr_list ')'
 			{
-			zeek::detail::set_location(@1, @4);
-			$$ = new zeek::detail::RecordConstructorExpr({zeek::AdoptRef{}, $3});
+			set_location(@1, @4);
+			$$ = new RecordConstructorExpr({AdoptRef{}, $3});
 			}
 
 	|	TOK_TABLE '(' { ++in_init; } opt_expr_list ')' { --in_init; }
 		opt_attr
 			{ // the ++in_init fixes up the parsing of "[x] = y"
-			zeek::detail::set_location(@1, @5);
-			std::unique_ptr<std::vector<zeek::detail::AttrPtr>> attrs{$7};
-			$$ = new zeek::detail::TableConstructorExpr({zeek::AdoptRef{}, $4}, std::move(attrs));
+			set_location(@1, @5);
+			std::unique_ptr<std::vector<AttrPtr>> attrs{$7};
+			$$ = new TableConstructorExpr({AdoptRef{}, $4}, std::move(attrs));
 			}
 
 	|	TOK_SET '(' opt_expr_list ')' opt_attr
 			{
-			zeek::detail::set_location(@1, @4);
-			std::unique_ptr<std::vector<zeek::detail::AttrPtr>> attrs{$5};
-			$$ = new zeek::detail::SetConstructorExpr({zeek::AdoptRef{}, $3}, std::move(attrs));
+			set_location(@1, @4);
+			std::unique_ptr<std::vector<AttrPtr>> attrs{$5};
+			$$ = new SetConstructorExpr({AdoptRef{}, $3}, std::move(attrs));
 			}
 
 	|	TOK_VECTOR '(' opt_expr_list ')'
 			{
-			zeek::detail::set_location(@1, @4);
-			$$ = new zeek::detail::VectorConstructorExpr({zeek::AdoptRef{}, $3});
+			set_location(@1, @4);
+			$$ = new VectorConstructorExpr({AdoptRef{}, $3});
 			}
 
 	|	expr '('
@@ -637,32 +639,32 @@ expr:
 
 		')'
 			{
-			zeek::detail::set_location(@1, @6);
+			set_location(@1, @6);
 
-			if ( $1->Tag() == zeek::detail::EXPR_NAME && $1->AsNameExpr()->Id()->IsType() )
+			if ( $1->Tag() == EXPR_NAME && $1->AsNameExpr()->Id()->IsType() )
 				{
 				const auto& ctor_type = $1->AsNameExpr()->Id()->GetType();
 
 				switch ( ctor_type->Tag() ) {
-				case zeek::TYPE_RECORD:
+				case TYPE_RECORD:
 					{
-					auto rce = zeek::make_intrusive<zeek::detail::RecordConstructorExpr>(
-						zeek::detail::ListExprPtr{zeek::AdoptRef{}, $4});
-					auto rt = zeek::cast_intrusive<zeek::RecordType>(ctor_type);
-					$$ = new zeek::detail::RecordCoerceExpr(std::move(rce), std::move(rt));
+					auto rce = make_intrusive<RecordConstructorExpr>(
+						ListExprPtr{AdoptRef{}, $4});
+					auto rt = cast_intrusive<RecordType>(ctor_type);
+					$$ = new RecordCoerceExpr(std::move(rce), std::move(rt));
 					}
 					break;
 
-				case zeek::TYPE_TABLE:
+				case TYPE_TABLE:
 					if ( ctor_type->IsTable() )
-						$$ = new zeek::detail::TableConstructorExpr({zeek::AdoptRef{}, $4}, 0, ctor_type);
+						$$ = new TableConstructorExpr({AdoptRef{}, $4}, 0, ctor_type);
 					else
-						$$ = new zeek::detail::SetConstructorExpr({zeek::AdoptRef{}, $4}, 0, ctor_type);
+						$$ = new SetConstructorExpr({AdoptRef{}, $4}, 0, ctor_type);
 
 					break;
 
-				case zeek::TYPE_VECTOR:
-					$$ = new zeek::detail::VectorConstructorExpr({zeek::AdoptRef{}, $4}, ctor_type);
+				case TYPE_VECTOR:
+					$$ = new VectorConstructorExpr({AdoptRef{}, $4}, ctor_type);
 					break;
 
 				default:
@@ -672,22 +674,22 @@ expr:
 				}
 
 			else
-				$$ = new zeek::detail::CallExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $4}, in_hook > 0);
+				$$ = new CallExpr({AdoptRef{}, $1}, {AdoptRef{}, $4}, in_hook > 0);
 			}
 
 	|	TOK_HOOK { ++in_hook; } expr
 			{
 			--in_hook;
-			zeek::detail::set_location(@1, @3);
-			if ( $3->Tag() != zeek::detail::EXPR_CALL )
+			set_location(@1, @3);
+			if ( $3->Tag() != EXPR_CALL )
 				$3->Error("not a valid hook call expression");
 			$$ = $3;
 			}
 
 	|	expr TOK_HAS_FIELD TOK_ID
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::HasFieldExpr({zeek::AdoptRef{}, $1}, $3);
+			set_location(@1, @3);
+			$$ = new HasFieldExpr({AdoptRef{}, $1}, $3);
 			}
 
 	|	anonymous_function
@@ -695,118 +697,118 @@ expr:
 
 	|	TOK_SCHEDULE expr '{' event '}'
 			{
-			zeek::detail::set_location(@1, @5);
-			$$ = new zeek::detail::ScheduleExpr({zeek::AdoptRef{}, $2}, {zeek::AdoptRef{}, $4});
+			set_location(@1, @5);
+			$$ = new ScheduleExpr({AdoptRef{}, $2}, {AdoptRef{}, $4});
 			}
 
 	|	TOK_ID
 			{
-			zeek::detail::set_location(@1);
-			auto id = zeek::detail::lookup_ID($1, zeek::detail::current_module.c_str());
+			set_location(@1);
+			auto id = lookup_ID($1, current_module.c_str());
 
 			if ( ! id )
 				{
 				if ( ! in_debug )
 					{
 /*	// CHECK THAT THIS IS NOT GLOBAL.
-					id = install_ID($1, zeek::detail::current_module.c_str(),
+					id = install_ID($1, current_module.c_str(),
 							        false, is_export);
 */
 
-					yyerror(zeek::util::fmt("unknown identifier %s", $1));
+					yyerror(util::fmt("unknown identifier %s", $1));
 					YYERROR;
 					}
 				else
 					{
-					yyerror(zeek::util::fmt("unknown identifier %s", $1));
+					yyerror(util::fmt("unknown identifier %s", $1));
 					YYERROR;
 					}
 				}
 			else
 				{
 				if ( id->IsDeprecated() )
-					zeek::reporter->Warning("%s", id->GetDeprecationWarning().c_str());
+					reporter->Warning("%s", id->GetDeprecationWarning().c_str());
 
 				if ( ! id->GetType() )
 					{
 					id->Error("undeclared variable");
-					id->SetType(zeek::error_type());
-					$$ = new zeek::detail::NameExpr(std::move(id));
+					id->SetType(error_type());
+					$$ = new NameExpr(std::move(id));
 					}
 
 				else if ( id->IsEnumConst() )
 					{
-					zeek::EnumType* t = id->GetType()->AsEnumType();
+					EnumType* t = id->GetType()->AsEnumType();
 					auto intval = t->Lookup(id->ModuleName(), id->Name());
 					if ( intval < 0 )
-						zeek::reporter->InternalError("enum value not found for %s", id->Name());
-					$$ = new zeek::detail::ConstExpr(t->GetEnumVal(intval));
+						reporter->InternalError("enum value not found for %s", id->Name());
+					$$ = new ConstExpr(t->GetEnumVal(intval));
 					}
 				else
 					{
-					$$ = new zeek::detail::NameExpr(std::move(id));
+					$$ = new NameExpr(std::move(id));
 					}
 				}
 			}
 
 	|	TOK_CONSTANT
 			{
-			zeek::detail::set_location(@1);
-			$$ = new zeek::detail::ConstExpr({zeek::AdoptRef{}, $1});
+			set_location(@1);
+			$$ = new ConstExpr({AdoptRef{}, $1});
 			}
 
 	|	'/' { begin_RE(); } TOK_PATTERN_TEXT TOK_PATTERN_END
 			{
-			zeek::detail::set_location(@3);
+			set_location(@3);
 
-			auto* re = new zeek::RE_Matcher($3);
+			auto* re = new RE_Matcher($3);
 			delete [] $3;
 
 			if ( $4 )
 				re->MakeCaseInsensitive();
 
 			re->Compile();
-			$$ = new zeek::detail::ConstExpr(zeek::make_intrusive<zeek::PatternVal>(re));
+			$$ = new ConstExpr(make_intrusive<PatternVal>(re));
 			}
 
 	|       '|' expr '|'	%prec '('
 			{
-			zeek::detail::set_location(@1, @3);
-			zeek::detail::ExprPtr e{zeek::AdoptRef{}, $2};
-			$$ = new zeek::detail::SizeExpr(std::move(e));
+			set_location(@1, @3);
+			ExprPtr e{AdoptRef{}, $2};
+			$$ = new SizeExpr(std::move(e));
 			}
 
 	|       expr TOK_AS type
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::CastExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new CastExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|       expr TOK_IS type
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::IsExpr({zeek::AdoptRef{}, $1}, {zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$$ = new IsExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 	;
 
 expr_list:
 		expr_list ',' expr
 			{
-			zeek::detail::set_location(@1, @3);
-			$1->Append({zeek::AdoptRef{}, $3});
+			set_location(@1, @3);
+			$1->Append({AdoptRef{}, $3});
 			}
 
 	|	expr
 			{
-			zeek::detail::set_location(@1);
-			$$ = new zeek::detail::ListExpr({zeek::AdoptRef{}, $1});
+			set_location(@1);
+			$$ = new ListExpr({AdoptRef{}, $1});
 			}
 	;
 
 opt_expr_list:
 		expr_list
 	|
-		{ $$ = new zeek::detail::ListExpr(); }
+		{ $$ = new ListExpr(); }
 	;
 
 enum_body:
@@ -837,13 +839,13 @@ enum_body_elem:
 		*/
 		TOK_ID '=' TOK_CONSTANT opt_deprecated
 			{
-			zeek::detail::set_location(@1, @3);
+			set_location(@1, @3);
 			assert(cur_enum_type);
 
-			if ( $3->GetType()->Tag() != zeek::TYPE_COUNT )
-				zeek::reporter->Error("enumerator is not a count constant");
+			if ( $3->GetType()->Tag() != TYPE_COUNT )
+				reporter->Error("enumerator is not a count constant");
 			else
-				cur_enum_type->AddName(zeek::detail::current_module, $1,
+				cur_enum_type->AddName(current_module, $1,
 				                       $3->InternalUnsigned(), is_export, $4,
 				                       in_enum_redef != 0);
 			}
@@ -854,94 +856,94 @@ enum_body_elem:
 			   error message if users triy to use a negative integer (will also
 			   catch other cases, but that's fine.)
 			*/
-			zeek::reporter->Error("enumerator is not a count constant");
+			reporter->Error("enumerator is not a count constant");
 			}
 
 	|	TOK_ID opt_deprecated
 			{
-			zeek::detail::set_location(@1);
+			set_location(@1);
 			assert(cur_enum_type);
-			cur_enum_type->AddName(zeek::detail::current_module, $1, is_export, $2,
+			cur_enum_type->AddName(current_module, $1, is_export, $2,
 			                       in_enum_redef != 0);
 			}
 	;
 
 type:
 		TOK_BOOL	{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_BOOL)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_BOOL)->Ref();
 				}
 
 	|	TOK_INT		{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_INT)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_INT)->Ref();
 				}
 
 	|	TOK_COUNT	{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_COUNT)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_COUNT)->Ref();
 				}
 
 	|	TOK_DOUBLE	{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_DOUBLE)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_DOUBLE)->Ref();
 				}
 
 	|	TOK_TIME	{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_TIME)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_TIME)->Ref();
 				}
 
 	|	TOK_INTERVAL	{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_INTERVAL)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_INTERVAL)->Ref();
 				}
 
 	|	TOK_STRING	{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_STRING)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_STRING)->Ref();
 				}
 
 	|	TOK_PATTERN	{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_PATTERN)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_PATTERN)->Ref();
 				}
 
 	|	TOK_TIMER	{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_TIMER)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_TIMER)->Ref();
 				}
 
 	|	TOK_PORT	{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_PORT)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_PORT)->Ref();
 				}
 
 	|	TOK_ADDR	{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_ADDR)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_ADDR)->Ref();
 				}
 
 	|	TOK_SUBNET	{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_SUBNET)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_SUBNET)->Ref();
 				}
 
 	|	TOK_ANY		{
-				zeek::detail::set_location(@1);
-				$$ = zeek::base_type(zeek::TYPE_ANY)->Ref();
+				set_location(@1);
+				$$ = base_type(TYPE_ANY)->Ref();
 				}
 
 	|	TOK_TABLE '[' type_list ']' TOK_OF type
 				{
-				zeek::detail::set_location(@1, @6);
-				$$ = new zeek::TableType({zeek::AdoptRef{}, $3}, {zeek::AdoptRef{}, $6});
+				set_location(@1, @6);
+				$$ = new TableType({AdoptRef{}, $3}, {AdoptRef{}, $6});
 				}
 
 	|	TOK_SET '[' type_list ']'
 				{
-				zeek::detail::set_location(@1, @4);
-				$$ = new zeek::SetType({zeek::AdoptRef{}, $3}, nullptr);
+				set_location(@1, @4);
+				$$ = new SetType({AdoptRef{}, $3}, nullptr);
 				}
 
 	|	TOK_RECORD '{'
@@ -950,108 +952,108 @@ type:
 			{ --in_record; }
 		'}'
 				{
-				zeek::detail::set_location(@1, @5);
-				$$ = new zeek::RecordType($4);
+				set_location(@1, @5);
+				$$ = new RecordType($4);
 				}
 
 	|	TOK_UNION '{' type_list '}'
 				{
-				zeek::detail::set_location(@1, @4);
-				zeek::reporter->Error("union type not implemented");
+				set_location(@1, @4);
+				reporter->Error("union type not implemented");
 				$$ = 0;
 				}
 
-	|	TOK_ENUM '{' { zeek::detail::set_location(@1); parse_new_enum(); } enum_body '}'
+	|	TOK_ENUM '{' { set_location(@1); parse_new_enum(); } enum_body '}'
 				{
-				zeek::detail::set_location(@1, @5);
+				set_location(@1, @5);
 				$4->UpdateLocationEndInfo(@5);
 				$$ = $4;
 				}
 
 	|	TOK_LIST
 				{
-				zeek::detail::set_location(@1);
+				set_location(@1);
 				// $$ = new TypeList();
-				zeek::reporter->Error("list type not implemented");
+				reporter->Error("list type not implemented");
 				$$ = 0;
 				}
 
 	|	TOK_LIST TOK_OF type
 				{
-				zeek::detail::set_location(@1);
+				set_location(@1);
 				// $$ = new TypeList($3);
-				zeek::reporter->Error("list type not implemented");
+				reporter->Error("list type not implemented");
 				$$ = 0;
 				}
 
 	|	TOK_VECTOR TOK_OF type
 				{
-				zeek::detail::set_location(@1, @3);
-				$$ = new zeek::VectorType({zeek::AdoptRef{}, $3});
+				set_location(@1, @3);
+				$$ = new VectorType({AdoptRef{}, $3});
 				}
 
 	|	TOK_FUNCTION func_params
 				{
-				zeek::detail::set_location(@1, @2);
+				set_location(@1, @2);
 				$$ = $2;
 				}
 
 	|	TOK_EVENT '(' formal_args ')'
 				{
-				zeek::detail::set_location(@1, @3);
-				$$ = new zeek::FuncType({zeek::AdoptRef{}, $3}, nullptr, zeek::FUNC_FLAVOR_EVENT);
+				set_location(@1, @3);
+				$$ = new FuncType({AdoptRef{}, $3}, nullptr, FUNC_FLAVOR_EVENT);
 				}
 
 	|	TOK_HOOK '(' formal_args ')'
 				{
-				zeek::detail::set_location(@1, @3);
-				$$ = new zeek::FuncType({zeek::AdoptRef{}, $3}, zeek::base_type(zeek::TYPE_BOOL), zeek::FUNC_FLAVOR_HOOK);
+				set_location(@1, @3);
+				$$ = new FuncType({AdoptRef{}, $3}, base_type(TYPE_BOOL), FUNC_FLAVOR_HOOK);
 				}
 
 	|	TOK_FILE TOK_OF type
 				{
-				zeek::detail::set_location(@1, @3);
-				$$ = new zeek::FileType({zeek::AdoptRef{}, $3});
+				set_location(@1, @3);
+				$$ = new FileType({AdoptRef{}, $3});
 				}
 
 	|	TOK_FILE
 				{
-				zeek::detail::set_location(@1);
-				$$ = new zeek::FileType(zeek::base_type(zeek::TYPE_STRING));
+				set_location(@1);
+				$$ = new FileType(base_type(TYPE_STRING));
 				}
 
 	|	TOK_OPAQUE TOK_OF TOK_ID
 				{
-				zeek::detail::set_location(@1, @3);
-				$$ = new zeek::OpaqueType($3);
+				set_location(@1, @3);
+				$$ = new OpaqueType($3);
 				}
 
 	|	resolve_id
 			{
 			if ( ! $1 || ! ($$ = $1->IsType() ? $1->GetType().get() : nullptr) )
 				{
-				zeek::detail::NullStmt here;
+				NullStmt here;
 				if ( $1 )
 					$1->Error("not a Zeek type", &here);
-				$$ = zeek::error_type()->Ref();
+				$$ = error_type()->Ref();
 				}
 			else
 				{
 				Ref($$);
 
 				if ( $1->IsDeprecated() )
-					zeek::reporter->Warning("%s", $1->GetDeprecationWarning().c_str());
+					reporter->Warning("%s", $1->GetDeprecationWarning().c_str());
 				}
 			}
 	;
 
 type_list:
 		type_list ',' type
-			{ $1->AppendEvenIfNotPure({zeek::AdoptRef{}, $3}); }
+			{ $1->AppendEvenIfNotPure({AdoptRef{}, $3}); }
 	|	type
 			{
-			$$ = new zeek::TypeList({zeek::NewRef{}, $1});
-			$$->Append({zeek::AdoptRef{}, $1});
+			$$ = new TypeList({NewRef{}, $1});
+			$$->Append({AdoptRef{}, $1});
 			}
 	;
 
@@ -1062,30 +1064,30 @@ type_decl_list:
 			}
 	|
 			{
-			$$ = new zeek::type_decl_list();
+			$$ = new type_decl_list();
 			}
 	;
 
 type_decl:
 		TOK_ID ':' type opt_attr ';'
 			{
-			zeek::detail::set_location(@1, @4);
-			auto attrs = make_attributes($4, {zeek::NewRef{}, $3}, in_record > 0, false);
-			$$ = new zeek::TypeDecl($1, {zeek::AdoptRef{}, $3}, std::move(attrs));
+			set_location(@1, @4);
+			auto attrs = make_attributes($4, {NewRef{}, $3}, in_record > 0, false);
+			$$ = new TypeDecl($1, {AdoptRef{}, $3}, std::move(attrs));
 
 			if ( in_record > 0 && cur_decl_type_id )
-				zeek::detail::zeekygen_mgr->RecordField(cur_decl_type_id, $$, ::filename,
+				zeekygen_mgr->RecordField(cur_decl_type_id, $$, ::filename,
 				                                        in_record_redef != 0);
 			}
 	;
 
 formal_args:
 		formal_args_decl_list
-			{ $$ = new zeek::RecordType($1); }
+			{ $$ = new RecordType($1); }
 	|	formal_args_decl_list ';'
-			{ $$ = new zeek::RecordType($1); }
+			{ $$ = new RecordType($1); }
 	|
-			{ $$ = new zeek::RecordType(new zeek::type_decl_list()); }
+			{ $$ = new RecordType(new type_decl_list()); }
 	;
 
 formal_args_decl_list:
@@ -1094,23 +1096,23 @@ formal_args_decl_list:
 	|	formal_args_decl_list ',' formal_args_decl
 			{ $1->push_back($3); }
 	|	formal_args_decl
-			{ $$ = new zeek::type_decl_list(); $$->push_back($1); }
+			{ $$ = new type_decl_list(); $$->push_back($1); }
 	;
 
 formal_args_decl:
 		TOK_ID ':' type opt_attr
 			{
-			zeek::detail::set_location(@1, @4);
-			auto attrs = make_attributes($4, {zeek::NewRef{}, $3}, true, false);
-			$$ = new zeek::TypeDecl($1, {zeek::AdoptRef{}, $3}, std::move(attrs));
+			set_location(@1, @4);
+			auto attrs = make_attributes($4, {NewRef{}, $3}, true, false);
+			$$ = new TypeDecl($1, {AdoptRef{}, $3}, std::move(attrs));
 			}
 	;
 
 decl:
 		TOK_MODULE TOK_ID ';'
 			{
-			zeek::detail::current_module = $2;
-			zeek::detail::zeekygen_mgr->ModuleUsage(::filename, zeek::detail::current_module);
+			current_module = $2;
+			zeekygen_mgr->ModuleUsage(::filename, current_module);
 			}
 
 	|	TOK_EXPORT '{' { is_export = true; } decl_list '}'
@@ -1118,43 +1120,43 @@ decl:
 
 	|	TOK_GLOBAL def_global_id opt_type init_class opt_init opt_attr ';'
 			{
-			zeek::IntrusivePtr id{zeek::AdoptRef{}, $2};
-			zeek::detail::add_global(id, {zeek::AdoptRef{}, $3}, $4, {zeek::AdoptRef{}, $5},
-			                         std::unique_ptr<std::vector<zeek::detail::AttrPtr>>{$6},
-			                         zeek::detail::VAR_REGULAR);
-			zeek::detail::zeekygen_mgr->Identifier(std::move(id));
+			IntrusivePtr id{AdoptRef{}, $2};
+			add_global(id, {AdoptRef{}, $3}, $4, {AdoptRef{}, $5},
+			                         std::unique_ptr<std::vector<AttrPtr>>{$6},
+			                         VAR_REGULAR);
+			zeekygen_mgr->Identifier(std::move(id));
 			}
 
 	|	TOK_OPTION def_global_id opt_type init_class opt_init opt_attr ';'
 			{
-			zeek::IntrusivePtr id{zeek::AdoptRef{}, $2};
-			zeek::detail::add_global(id, {zeek::AdoptRef{}, $3}, $4, {zeek::AdoptRef{}, $5},
-			                         std::unique_ptr<std::vector<zeek::detail::AttrPtr>>{$6},
-			                         zeek::detail::VAR_OPTION);
-			zeek::detail::zeekygen_mgr->Identifier(std::move(id));
+			IntrusivePtr id{AdoptRef{}, $2};
+			add_global(id, {AdoptRef{}, $3}, $4, {AdoptRef{}, $5},
+			                         std::unique_ptr<std::vector<AttrPtr>>{$6},
+			                         VAR_OPTION);
+			zeekygen_mgr->Identifier(std::move(id));
 			}
 
 	|	TOK_CONST def_global_id opt_type init_class opt_init opt_attr ';'
 			{
-			zeek::IntrusivePtr id{zeek::AdoptRef{}, $2};
-			zeek::detail::add_global(id, {zeek::AdoptRef{}, $3}, $4, {zeek::AdoptRef{}, $5},
-			                         std::unique_ptr<std::vector<zeek::detail::AttrPtr>>{$6},
-			                         zeek::detail::VAR_CONST);
-			zeek::detail::zeekygen_mgr->Identifier(std::move(id));
+			IntrusivePtr id{AdoptRef{}, $2};
+			add_global(id, {AdoptRef{}, $3}, $4, {AdoptRef{}, $5},
+			                         std::unique_ptr<std::vector<AttrPtr>>{$6},
+			                         VAR_CONST);
+			zeekygen_mgr->Identifier(std::move(id));
 			}
 
 	|	TOK_REDEF global_id opt_type init_class opt_init opt_attr ';'
 			{
-			zeek::IntrusivePtr id{zeek::AdoptRef{}, $2};
-			zeek::detail::ExprPtr init{zeek::AdoptRef{}, $5};
-			zeek::detail::add_global(id, {zeek::AdoptRef{}, $3}, $4, init,
-			                         std::unique_ptr<std::vector<zeek::detail::AttrPtr>>{$6},
-			                         zeek::detail::VAR_REDEF);
-			zeek::detail::zeekygen_mgr->Redef(id.get(), ::filename, $4, std::move(init));
+			IntrusivePtr id{AdoptRef{}, $2};
+			ExprPtr init{AdoptRef{}, $5};
+			add_global(id, {AdoptRef{}, $3}, $4, init,
+			                         std::unique_ptr<std::vector<AttrPtr>>{$6},
+			                         VAR_REDEF);
+			zeekygen_mgr->Redef(id.get(), ::filename, $4, std::move(init));
 			}
 
 	|	TOK_REDEF TOK_ENUM global_id TOK_ADD_TO '{'
-			{ ++in_enum_redef; parse_redef_enum($3); zeek::detail::zeekygen_mgr->Redef($3, ::filename); }
+			{ ++in_enum_redef; parse_redef_enum($3); zeekygen_mgr->Redef($3, ::filename); }
 		enum_body '}' ';'
 			{
 			--in_enum_redef;
@@ -1162,7 +1164,7 @@ decl:
 			}
 
 	|	TOK_REDEF TOK_RECORD global_id
-			{ cur_decl_type_id = $3; zeek::detail::zeekygen_mgr->Redef($3, ::filename); }
+			{ cur_decl_type_id = $3; zeekygen_mgr->Redef($3, ::filename); }
 		TOK_ADD_TO '{'
 			{ ++in_record; ++in_record_redef; }
 		type_decl_list
@@ -1174,19 +1176,19 @@ decl:
 			if ( ! $3->GetType() )
 				$3->Error("unknown identifier");
 			else
-				extend_record($3, std::unique_ptr<zeek::type_decl_list>($8),
-				              std::unique_ptr<std::vector<zeek::detail::AttrPtr>>($11));
+				extend_record($3, std::unique_ptr<type_decl_list>($8),
+				              std::unique_ptr<std::vector<AttrPtr>>($11));
 			}
 
 	|	TOK_TYPE global_id ':'
-			{ cur_decl_type_id = $2; zeek::detail::zeekygen_mgr->StartType({zeek::NewRef{}, $2});  }
+			{ cur_decl_type_id = $2; zeekygen_mgr->StartType({NewRef{}, $2});  }
 		type opt_attr ';'
 			{
 			cur_decl_type_id = 0;
-			zeek::IntrusivePtr id{zeek::AdoptRef{}, $2};
-			zeek::detail::add_type(id.get(), {zeek::AdoptRef{}, $5},
-			                       std::unique_ptr<std::vector<zeek::detail::AttrPtr>>{$6});
-			zeek::detail::zeekygen_mgr->Identifier(std::move(id));
+			IntrusivePtr id{AdoptRef{}, $2};
+			add_type(id.get(), {AdoptRef{}, $5},
+			                       std::unique_ptr<std::vector<AttrPtr>>{$6});
+			zeekygen_mgr->Identifier(std::move(id));
 			}
 
 	|	func_hdr { func_hdr_location = @1; } func_body
@@ -1216,41 +1218,41 @@ conditional:
 func_hdr:
 		TOK_FUNCTION def_global_id func_params opt_attr
 			{
-			zeek::IntrusivePtr id{zeek::AdoptRef{}, $2};
-			zeek::detail::begin_func(id, zeek::detail::current_module.c_str(),
-				                     zeek::FUNC_FLAVOR_FUNCTION, false, {zeek::NewRef{}, $3},
-			                         std::unique_ptr<std::vector<zeek::detail::AttrPtr>>{$4});
+			IntrusivePtr id{AdoptRef{}, $2};
+			begin_func(id, current_module.c_str(),
+				                     FUNC_FLAVOR_FUNCTION, false, {NewRef{}, $3},
+			                         std::unique_ptr<std::vector<AttrPtr>>{$4});
 			$$ = $3;
-			zeek::detail::zeekygen_mgr->Identifier(std::move(id));
+			zeekygen_mgr->Identifier(std::move(id));
 			}
 	|	TOK_EVENT event_id func_params opt_attr
 			{
 			const char* name = $2->Name();
-			if ( zeek::util::streq("bro_init", name) || zeek::util::streq("bro_done", name) || zeek::util::streq("bro_script_loaded", name) )
+			if ( util::streq("bro_init", name) || util::streq("bro_done", name) || util::streq("bro_script_loaded", name) )
 				{
 				auto base = std::string(name).substr(4);
-				zeek::reporter->Error("event %s() is no longer available, use zeek_%s() instead", name, base.c_str());
+				reporter->Error("event %s() is no longer available, use zeek_%s() instead", name, base.c_str());
 				}
 
-			zeek::detail::begin_func({zeek::NewRef{}, $2}, zeek::detail::current_module.c_str(),
-				                     zeek::FUNC_FLAVOR_EVENT, false, {zeek::NewRef{}, $3},
-			                         std::unique_ptr<std::vector<zeek::detail::AttrPtr>>{$4});
+			begin_func({NewRef{}, $2}, current_module.c_str(),
+				                     FUNC_FLAVOR_EVENT, false, {NewRef{}, $3},
+			                         std::unique_ptr<std::vector<AttrPtr>>{$4});
 			$$ = $3;
 			}
 	|	TOK_HOOK def_global_id func_params opt_attr
 			{
-			$3->ClearYieldType(zeek::FUNC_FLAVOR_HOOK);
-			$3->SetYieldType(zeek::base_type(zeek::TYPE_BOOL));
-			zeek::detail::begin_func({zeek::NewRef{}, $2}, zeek::detail::current_module.c_str(),
-				                     zeek::FUNC_FLAVOR_HOOK, false, {zeek::NewRef{}, $3},
-			                         std::unique_ptr<std::vector<zeek::detail::AttrPtr>>{$4});
+			$3->ClearYieldType(FUNC_FLAVOR_HOOK);
+			$3->SetYieldType(base_type(TYPE_BOOL));
+			begin_func({NewRef{}, $2}, current_module.c_str(),
+				                     FUNC_FLAVOR_HOOK, false, {NewRef{}, $3},
+			                         std::unique_ptr<std::vector<AttrPtr>>{$4});
 			$$ = $3;
 			}
 	|	TOK_REDEF TOK_EVENT event_id func_params opt_attr
 			{
-			zeek::detail::begin_func({zeek::NewRef{}, $3}, zeek::detail::current_module.c_str(),
-				                     zeek::FUNC_FLAVOR_EVENT, true, {zeek::NewRef{}, $4},
-			                         std::unique_ptr<std::vector<zeek::detail::AttrPtr>>{$5});
+			begin_func({NewRef{}, $3}, current_module.c_str(),
+				                     FUNC_FLAVOR_EVENT, true, {NewRef{}, $4},
+			                         std::unique_ptr<std::vector<AttrPtr>>{$5});
 			$$ = $4;
 			}
 	;
@@ -1270,8 +1272,8 @@ func_body:
 
 		'}'
 			{
-			zeek::detail::set_location(func_hdr_location, @5);
-			zeek::detail::end_func({zeek::AdoptRef{}, $3});
+			set_location(func_hdr_location, @5);
+			end_func({AdoptRef{}, $3});
 			}
 	;
 
@@ -1290,7 +1292,7 @@ lambda_body:
 
 		'}'
 			{
-			zeek::detail::set_location(@1, @5);
+			set_location(@1, @5);
 
 			// Code duplication here is sad but needed.
 			// end_func actually instantiates the function
@@ -1300,12 +1302,12 @@ lambda_body:
 
 			// Gather the ingredients for a Func from the
 			// current scope.
-			auto ingredients = std::make_unique<zeek::detail::function_ingredients>(
-				zeek::IntrusivePtr{zeek::NewRef{}, zeek::detail::current_scope()},
-				zeek::IntrusivePtr{zeek::AdoptRef{}, $3});
-			zeek::IDPList outer_ids = zeek::detail::gather_outer_ids(zeek::detail::pop_scope().get(), ingredients->body.get());
+			auto ingredients = std::make_unique<function_ingredients>(
+				IntrusivePtr{NewRef{}, current_scope()},
+				IntrusivePtr{AdoptRef{}, $3});
+			IDPList outer_ids = gather_outer_ids(pop_scope().get(), ingredients->body.get());
 
-			$$ = new zeek::detail::LambdaExpr(std::move(ingredients), std::move(outer_ids));
+			$$ = new LambdaExpr(std::move(ingredients), std::move(outer_ids));
 			}
 	;
 
@@ -1317,14 +1319,14 @@ anonymous_function:
 begin_lambda:
 		opt_captures func_params
 			{
-			auto id = zeek::detail::current_scope()->GenerateTemporary("anonymous-function");
-			zeek::detail::begin_func(id, zeek::detail::current_module.c_str(), zeek::FUNC_FLAVOR_FUNCTION, false, {zeek::AdoptRef{}, $2});
+			auto id = current_scope()->GenerateTemporary("anonymous-function");
+			begin_func(id, current_module.c_str(), FUNC_FLAVOR_FUNCTION, false, {AdoptRef{}, $2});
 
-			std::optional<zeek::FuncType::CaptureList> captures;
+			std::optional<FuncType::CaptureList> captures;
 
 			if ( $1 )
 				{
-				captures = zeek::FuncType::CaptureList{};
+				captures = FuncType::CaptureList{};
 				captures->reserve($1->size());
 
 				for ( auto c : *$1 )
@@ -1353,7 +1355,7 @@ capture_list:
 			{ $1->push_back($3); }
 	|	capture
 			{
-			$$ = new std::vector<zeek::FuncType::Capture*>;
+			$$ = new std::vector<FuncType::Capture*>;
 			$$->push_back($1);
 			}
 	;
@@ -1361,26 +1363,26 @@ capture_list:
 capture:
 		opt_deep TOK_ID
 			{
-			zeek::detail::set_location(@2);
-			auto id = zeek::detail::lookup_ID($2,
-					zeek::detail::current_module.c_str());
+			set_location(@2);
+			auto id = lookup_ID($2,
+					current_module.c_str());
 
 			if ( ! id )
-				zeek::reporter->Error("no such local identifier: %s", $2);
+				reporter->Error("no such local identifier: %s", $2);
 			else if ( id->IsType() )
 				{
-				zeek::reporter->Error("cannot specify type in capture: %s", $2);
+				reporter->Error("cannot specify type in capture: %s", $2);
 				id = nullptr;
 				}
 			else if ( id->IsGlobal() )
 				{
-				zeek::reporter->Error("cannot specify global in capture: %s", $2);
+				reporter->Error("cannot specify global in capture: %s", $2);
 				id = nullptr;
 				}
 
 			delete [] $2;
 
-			$$ = new zeek::FuncType::Capture;
+			$$ = new FuncType::Capture;
 			$$->id = id;
 			$$->deep_copy = $1;
 			}
@@ -1394,9 +1396,9 @@ opt_deep:	TOK_COPY
 
 func_params:
 		'(' formal_args ')' ':' type
-			{ $$ = new zeek::FuncType({zeek::AdoptRef{}, $2}, {zeek::AdoptRef{}, $5}, zeek::FUNC_FLAVOR_FUNCTION); }
+			{ $$ = new FuncType({AdoptRef{}, $2}, {AdoptRef{}, $5}, FUNC_FLAVOR_FUNCTION); }
 	|	'(' formal_args ')'
-			{ $$ = new zeek::FuncType({zeek::AdoptRef{}, $2}, zeek::base_type(zeek::TYPE_VOID), zeek::FUNC_FLAVOR_FUNCTION); }
+			{ $$ = new FuncType({AdoptRef{}, $2}, base_type(TYPE_VOID), FUNC_FLAVOR_FUNCTION); }
 	;
 
 opt_type:
@@ -1407,10 +1409,10 @@ opt_type:
 	;
 
 init_class:
-				{ $$ = zeek::detail::INIT_NONE; }
-	|	'='		{ $$ = zeek::detail::INIT_FULL; }
-	|	TOK_ADD_TO	{ $$ = zeek::detail::INIT_EXTRA; }
-	|	TOK_REMOVE_FROM	{ $$ = zeek::detail::INIT_REMOVE; }
+				{ $$ = INIT_NONE; }
+	|	'='		{ $$ = INIT_FULL; }
+	|	TOK_ADD_TO	{ $$ = INIT_EXTRA; }
+	|	TOK_REMOVE_FROM	{ $$ = INIT_REMOVE; }
 	;
 
 opt_init:
@@ -1431,25 +1433,25 @@ init:
 index_slice:
 		expr '[' opt_expr ':' opt_expr ']'
 			{
-			zeek::detail::set_location(@1, @6);
+			set_location(@1, @6);
 
-			auto low = $3 ? zeek::detail::ExprPtr{zeek::AdoptRef{}, $3} :
-			                zeek::make_intrusive<zeek::detail::ConstExpr>(zeek::val_mgr->Count(0));
+			auto low = $3 ? ExprPtr{AdoptRef{}, $3} :
+			                make_intrusive<ConstExpr>(val_mgr->Count(0));
 
-			auto high = $5 ? zeek::detail::ExprPtr{zeek::AdoptRef{}, $5} :
-			                 zeek::make_intrusive<zeek::detail::SizeExpr>(
-			                     zeek::detail::ExprPtr{zeek::NewRef{}, $1});
+			auto high = $5 ? ExprPtr{AdoptRef{}, $5} :
+			                 make_intrusive<SizeExpr>(
+			                     ExprPtr{NewRef{}, $1});
 
-			if ( ! zeek::IsIntegral(low->GetType()->Tag()) || ! zeek::IsIntegral(high->GetType()->Tag()) )
-				zeek::reporter->Error("slice notation must have integral values as indexes");
+			if ( ! IsIntegral(low->GetType()->Tag()) || ! IsIntegral(high->GetType()->Tag()) )
+				reporter->Error("slice notation must have integral values as indexes");
 
-			auto le = zeek::make_intrusive<zeek::detail::ListExpr>(std::move(low));
+			auto le = make_intrusive<ListExpr>(std::move(low));
 			le->Append(std::move(high));
 
 			if ( in_when_cond > 0  )
-				$$ = new zeek::detail::IndexExprWhen({zeek::AdoptRef{}, $1}, std::move(le), true);
+				$$ = new IndexExprWhen({AdoptRef{}, $1}, std::move(le), true);
 			else
-				$$ = new zeek::detail::IndexExpr({zeek::AdoptRef{}, $1}, std::move(le), true);
+				$$ = new IndexExpr({AdoptRef{}, $1}, std::move(le), true);
 			}
 
 opt_attr:
@@ -1460,71 +1462,71 @@ opt_attr:
 
 attr_list:
 		attr_list attr
-			{ $1->emplace_back(zeek::AdoptRef{}, $2); }
+			{ $1->emplace_back(AdoptRef{}, $2); }
 	|	attr
 			{
-			$$ = new std::vector<zeek::detail::AttrPtr>;
-			$$->emplace_back(zeek::AdoptRef{}, $1);
+			$$ = new std::vector<AttrPtr>;
+			$$->emplace_back(AdoptRef{}, $1);
 			}
 	;
 
 attr:
 		TOK_ATTR_DEFAULT '=' expr
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_DEFAULT, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Attr(ATTR_DEFAULT, {AdoptRef{}, $3}); }
 	|	TOK_ATTR_OPTIONAL
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_OPTIONAL); }
+			{ $$ = new Attr(ATTR_OPTIONAL); }
 	|	TOK_ATTR_REDEF
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_REDEF); }
+			{ $$ = new Attr(ATTR_REDEF); }
 	|	TOK_ATTR_IS_ASSIGNED
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_IS_ASSIGNED); }
+			{ $$ = new Attr(ATTR_IS_ASSIGNED); }
 	|	TOK_ATTR_IS_USED
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_IS_USED); }
+			{ $$ = new Attr(ATTR_IS_USED); }
 	|	TOK_ATTR_ADD_FUNC '=' expr
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_ADD_FUNC, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Attr(ATTR_ADD_FUNC, {AdoptRef{}, $3}); }
 	|	TOK_ATTR_DEL_FUNC '=' expr
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_DEL_FUNC, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Attr(ATTR_DEL_FUNC, {AdoptRef{}, $3}); }
 	|	TOK_ATTR_ON_CHANGE '=' expr
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_ON_CHANGE, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Attr(ATTR_ON_CHANGE, {AdoptRef{}, $3}); }
 	|	TOK_ATTR_BROKER_STORE '=' expr
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_BROKER_STORE, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Attr(ATTR_BROKER_STORE, {AdoptRef{}, $3}); }
 	|	TOK_ATTR_BROKER_STORE_ALLOW_COMPLEX
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_BROKER_STORE_ALLOW_COMPLEX); }
+			{ $$ = new Attr(ATTR_BROKER_STORE_ALLOW_COMPLEX); }
 	|	TOK_ATTR_BACKEND '=' expr
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_BACKEND, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Attr(ATTR_BACKEND, {AdoptRef{}, $3}); }
 	|	TOK_ATTR_EXPIRE_FUNC '=' expr
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_EXPIRE_FUNC, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Attr(ATTR_EXPIRE_FUNC, {AdoptRef{}, $3}); }
 	|	TOK_ATTR_EXPIRE_CREATE '=' expr
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_EXPIRE_CREATE, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Attr(ATTR_EXPIRE_CREATE, {AdoptRef{}, $3}); }
 	|	TOK_ATTR_EXPIRE_READ '=' expr
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_EXPIRE_READ, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Attr(ATTR_EXPIRE_READ, {AdoptRef{}, $3}); }
 	|	TOK_ATTR_EXPIRE_WRITE '=' expr
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_EXPIRE_WRITE, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Attr(ATTR_EXPIRE_WRITE, {AdoptRef{}, $3}); }
 	|	TOK_ATTR_RAW_OUTPUT
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_RAW_OUTPUT); }
+			{ $$ = new Attr(ATTR_RAW_OUTPUT); }
 	|	TOK_ATTR_PRIORITY '=' expr
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_PRIORITY, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Attr(ATTR_PRIORITY, {AdoptRef{}, $3}); }
 	|	TOK_ATTR_TYPE_COLUMN '=' expr
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_TYPE_COLUMN, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Attr(ATTR_TYPE_COLUMN, {AdoptRef{}, $3}); }
 	|	TOK_ATTR_LOG
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_LOG); }
+			{ $$ = new Attr(ATTR_LOG); }
 	|	TOK_ATTR_ERROR_HANDLER
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_ERROR_HANDLER); }
+			{ $$ = new Attr(ATTR_ERROR_HANDLER); }
 	|	TOK_ATTR_DEPRECATED
-			{ $$ = new zeek::detail::Attr(zeek::detail::ATTR_DEPRECATED); }
+			{ $$ = new Attr(ATTR_DEPRECATED); }
 	|	TOK_ATTR_DEPRECATED '=' TOK_CONSTANT
 			{
-			if ( zeek::IsString($3->GetType()->Tag()) )
-				$$ = new zeek::detail::Attr(
-					zeek::detail::ATTR_DEPRECATED,
-					zeek::make_intrusive<zeek::detail::ConstExpr>(zeek::IntrusivePtr{zeek::AdoptRef{}, $3}));
+			if ( IsString($3->GetType()->Tag()) )
+				$$ = new Attr(
+					ATTR_DEPRECATED,
+					make_intrusive<ConstExpr>(IntrusivePtr{AdoptRef{}, $3}));
 			else
 				{
-				zeek::ODesc d;
+				ODesc d;
 				$3->Describe(&d);
 				Unref($3);
-				zeek::reporter->Error("'&deprecated=%s' must use a string literal",
+				reporter->Error("'&deprecated=%s' must use a string literal",
 				                      d.Description());
-				$$ = new zeek::detail::Attr(zeek::detail::ATTR_DEPRECATED);
+				$$ = new Attr(ATTR_DEPRECATED);
 				}
 			}
 	;
@@ -1532,225 +1534,225 @@ attr:
 stmt:
 		'{' opt_no_test_block stmt_list '}'
 			{
-			zeek::detail::set_location(@1, @4);
+			set_location(@1, @4);
 			$$ = $3;
 			if ( $2 )
-			    zeek::detail::script_coverage_mgr.DecIgnoreDepth();
+			    script_coverage_mgr.DecIgnoreDepth();
 			}
 
 	|	TOK_PRINT expr_list ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::PrintStmt(zeek::IntrusivePtr{zeek::AdoptRef{}, $2});
+			set_location(@1, @3);
+			$$ = new PrintStmt(IntrusivePtr{AdoptRef{}, $2});
 			if ( ! $4 )
-			    zeek::detail::script_coverage_mgr.AddStmt($$);
+			    script_coverage_mgr.AddStmt($$);
 			}
 
 	|	TOK_EVENT event ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::EventStmt({zeek::AdoptRef{}, $2});
+			set_location(@1, @3);
+			$$ = new EventStmt({AdoptRef{}, $2});
 			if ( ! $4 )
-			    zeek::detail::script_coverage_mgr.AddStmt($$);
+			    script_coverage_mgr.AddStmt($$);
 			}
 
 	|	TOK_IF '(' expr ')' stmt
 			{
-			zeek::detail::set_location(@1, @4);
-			$$ = new zeek::detail::IfStmt({zeek::AdoptRef{}, $3}, {zeek::AdoptRef{}, $5}, zeek::make_intrusive<zeek::detail::NullStmt>());
+			set_location(@1, @4);
+			$$ = new IfStmt({AdoptRef{}, $3}, {AdoptRef{}, $5}, make_intrusive<NullStmt>());
 			}
 
 	|	TOK_IF '(' expr ')' stmt TOK_ELSE stmt
 			{
-			zeek::detail::set_location(@1, @4);
-			$$ = new zeek::detail::IfStmt({zeek::AdoptRef{}, $3}, {zeek::AdoptRef{}, $5}, {zeek::AdoptRef{}, $7});
+			set_location(@1, @4);
+			$$ = new IfStmt({AdoptRef{}, $3}, {AdoptRef{}, $5}, {AdoptRef{}, $7});
 			}
 
 	|	TOK_SWITCH expr '{' case_list '}'
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::SwitchStmt({zeek::AdoptRef{}, $2}, $4);
+			set_location(@1, @2);
+			$$ = new SwitchStmt({AdoptRef{}, $2}, $4);
 			}
 
 	|	for_head stmt
 			{
-			$1->AsForStmt()->AddBody({zeek::AdoptRef{}, $2});
+			$1->AsForStmt()->AddBody({AdoptRef{}, $2});
 			}
 
 	|	TOK_WHILE '(' expr ')' stmt
 			{
-			$$ = new zeek::detail::WhileStmt({zeek::AdoptRef{}, $3}, {zeek::AdoptRef{}, $5});
+			$$ = new WhileStmt({AdoptRef{}, $3}, {AdoptRef{}, $5});
 			}
 
 	|	TOK_NEXT ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::NextStmt;
+			set_location(@1, @2);
+			$$ = new NextStmt;
 			if ( ! $3 )
-			    zeek::detail::script_coverage_mgr.AddStmt($$);
+			    script_coverage_mgr.AddStmt($$);
 			}
 
 	|	TOK_BREAK ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::BreakStmt;
+			set_location(@1, @2);
+			$$ = new BreakStmt;
 			if ( ! $3 )
-			    zeek::detail::script_coverage_mgr.AddStmt($$);
+			    script_coverage_mgr.AddStmt($$);
 			}
 
 	|	TOK_FALLTHROUGH ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::FallthroughStmt;
+			set_location(@1, @2);
+			$$ = new FallthroughStmt;
 			if ( ! $3 )
-				zeek::detail::script_coverage_mgr.AddStmt($$);
+				script_coverage_mgr.AddStmt($$);
 			}
 
 	|	TOK_RETURN ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::ReturnStmt(0);
+			set_location(@1, @2);
+			$$ = new ReturnStmt(0);
 			if ( ! $3 )
-			    zeek::detail::script_coverage_mgr.AddStmt($$);
+			    script_coverage_mgr.AddStmt($$);
 			}
 
 	|	TOK_RETURN expr ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::ReturnStmt({zeek::AdoptRef{}, $2});
+			set_location(@1, @2);
+			$$ = new ReturnStmt({AdoptRef{}, $2});
 			if ( ! $4 )
-			    zeek::detail::script_coverage_mgr.AddStmt($$);
+			    script_coverage_mgr.AddStmt($$);
 			}
 
 	|	TOK_ADD expr ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::AddStmt({zeek::AdoptRef{}, $2});
+			set_location(@1, @3);
+			$$ = new AddStmt({AdoptRef{}, $2});
 			if ( ! $4 )
-			    zeek::detail::script_coverage_mgr.AddStmt($$);
+			    script_coverage_mgr.AddStmt($$);
 			}
 
 	|	TOK_DELETE expr ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @3);
-			$$ = new zeek::detail::DelStmt({zeek::AdoptRef{}, $2});
+			set_location(@1, @3);
+			$$ = new DelStmt({AdoptRef{}, $2});
 			if ( ! $4 )
-			    zeek::detail::script_coverage_mgr.AddStmt($$);
+			    script_coverage_mgr.AddStmt($$);
 			}
 
 	|	TOK_LOCAL local_id opt_type init_class opt_init opt_attr ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @7);
-			$$ = zeek::detail::add_local({zeek::AdoptRef{}, $2}, {zeek::AdoptRef{}, $3}, $4,
-			                             {zeek::AdoptRef{}, $5},
-			                             std::unique_ptr<std::vector<zeek::detail::AttrPtr>>{$6},
-			                             zeek::detail::VAR_REGULAR).release();
+			set_location(@1, @7);
+			$$ = add_local({AdoptRef{}, $2}, {AdoptRef{}, $3}, $4,
+			                             {AdoptRef{}, $5},
+			                             std::unique_ptr<std::vector<AttrPtr>>{$6},
+			                             VAR_REGULAR).release();
 			if ( ! $8 )
-			    zeek::detail::script_coverage_mgr.AddStmt($$);
+			    script_coverage_mgr.AddStmt($$);
 			}
 
 	|	TOK_CONST local_id opt_type init_class opt_init opt_attr ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @6);
-			$$ = zeek::detail::add_local({zeek::AdoptRef{}, $2}, {zeek::AdoptRef{}, $3}, $4,
-			                             {zeek::AdoptRef{}, $5},
-			                             std::unique_ptr<std::vector<zeek::detail::AttrPtr>>{$6},
-			                             zeek::detail::VAR_CONST).release();
+			set_location(@1, @6);
+			$$ = add_local({AdoptRef{}, $2}, {AdoptRef{}, $3}, $4,
+			                             {AdoptRef{}, $5},
+			                             std::unique_ptr<std::vector<AttrPtr>>{$6},
+			                             VAR_CONST).release();
 			if ( ! $8 )
-			    zeek::detail::script_coverage_mgr.AddStmt($$);
+			    script_coverage_mgr.AddStmt($$);
 			}
 
 	|	TOK_WHEN '(' when_condition ')' stmt
 			{
-			zeek::detail::set_location(@3, @5);
-			$$ = new zeek::detail::WhenStmt({zeek::AdoptRef{}, $3}, {zeek::AdoptRef{}, $5},
+			set_location(@3, @5);
+			$$ = new WhenStmt({AdoptRef{}, $3}, {AdoptRef{}, $5},
 			                                  nullptr, nullptr, false);
 			}
 
 	|	TOK_WHEN '(' when_condition ')' stmt TOK_TIMEOUT expr '{' opt_no_test_block stmt_list '}'
 			{
-			zeek::detail::set_location(@3, @9);
-			$$ = new zeek::detail::WhenStmt({zeek::AdoptRef{}, $3}, {zeek::AdoptRef{}, $5},
-			                                  {zeek::AdoptRef{}, $10}, {zeek::AdoptRef{}, $7}, false);
+			set_location(@3, @9);
+			$$ = new WhenStmt({AdoptRef{}, $3}, {AdoptRef{}, $5},
+			                                  {AdoptRef{}, $10}, {AdoptRef{}, $7}, false);
 			if ( $9 )
-			    zeek::detail::script_coverage_mgr.DecIgnoreDepth();
+			    script_coverage_mgr.DecIgnoreDepth();
 			}
 
 
 	|	TOK_RETURN TOK_WHEN '(' when_condition ')' stmt
 			{
-			zeek::detail::set_location(@4, @6);
-			$$ = new zeek::detail::WhenStmt({zeek::AdoptRef{}, $4}, {zeek::AdoptRef{}, $6}, nullptr,
+			set_location(@4, @6);
+			$$ = new WhenStmt({AdoptRef{}, $4}, {AdoptRef{}, $6}, nullptr,
 			                  nullptr, true);
 			}
 
 	|	TOK_RETURN TOK_WHEN '(' when_condition ')' stmt TOK_TIMEOUT expr '{' opt_no_test_block stmt_list '}'
 			{
-			zeek::detail::set_location(@4, @10);
-			$$ = new zeek::detail::WhenStmt({zeek::AdoptRef{}, $4}, {zeek::AdoptRef{}, $6},
-			                                  {zeek::AdoptRef{}, $11}, {zeek::AdoptRef{}, $8}, true);
+			set_location(@4, @10);
+			$$ = new WhenStmt({AdoptRef{}, $4}, {AdoptRef{}, $6},
+			                                  {AdoptRef{}, $11}, {AdoptRef{}, $8}, true);
 			if ( $10 )
-			    zeek::detail::script_coverage_mgr.DecIgnoreDepth();
+			    script_coverage_mgr.DecIgnoreDepth();
 			}
 
 	|	index_slice '=' expr ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @4);
-			$$ = new zeek::detail::ExprStmt(zeek::detail::get_assign_expr({zeek::AdoptRef{}, $1},
-			                                  {zeek::AdoptRef{}, $3}, in_init));
+			set_location(@1, @4);
+			$$ = new ExprStmt(get_assign_expr({AdoptRef{}, $1},
+			                                  {AdoptRef{}, $3}, in_init));
 
 			if ( ! $5 )
-				zeek::detail::script_coverage_mgr.AddStmt($$);
+				script_coverage_mgr.AddStmt($$);
 			}
 
 	|	expr ';' opt_no_test
 			{
-			zeek::detail::set_location(@1, @2);
-			$$ = new zeek::detail::ExprStmt({zeek::AdoptRef{}, $1});
+			set_location(@1, @2);
+			$$ = new ExprStmt({AdoptRef{}, $1});
 			if ( ! $3 )
-			    zeek::detail::script_coverage_mgr.AddStmt($$);
+			    script_coverage_mgr.AddStmt($$);
 			}
 
 	|	';'
 			{
-			zeek::detail::set_location(@1, @1);
-			$$ = new zeek::detail::NullStmt;
+			set_location(@1, @1);
+			$$ = new NullStmt;
 			}
 
 	|	conditional
-			{ $$ = new zeek::detail::NullStmt; }
+			{ $$ = new NullStmt; }
 	;
 
 stmt_list:
 		stmt_list stmt
 			{
-			zeek::detail::set_location(@1, @2);
+			set_location(@1, @2);
 			$1->AsStmtList()->Stmts().push_back($2);
 			$1->UpdateLocationEndInfo(@2);
 			}
 	|
-			{ $$ = new zeek::detail::StmtList(); }
+			{ $$ = new StmtList(); }
 	;
 
 event:
 		TOK_ID '(' opt_expr_list ')'
 			{
-			zeek::detail::set_location(@1, @4);
-			const auto& id = zeek::detail::lookup_ID($1, zeek::detail::current_module.c_str());
+			set_location(@1, @4);
+			const auto& id = lookup_ID($1, current_module.c_str());
 
 			if ( id )
 				{
 				if ( ! id->IsGlobal() )
 					{
-					yyerror(zeek::util::fmt("local identifier \"%s\" cannot be used to reference an event", $1));
+					yyerror(util::fmt("local identifier \"%s\" cannot be used to reference an event", $1));
 					YYERROR;
 					}
 
 				if ( id->IsDeprecated() )
-					zeek::reporter->Warning("%s", id->GetDeprecationWarning().c_str());
+					reporter->Warning("%s", id->GetDeprecationWarning().c_str());
 				}
 
-			$$ = new zeek::detail::EventExpr($1, {zeek::AdoptRef{}, $3});
+			$$ = new EventExpr($1, {AdoptRef{}, $3});
 			}
 	;
 
@@ -1758,18 +1760,18 @@ case_list:
 		case_list case
 			{ $1->push_back($2); }
 	|
-			{ $$ = new zeek::detail::case_list; }
+			{ $$ = new case_list; }
 	;
 
 case:
 		TOK_CASE expr_list ':' stmt_list
-			{ $$ = new zeek::detail::Case({zeek::AdoptRef{}, $2}, nullptr, {zeek::AdoptRef{}, $4}); }
+			{ $$ = new Case({AdoptRef{}, $2}, nullptr, {AdoptRef{}, $4}); }
 	|
 		TOK_CASE case_type_list ':' stmt_list
-			{ $$ = new zeek::detail::Case(nullptr, $2, {zeek::AdoptRef{}, $4}); }
+			{ $$ = new Case(nullptr, $2, {AdoptRef{}, $4}); }
 	|
 		TOK_DEFAULT ':' stmt_list
-			{ $$ = new zeek::detail::Case(nullptr, nullptr, {zeek::AdoptRef{}, $3}); }
+			{ $$ = new Case(nullptr, nullptr, {AdoptRef{}, $3}); }
 	;
 
 case_type_list:
@@ -1778,7 +1780,7 @@ case_type_list:
 	|
 		case_type
 			{
-			$$ = new zeek::IDPList;
+			$$ = new IDPList;
 			$$->push_back($1);
 			}
 	;
@@ -1786,36 +1788,36 @@ case_type_list:
 case_type:
 		TOK_TYPE type
 			{
-			$$ = new zeek::detail::ID(0, zeek::detail::SCOPE_FUNCTION, 0);
-			$$->SetType({zeek::AdoptRef{}, $2});
+			$$ = new ID(0, SCOPE_FUNCTION, 0);
+			$$->SetType({AdoptRef{}, $2});
 			}
 
 	|	TOK_TYPE type TOK_AS TOK_ID
 			{
 			const char* name = $4;
-			zeek::TypePtr type{zeek::AdoptRef{}, $2};
-			auto case_var = zeek::detail::lookup_ID(name, zeek::detail::current_module.c_str());
+			TypePtr type{AdoptRef{}, $2};
+			auto case_var = lookup_ID(name, current_module.c_str());
 
 			if ( case_var && case_var->IsGlobal() )
 				case_var->Error("already a global identifier");
 			else
-				case_var = zeek::detail::install_ID(name, zeek::detail::current_module.c_str(), false, false);
+				case_var = install_ID(name, current_module.c_str(), false, false);
 
-			zeek::detail::add_local(case_var, std::move(type), zeek::detail::INIT_NONE, nullptr, nullptr,
-			                        zeek::detail::VAR_REGULAR);
+			add_local(case_var, std::move(type), INIT_NONE, nullptr, nullptr,
+			                        VAR_REGULAR);
 			$$ = case_var.release();
 			}
 
 for_head:
 		TOK_FOR '(' TOK_ID TOK_IN expr ')'
 			{
-			zeek::detail::set_location(@1, @6);
+			set_location(@1, @6);
 
 			// This rule needs to be separate from the loop
 			// body so that we execute these actions - defining
 			// the local variable - prior to parsing the body,
 			// which might refer to the variable.
-			auto loop_var = zeek::detail::lookup_ID($3, zeek::detail::current_module.c_str());
+			auto loop_var = lookup_ID($3, current_module.c_str());
 
 			if ( loop_var )
 				{
@@ -1825,30 +1827,30 @@ for_head:
 
 			else
 				{
-				loop_var = zeek::detail::install_ID($3, zeek::detail::current_module.c_str(),
+				loop_var = install_ID($3, current_module.c_str(),
 				                                    false, false);
 				}
 
-			auto* loop_vars = new zeek::IDPList;
+			auto* loop_vars = new IDPList;
 			loop_vars->push_back(loop_var.release());
 
-			$$ = new zeek::detail::ForStmt(loop_vars, {zeek::AdoptRef{}, $5});
+			$$ = new ForStmt(loop_vars, {AdoptRef{}, $5});
 			}
 	|
 		TOK_FOR '(' '[' local_id_list ']' TOK_IN expr ')'
 			{
-			$$ = new zeek::detail::ForStmt($4, {zeek::AdoptRef{}, $7});
+			$$ = new ForStmt($4, {AdoptRef{}, $7});
 			}
 	|
 		TOK_FOR '(' TOK_ID ',' TOK_ID TOK_IN expr ')'
 			{
-			zeek::detail::set_location(@1, @8);
-			const char* module = zeek::detail::current_module.c_str();
+			set_location(@1, @8);
+			const char* module = current_module.c_str();
 
 			// Check for previous definitions of key and
 			// value variables.
-			auto key_var = zeek::detail::lookup_ID($3, module);
-			auto val_var = zeek::detail::lookup_ID($5, module);
+			auto key_var = lookup_ID($3, module);
+			auto val_var = lookup_ID($5, module);
 
 			// Validate previous definitions as needed.
 			if ( key_var )
@@ -1857,7 +1859,7 @@ for_head:
 					key_var->Error("global variable used in for loop");
 				}
 			else
-				key_var = zeek::detail::install_ID($3, module, false, false);
+				key_var = install_ID($3, module, false, false);
 
 			if ( val_var )
 				{
@@ -1865,21 +1867,21 @@ for_head:
 					val_var->Error("global variable used in for loop");
 				}
 			else
-				val_var = zeek::detail::install_ID($5, module, false, false);
+				val_var = install_ID($5, module, false, false);
 
-			auto* loop_vars = new zeek::IDPList;
+			auto* loop_vars = new IDPList;
 			loop_vars->push_back(key_var.release());
 
-			$$ = new zeek::detail::ForStmt(loop_vars, {zeek::AdoptRef{}, $7}, std::move(val_var));
+			$$ = new ForStmt(loop_vars, {AdoptRef{}, $7}, std::move(val_var));
 			}
 	|
 		TOK_FOR '(' '[' local_id_list ']' ',' TOK_ID TOK_IN expr ')'
 			{
-			zeek::detail::set_location(@1, @10);
-			const char* module = zeek::detail::current_module.c_str();
+			set_location(@1, @10);
+			const char* module = current_module.c_str();
 
 			// Validate value variable
-			auto val_var = zeek::detail::lookup_ID($7, module);
+			auto val_var = lookup_ID($7, module);
 
 			if ( val_var )
 				{
@@ -1887,9 +1889,9 @@ for_head:
 					val_var->Error("global variable used in for loop");
 				}
 			else
-				val_var = zeek::detail::install_ID($7, module, false, false);
+				val_var = install_ID($7, module, false, false);
 
-			$$ = new zeek::detail::ForStmt($4, {zeek::AdoptRef{}, $9}, std::move(val_var));
+			$$ = new ForStmt($4, {AdoptRef{}, $9}, std::move(val_var));
 			}
 	;
 
@@ -1898,7 +1900,7 @@ local_id_list:
 			{ $1->push_back($3); }
 	|	local_id
 			{
-			$$ = new zeek::IDPList;
+			$$ = new IDPList;
 			$$->push_back($1);
 			}
 	;
@@ -1906,8 +1908,8 @@ local_id_list:
 local_id:
 		TOK_ID
 			{
-			zeek::detail::set_location(@1);
-			auto id = zeek::detail::lookup_ID($1, zeek::detail::current_module.c_str());
+			set_location(@1);
+			auto id = lookup_ID($1, current_module.c_str());
 			$$ = id.release();
 
 			if ( $$ )
@@ -1919,7 +1921,7 @@ local_id:
 
 			else
 				{
-				$$ = zeek::detail::install_ID($1, zeek::detail::current_module.c_str(),
+				$$ = install_ID($1, current_module.c_str(),
 				                              false, is_export).release();
 				}
 			}
@@ -1943,8 +1945,8 @@ event_id:
 global_or_event_id:
 		TOK_ID
 			{
-			zeek::detail::set_location(@1);
-			auto id = zeek::detail::lookup_ID($1, zeek::detail::current_module.c_str(), false,
+			set_location(@1);
+			auto id = lookup_ID($1, current_module.c_str(), false,
 			                    defining_global_ID);
 			$$ = id.release();
 
@@ -1957,9 +1959,9 @@ global_or_event_id:
 					{
 					const auto& t = $$->GetType();
 
-					if ( t->Tag() != zeek::TYPE_FUNC ||
-					     t->AsFuncType()->Flavor() != zeek::FUNC_FLAVOR_FUNCTION )
-						zeek::reporter->Warning("%s", $$->GetDeprecationWarning().c_str());
+					if ( t->Tag() != TYPE_FUNC ||
+					     t->AsFuncType()->Flavor() != FUNC_FLAVOR_FUNCTION )
+						reporter->Warning("%s", $$->GetDeprecationWarning().c_str());
 					}
 
 				delete [] $1;
@@ -1969,9 +1971,9 @@ global_or_event_id:
 				{
 				const char* module_name =
 					resolving_global_ID ?
-						zeek::detail::current_module.c_str() : 0;
+						current_module.c_str() : 0;
 
-				$$ = zeek::detail::install_ID($1, module_name,
+				$$ = install_ID($1, module_name,
 				                              true, is_export).release();
 				}
 			}
@@ -1981,12 +1983,12 @@ global_or_event_id:
 resolve_id:
 		TOK_ID
 			{
-			zeek::detail::set_location(@1);
-			auto id = zeek::detail::lookup_ID($1, zeek::detail::current_module.c_str());
+			set_location(@1);
+			auto id = lookup_ID($1, current_module.c_str());
 			$$ = id.release();
 
 			if ( ! $$ )
-				zeek::reporter->Error("identifier not defined: %s", $1);
+				reporter->Error("identifier not defined: %s", $1);
 
 			delete [] $1;
 			}
@@ -2000,25 +2002,25 @@ opt_no_test:
 
 opt_no_test_block:
 		TOK_NO_TEST
-			{ $$ = true; zeek::detail::script_coverage_mgr.IncIgnoreDepth(); }
+			{ $$ = true; script_coverage_mgr.IncIgnoreDepth(); }
 	|
 			{ $$ = false; }
 
 opt_deprecated:
 		TOK_ATTR_DEPRECATED
-			{ $$ = new zeek::detail::ConstExpr(zeek::make_intrusive<zeek::StringVal>("")); }
+			{ $$ = new ConstExpr(make_intrusive<StringVal>("")); }
 	|
 		TOK_ATTR_DEPRECATED '=' TOK_CONSTANT
 			{
-			if ( zeek::IsString($3->GetType()->Tag()) )
-				$$ = new zeek::detail::ConstExpr({zeek::AdoptRef{}, $3});
+			if ( IsString($3->GetType()->Tag()) )
+				$$ = new ConstExpr({AdoptRef{}, $3});
 			else
 				{
-				zeek::ODesc d;
+				ODesc d;
 				$3->Describe(&d);
-				zeek::reporter->Error("'&deprecated=%s' must use a string literal",
+				reporter->Error("'&deprecated=%s' must use a string literal",
 				                      d.Description());
-				$$ = new zeek::detail::ConstExpr(zeek::make_intrusive<zeek::StringVal>(""));
+				$$ = new ConstExpr(make_intrusive<StringVal>(""));
 				}
 			}
 	|
@@ -2029,25 +2031,25 @@ opt_deprecated:
 int yyerror(const char msg[])
 	{
 	if ( in_debug )
-		g_curr_debug_error = zeek::util::copy_string(msg);
+		g_curr_debug_error = util::copy_string(msg);
 
 	if ( last_tok[0] == '\n' )
-		zeek::reporter->Error("%s, on previous line", msg);
+		reporter->Error("%s, on previous line", msg);
 	else if ( last_tok[0] == '\0' )
 		{
 		if ( last_filename )
-			zeek::reporter->Error("%s, at end of file %s", msg, last_filename);
+			reporter->Error("%s, at end of file %s", msg, last_filename);
 		else
-			zeek::reporter->Error("%s, at end of file", msg);
+			reporter->Error("%s, at end of file", msg);
 		}
 	else
 		{
 		if ( last_last_tok_filename && last_tok_filename &&
-		     ! zeek::util::streq(last_last_tok_filename, last_tok_filename) )
-			zeek::reporter->Error("%s, at or near \"%s\" or end of file %s",
+		     ! util::streq(last_last_tok_filename, last_tok_filename) )
+			reporter->Error("%s, at or near \"%s\" or end of file %s",
 			                      msg, last_tok, last_last_tok_filename);
 		else
-			zeek::reporter->Error("%s, at or near \"%s\"", msg, last_tok);
+			reporter->Error("%s, at or near \"%s\"", msg, last_tok);
 		}
 
 	return 0;