diff --git a/src/Attr.cc b/src/Attr.cc
index c57f288313..f2b854cb50 100644
--- a/src/Attr.cc
+++ b/src/Attr.cc
@@ -23,7 +23,7 @@ const char* attr_name(attr_tag t)
 	return attr_names[int(t)];
 	}
 
-Attr::Attr(attr_tag t, IntrusivePtr<Expr> e)
+Attr::Attr(attr_tag t, IntrusivePtr<zeek::detail::Expr> e)
 	: expr(std::move(e))
 	{
 	tag = t;
@@ -90,7 +90,7 @@ void Attr::DescribeReST(ODesc* d, bool shorten) const
 		d->Add("=");
 		d->SP();
 
-		if ( expr->Tag() == EXPR_NAME )
+		if ( expr->Tag() == zeek::detail::EXPR_NAME )
 			{
 			d->Add(":zeek:see:`");
 			expr->Describe(d);
@@ -104,7 +104,7 @@ void Attr::DescribeReST(ODesc* d, bool shorten) const
 			d->Add("`");
 			}
 
-		else if ( expr->Tag() == EXPR_CONST )
+		else if ( expr->Tag() == zeek::detail::EXPR_CONST )
 			{
 			ODesc dd;
 			dd.SetQuotes(true);
diff --git a/src/Attr.h b/src/Attr.h
index fbf60f68a4..7e1fb62e17 100644
--- a/src/Attr.h
+++ b/src/Attr.h
@@ -8,7 +8,7 @@
 #include "BroList.h"
 #include "IntrusivePtr.h"
 
-class Expr;
+FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
 
 // Note that there are two kinds of attributes: the kind (here) which
 // modify expressions or supply metadata on types, and the kind that
@@ -40,19 +40,19 @@ class Attr final : public BroObj {
 public:
 	static inline const IntrusivePtr<Attr> nil;
 
-	Attr(attr_tag t, IntrusivePtr<Expr> e);
+	Attr(attr_tag t, IntrusivePtr<zeek::detail::Expr> e);
 	explicit Attr(attr_tag t);
 	~Attr() override;
 
 	attr_tag Tag() const	{ return tag; }
 
 	[[deprecated("Remove in v4.1.  Use GetExpr().")]]
-	Expr* AttrExpr() const	{ return expr.get(); }
+	zeek::detail::Expr* AttrExpr() const	{ return expr.get(); }
 
-	const IntrusivePtr<Expr>& GetExpr() const
+	const IntrusivePtr<zeek::detail::Expr>& GetExpr() const
 		{ return expr; }
 
-	void SetAttrExpr(IntrusivePtr<Expr> e);
+	void SetAttrExpr(IntrusivePtr<zeek::detail::Expr> e);
 
 	void Describe(ODesc* d) const override;
 	void DescribeReST(ODesc* d, bool shorten = false) const;
@@ -75,7 +75,7 @@ protected:
 	void AddTag(ODesc* d) const;
 
 	attr_tag tag;
-	IntrusivePtr<Expr> expr;
+	IntrusivePtr<zeek::detail::Expr> expr;
 };
 
 // Manages a collection of attributes.
diff --git a/src/BroList.h b/src/BroList.h
index d2e77a33ca..57b1fba2af 100644
--- a/src/BroList.h
+++ b/src/BroList.h
@@ -4,8 +4,8 @@
 
 #include "List.h"
 
-class Expr;
-typedef PList<Expr> expr_list;
+FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
+typedef PList<zeek::detail::Expr> expr_list;
 
 class ID;
 typedef PList<ID> id_list;
diff --git a/src/DbgWatch.cc b/src/DbgWatch.cc
index 8ea7d96fa1..5d286afc1c 100644
--- a/src/DbgWatch.cc
+++ b/src/DbgWatch.cc
@@ -12,7 +12,7 @@ DbgWatch::DbgWatch(BroObj* var_to_watch)
 	reporter->InternalError("DbgWatch unimplemented");
 	}
 
-DbgWatch::DbgWatch(Expr* expr_to_watch)
+DbgWatch::DbgWatch(zeek::detail::Expr* expr_to_watch)
 	{
 	reporter->InternalError("DbgWatch unimplemented");
 	}
diff --git a/src/DbgWatch.h b/src/DbgWatch.h
index 2dfb8ea605..ba55b25bce 100644
--- a/src/DbgWatch.h
+++ b/src/DbgWatch.h
@@ -2,16 +2,19 @@
 
 #pragma once
 
+#include "util.h"
+
 class BroObj;
-class Expr;
+
+FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
 
 class DbgWatch {
 public:
 	explicit DbgWatch(BroObj* var_to_watch);
-	explicit DbgWatch(Expr* expr_to_watch);
+	explicit DbgWatch(zeek::detail::Expr* expr_to_watch);
 	~DbgWatch();
 
 protected:
 	BroObj* var;
-	Expr* expr;
+	zeek::detail::Expr* expr;
 };
diff --git a/src/Debug.cc b/src/Debug.cc
index 7cbc928943..f1e94e96c9 100644
--- a/src/Debug.cc
+++ b/src/Debug.cc
@@ -935,7 +935,7 @@ bool post_execute_stmt(zeek::detail::Stmt* stmt, Frame* f, Val* result, stmt_flo
 
 // Evaluates the given expression in the context of the currently selected
 // frame.  Returns the resulting value, or nil if none (or there was an error).
-Expr* g_curr_debug_expr = nullptr;
+zeek::detail::Expr* g_curr_debug_expr = nullptr;
 const char* g_curr_debug_error = nullptr;
 bool in_debug = false;
 
diff --git a/src/Expr.cc b/src/Expr.cc
index 817a8f49b0..4d7e89f8d1 100644
--- a/src/Expr.cc
+++ b/src/Expr.cc
@@ -22,6 +22,8 @@
 
 #include "broker/Data.h"
 
+namespace zeek::detail {
+
 const char* expr_name(BroExprTag t)
 	{
 	static const char* expr_names[int(NUM_EXPRS)] = {
@@ -5055,3 +5057,5 @@ bool expr_greater(const Expr* e1, const Expr* e2)
 	{
 	return e1->Tag() > e2->Tag();
 	}
+
+}
diff --git a/src/Expr.h b/src/Expr.h
index d196a8069b..34ddfbab28 100644
--- a/src/Expr.h
+++ b/src/Expr.h
@@ -17,6 +17,13 @@
 #include "Val.h"
 #include "ZeekArgs.h"
 
+template <class T> class IntrusivePtr;
+class Frame;
+class Scope;
+struct function_ingredients;
+
+namespace zeek::detail {
+
 enum BroExprTag : int {
 	EXPR_ANY = -1,
 	EXPR_NAME, EXPR_CONST,
@@ -58,19 +65,13 @@ enum BroExprTag : int {
 
 extern const char* expr_name(BroExprTag t);
 
-template <class T> class IntrusivePtr;
-class Frame;
-class Scope;
 class ListExpr;
 class NameExpr;
 class IndexExpr;
 class AssignExpr;
 class CallExpr;
 class EventExpr;
-
-struct function_ingredients;
-
-FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
+class Stmt;
 
 class Expr : public BroObj {
 public:
@@ -953,3 +954,55 @@ extern bool expr_greater(const Expr* e1, const Expr* e2);
 // True if the given Expr* has a vector type
 inline bool is_vector(Expr* e)	{ return e->GetType()->Tag() == TYPE_VECTOR; }
 inline bool is_vector(const IntrusivePtr<Expr>& e)	{ return is_vector(e.get()); }
+
+}
+
+using Expr [[deprecated("Remove in v4.1. Use zeek::detail::Expr instead.")]] = zeek::detail::Expr;
+using NameExpr [[deprecated("Remove in v4.1. Use zeek::detail::NameExpr instead.")]] = zeek::detail::NameExpr;
+using ConstExpr [[deprecated("Remove in v4.1. Use zeek::detail::ConstExpr instead.")]] = zeek::detail::ConstExpr;
+using UnaryExpr [[deprecated("Remove in v4.1. Use zeek::detail::UnaryExpr instead.")]] = zeek::detail::UnaryExpr;
+using BinaryExpr [[deprecated("Remove in v4.1. Use zeek::detail::BinaryExpr instead.")]] = zeek::detail::BinaryExpr;
+using CloneExpr [[deprecated("Remove in v4.1. Use zeek::detail::CloneExpr instead.")]] = zeek::detail::CloneExpr;
+using IncrExpr [[deprecated("Remove in v4.1. Use zeek::detail::IncrExpr instead.")]] = zeek::detail::IncrExpr;
+using ComplementExpr [[deprecated("Remove in v4.1. Use zeek::detail::ComplementExpr instead.")]] = zeek::detail::ComplementExpr;
+using NotExpr [[deprecated("Remove in v4.1. Use zeek::detail::NotExpr instead.")]] = zeek::detail::NotExpr;
+using PosExpr [[deprecated("Remove in v4.1. Use zeek::detail::PosExpr instead.")]] = zeek::detail::PosExpr;
+using NegExpr [[deprecated("Remove in v4.1. Use zeek::detail::NegExpr instead.")]] = zeek::detail::NegExpr;
+using SizeExpr [[deprecated("Remove in v4.1. Use zeek::detail::SizeExpr instead.")]] = zeek::detail::SizeExpr;
+using AddExpr [[deprecated("Remove in v4.1. Use zeek::detail::AddExpr instead.")]] = zeek::detail::AddExpr;
+using AddToExpr [[deprecated("Remove in v4.1. Use zeek::detail::AddToExpr instead.")]] = zeek::detail::AddToExpr;
+using RemoveFromExpr [[deprecated("Remove in v4.1. Use zeek::detail::RemoveFromExpr instead.")]] = zeek::detail::RemoveFromExpr;
+using SubExpr [[deprecated("Remove in v4.1. Use zeek::detail::SubExpr instead.")]] = zeek::detail::SubExpr;
+using TimesExpr [[deprecated("Remove in v4.1. Use zeek::detail::TimesExpr instead.")]] = zeek::detail::TimesExpr;
+using DivideExpr [[deprecated("Remove in v4.1. Use zeek::detail::DivideExpr instead.")]] = zeek::detail::DivideExpr;
+using ModExpr [[deprecated("Remove in v4.1. Use zeek::detail::ModExpr instead.")]] = zeek::detail::ModExpr;
+using BoolExpr [[deprecated("Remove in v4.1. Use zeek::detail::BoolExpr instead.")]] = zeek::detail::BoolExpr;
+using BitExpr [[deprecated("Remove in v4.1. Use zeek::detail::BitExpr instead.")]] = zeek::detail::BitExpr;
+using EqExpr [[deprecated("Remove in v4.1. Use zeek::detail::EqExpr instead.")]] = zeek::detail::EqExpr;
+using RelExpr [[deprecated("Remove in v4.1. Use zeek::detail::RelExpr instead.")]] = zeek::detail::RelExpr;
+using CondExpr [[deprecated("Remove in v4.1. Use zeek::detail::CondExpr instead.")]] = zeek::detail::CondExpr;
+using RefExpr [[deprecated("Remove in v4.1. Use zeek::detail::RefExpr instead.")]] = zeek::detail::RefExpr;
+using AssignExpr [[deprecated("Remove in v4.1. Use zeek::detail::AssignExpr instead.")]] = zeek::detail::AssignExpr;
+using IndexSliceAssignExpr [[deprecated("Remove in v4.1. Use zeek::detail::IndexSliceAssignExpr instead.")]] = zeek::detail::IndexSliceAssignExpr;
+using IndexExpr [[deprecated("Remove in v4.1. Use zeek::detail::IndexExpr instead.")]] = zeek::detail::IndexExpr;
+using FieldExpr [[deprecated("Remove in v4.1. Use zeek::detail::FieldExpr instead.")]] = zeek::detail::FieldExpr;
+using HasFieldExpr [[deprecated("Remove in v4.1. Use zeek::detail::HasFieldExpr instead.")]] = zeek::detail::HasFieldExpr;
+using RecordConstructorExpr [[deprecated("Remove in v4.1. Use zeek::detail::RecordConstructorExpr instead.")]] = zeek::detail::RecordConstructorExpr;
+using TableConstructorExpr [[deprecated("Remove in v4.1. Use zeek::detail::TableConstructorExpr instead.")]] = zeek::detail::TableConstructorExpr;
+using SetConstructorExpr [[deprecated("Remove in v4.1. Use zeek::detail::SetConstructorExpr instead.")]] = zeek::detail::SetConstructorExpr;
+using VectorConstructorExpr [[deprecated("Remove in v4.1. Use zeek::detail::VectorConstructorExpr instead.")]] = zeek::detail::VectorConstructorExpr;
+using FieldAssignExpr [[deprecated("Remove in v4.1. Use zeek::detail::FieldAssignExpr instead.")]] = zeek::detail::FieldAssignExpr;
+using ArithCoerceExpr [[deprecated("Remove in v4.1. Use zeek::detail::ArithCoerceExpr instead.")]] = zeek::detail::ArithCoerceExpr;
+using RecordCoerceExpr [[deprecated("Remove in v4.1. Use zeek::detail::RecordCoerceExpr instead.")]] = zeek::detail::RecordCoerceExpr;
+using TableCoerceExpr [[deprecated("Remove in v4.1. Use zeek::detail::TableCoerceExpr instead.")]] = zeek::detail::TableCoerceExpr;
+using VectorCoerceExpr [[deprecated("Remove in v4.1. Use zeek::detail::VectorCoerceExpr instead.")]] = zeek::detail::VectorCoerceExpr;
+using ScheduleTimer [[deprecated("Remove in v4.1. Use zeek::detail::ScheduleTimer instead.")]] = zeek::detail::ScheduleTimer;
+using ScheduleExpr [[deprecated("Remove in v4.1. Use zeek::detail::ScheduleExpr instead.")]] = zeek::detail::ScheduleExpr;
+using InExpr [[deprecated("Remove in v4.1. Use zeek::detail::InExpr instead.")]] = zeek::detail::InExpr;
+using CallExpr [[deprecated("Remove in v4.1. Use zeek::detail::CallExpr instead.")]] = zeek::detail::CallExpr;
+using LambdaExpr [[deprecated("Remove in v4.1. Use zeek::detail::LambdaExpr instead.")]] = zeek::detail::LambdaExpr;
+using EventExpr [[deprecated("Remove in v4.1. Use zeek::detail::EventExpr instead.")]] = zeek::detail::EventExpr;
+using ListExpr [[deprecated("Remove in v4.1. Use zeek::detail::ListExpr instead.")]] = zeek::detail::ListExpr;
+using RecordAssignExpr [[deprecated("Remove in v4.1. Use zeek::detail::RecordAssignExpr instead.")]] = zeek::detail::RecordAssignExpr;
+using CastExpr [[deprecated("Remove in v4.1. Use zeek::detail::CastExpr instead.")]] = zeek::detail::CastExpr;
+using IsExpr [[deprecated("Remove in v4.1. Use zeek::detail::IsExpr instead.")]] = zeek::detail::IsExpr;
diff --git a/src/Frame.h b/src/Frame.h
index e203fa17bd..d7a1a26a28 100644
--- a/src/Frame.h
+++ b/src/Frame.h
@@ -17,9 +17,10 @@
 #include <broker/expected.hh>
 
 namespace trigger { class Trigger; }
-class CallExpr;
 class BroFunc;
 
+FORWARD_DECLARE_NAMESPACED(CallExpr, zeek::detail);
+
 class Frame :  public BroObj {
 public:
 	/**
@@ -219,9 +220,9 @@ public:
 	void ClearTrigger();
 	trigger::Trigger* GetTrigger() const		{ return trigger.get(); }
 
-	void SetCall(const CallExpr* arg_call)	{ call = arg_call; }
+	void SetCall(const zeek::detail::CallExpr* arg_call)	{ call = arg_call; }
 	void ClearCall()			{ call = nullptr; }
-	const CallExpr* GetCall() const		{ return call; }
+	const zeek::detail::CallExpr* GetCall() const		{ return call; }
 
 	void SetDelayed()	{ delayed = true; }
 	bool HasDelayed() const	{ return delayed; }
@@ -322,7 +323,7 @@ private:
 	zeek::detail::Stmt* next_stmt;
 
 	IntrusivePtr<trigger::Trigger> trigger;
-	const CallExpr* call;
+	const zeek::detail::CallExpr* call;
 
 	std::unique_ptr<std::vector<BroFunc*>> functions_with_closure_frame_reference;
 };
diff --git a/src/Func.cc b/src/Func.cc
index 77dbabaea6..ad1c7b03b9 100644
--- a/src/Func.cc
+++ b/src/Func.cc
@@ -343,7 +343,7 @@ IntrusivePtr<Val> BroFunc::Invoke(zeek::Args* args, Frame* parent) const
 		}
 
 	g_frame_stack.push_back(f.get());	// used for backtracing
-	const CallExpr* call_expr = parent ? parent->GetCall() : nullptr;
+	const zeek::detail::CallExpr* call_expr = parent ? parent->GetCall() : nullptr;
 	call_stack.emplace_back(CallInfo{call_expr, this, *args});
 
 	if ( g_trace_state.DoTrace() )
@@ -641,7 +641,7 @@ IntrusivePtr<Val> BuiltinFunc::Invoke(zeek::Args* args, Frame* parent) const
 		g_trace_state.LogTrace("\tBuiltin Function called: %s\n", d.Description());
 		}
 
-	const CallExpr* call_expr = parent ? parent->GetCall() : nullptr;
+	const zeek::detail::CallExpr* call_expr = parent ? parent->GetCall() : nullptr;
 	call_stack.emplace_back(CallInfo{call_expr, this, *args});
 	auto result = std::move(func(parent, args).rval);
 	call_stack.pop_back();
@@ -675,7 +675,7 @@ void builtin_error(const char* msg, IntrusivePtr<Val> arg)
 
 void builtin_error(const char* msg, BroObj* arg)
 	{
-	auto emit = [=](const CallExpr* ce)
+	auto emit = [=](const zeek::detail::CallExpr* ce)
 		{
 		if ( ce )
 			ce->Error(msg, arg);
@@ -789,7 +789,7 @@ void init_builtin_funcs_subdirs()
 	#include "__all__.bif.init.cc" // Autogenerated for compiling in the bif_target() code.
 }
 
-bool check_built_in_call(BuiltinFunc* f, CallExpr* call)
+bool check_built_in_call(BuiltinFunc* f, zeek::detail::CallExpr* call)
 	{
 	if ( f->TheFunc() != zeek::BifFunc::fmt_bif)
 		return true;
@@ -802,7 +802,7 @@ bool check_built_in_call(BuiltinFunc* f, CallExpr* call)
 		return true;
 		}
 
-	const Expr* fmt_str_arg = args[0];
+	const zeek::detail::Expr* fmt_str_arg = args[0];
 	if ( fmt_str_arg->GetType()->Tag() != TYPE_STRING )
 		{
 		call->Error("first argument to fmt() needs to be a format string");
diff --git a/src/Func.h b/src/Func.h
index 88a805ad5a..6dbe12edac 100644
--- a/src/Func.h
+++ b/src/Func.h
@@ -20,14 +20,13 @@
 #include "ZeekArgs.h"
 
 class Val;
-class ListExpr;
 class FuncType;
 class Frame;
 class ID;
-class CallExpr;
 class Scope;
 
 FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
+FORWARD_DECLARE_NAMESPACED(CallExpr, zeek::detail);
 
 class Func : public BroObj {
 public:
@@ -254,10 +253,10 @@ extern void builtin_error(const char* msg, BroObj* arg);
 extern void init_builtin_funcs();
 extern void init_builtin_funcs_subdirs();
 
-extern bool check_built_in_call(BuiltinFunc* f, CallExpr* call);
+extern bool check_built_in_call(BuiltinFunc* f, zeek::detail::CallExpr* call);
 
 struct CallInfo {
-	const CallExpr* call;
+	const zeek::detail::CallExpr* call;
 	const Func* func;
 	const zeek::Args& args;
 };
diff --git a/src/ID.cc b/src/ID.cc
index 20172a5e54..b21200155d 100644
--- a/src/ID.cc
+++ b/src/ID.cc
@@ -205,7 +205,7 @@ void ID::SetVal(IntrusivePtr<Val> v, init_class c)
 		}
 	}
 
-void ID::SetVal(IntrusivePtr<Expr> ev, init_class c)
+void ID::SetVal(IntrusivePtr<zeek::detail::Expr> ev, init_class c)
 	{
 	const auto& a = attrs->Find(c == INIT_EXTRA ? ATTR_ADD_FUNC : ATTR_DEL_FUNC);
 
@@ -276,7 +276,7 @@ bool ID::IsDeprecated() const
 	return GetAttr(ATTR_DEPRECATED) != nullptr;
 	}
 
-void ID::MakeDeprecated(IntrusivePtr<Expr> deprecation)
+void ID::MakeDeprecated(IntrusivePtr<zeek::detail::Expr> deprecation)
 	{
 	if ( IsDeprecated() )
 		return;
@@ -292,7 +292,7 @@ std::string ID::GetDeprecationWarning() const
 
 	if ( depr_attr )
 		{
-		auto expr = static_cast<ConstExpr*>(depr_attr->GetExpr().get());
+		auto expr = static_cast<zeek::detail::ConstExpr*>(depr_attr->GetExpr().get());
 		if ( expr )
 			{
 			StringVal* text = expr->Value()->AsStringVal();
@@ -337,13 +337,13 @@ void ID::SetOption()
 		}
 	}
 
-void ID::EvalFunc(IntrusivePtr<Expr> ef, IntrusivePtr<Expr> ev)
+void ID::EvalFunc(IntrusivePtr<zeek::detail::Expr> ef, IntrusivePtr<zeek::detail::Expr> ev)
 	{
-	auto arg1 = make_intrusive<ConstExpr>(val);
-	auto args = make_intrusive<ListExpr>();
+	auto arg1 = make_intrusive<zeek::detail::ConstExpr>(val);
+	auto args = make_intrusive<zeek::detail::ListExpr>();
 	args->Append(std::move(arg1));
 	args->Append(std::move(ev));
-	auto ce = make_intrusive<CallExpr>(std::move(ef), std::move(args));
+	auto ce = make_intrusive<zeek::detail::CallExpr>(std::move(ef), std::move(args));
 	SetVal(ce->Eval(nullptr));
 	}
 
diff --git a/src/ID.h b/src/ID.h
index 5c0c5e84b7..ad11c5bf9b 100644
--- a/src/ID.h
+++ b/src/ID.h
@@ -14,7 +14,6 @@
 #include <vector>
 
 class Val;
-class Expr;
 class Func;
 class BroType;
 class RecordType;
@@ -23,6 +22,8 @@ class VectorType;
 class EnumType;
 class Attributes;
 
+FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
+
 typedef enum { INIT_NONE, INIT_FULL, INIT_EXTRA, INIT_REMOVE, } init_class;
 typedef enum { SCOPE_FUNCTION, SCOPE_MODULE, SCOPE_GLOBAL } IDScope;
 
@@ -70,7 +71,7 @@ public:
 	void SetVal(IntrusivePtr<Val> v);
 
 	void SetVal(IntrusivePtr<Val> v, init_class c);
-	void SetVal(IntrusivePtr<Expr> ev, init_class c);
+	void SetVal(IntrusivePtr<zeek::detail::Expr> ev, init_class c);
 
 	bool HasVal() const		{ return val != nullptr; }
 
@@ -117,7 +118,7 @@ public:
 
 	bool IsDeprecated() const;
 
-	void MakeDeprecated(IntrusivePtr<Expr> deprecation);
+	void MakeDeprecated(IntrusivePtr<zeek::detail::Expr> deprecation);
 
 	std::string GetDeprecationWarning() const;
 
@@ -144,7 +145,7 @@ public:
 	std::vector<Func*> GetOptionHandlers() const;
 
 protected:
-	void EvalFunc(IntrusivePtr<Expr> ef, IntrusivePtr<Expr> ev);
+	void EvalFunc(IntrusivePtr<zeek::detail::Expr> ef, IntrusivePtr<zeek::detail::Expr> ev);
 
 #ifdef DEBUG
 	void UpdateValID();
diff --git a/src/Reporter.cc b/src/Reporter.cc
index a692c957ce..e881706834 100644
--- a/src/Reporter.cc
+++ b/src/Reporter.cc
@@ -143,7 +143,7 @@ void Reporter::FatalErrorWithCore(const char* fmt, ...)
 	abort();
 	}
 
-void Reporter::ExprRuntimeError(const Expr* expr, const char* fmt, ...)
+void Reporter::ExprRuntimeError(const zeek::detail::Expr* expr, const char* fmt, ...)
 	{
 	++errors;
 
diff --git a/src/Reporter.h b/src/Reporter.h
index 337b3664ea..30597c2a99 100644
--- a/src/Reporter.h
+++ b/src/Reporter.h
@@ -36,7 +36,8 @@ protected:
 };
 
 class IPAddr;
-class Expr;
+
+FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
 
 #define FMT_ATTR __attribute__((format(printf, 2, 3))) // sic! 1st is "this" I guess.
 
@@ -77,7 +78,7 @@ public:
 
 	// Report a runtime error in evaluating a Bro script expression. This
 	// function will not return but raise an InterpreterException.
-	[[noreturn]] void ExprRuntimeError(const Expr* expr, const char* fmt, ...) __attribute__((format(printf, 3, 4)));
+	[[noreturn]] void ExprRuntimeError(const zeek::detail::Expr* expr, const char* fmt, ...) __attribute__((format(printf, 3, 4)));
 
 	// Report a runtime error in evaluating a Bro script expression. This
 	// function will not return but raise an InterpreterException.
diff --git a/src/Stmt.h b/src/Stmt.h
index 55cc919770..b39872aee8 100644
--- a/src/Stmt.h
+++ b/src/Stmt.h
@@ -14,14 +14,14 @@
 #include "TraverseTypes.h"
 
 class CompositeHash;
-class EventExpr;
-class ListExpr;
 class Frame;
 
 namespace zeek::detail {
 
 class StmtList;
 class ForStmt;
+class EventExpr;
+class ListExpr;
 
 class Stmt : public BroObj {
 public:
diff --git a/src/Traverse.h b/src/Traverse.h
index 6c01fb88b7..10b37c7385 100644
--- a/src/Traverse.h
+++ b/src/Traverse.h
@@ -6,10 +6,10 @@
 
 class Func;
 class Scope;
-class Expr;
 class ID;
 
 FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
+FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
 
 class TraversalCallback {
 public:
@@ -22,8 +22,8 @@ public:
 	virtual TraversalCode PreStmt(const zeek::detail::Stmt*) { return TC_CONTINUE; }
 	virtual TraversalCode PostStmt(const zeek::detail::Stmt*) { return TC_CONTINUE; }
 
-	virtual TraversalCode PreExpr(const Expr*) { return TC_CONTINUE; }
-	virtual TraversalCode PostExpr(const Expr*) { return TC_CONTINUE; }
+	virtual TraversalCode PreExpr(const zeek::detail::Expr*) { return TC_CONTINUE; }
+	virtual TraversalCode PostExpr(const zeek::detail::Expr*) { return TC_CONTINUE; }
 
 	virtual TraversalCode PreID(const ID*) { return TC_CONTINUE; }
 	virtual TraversalCode PostID(const ID*) { return TC_CONTINUE; }
diff --git a/src/Trigger.cc b/src/Trigger.cc
index 0d26fb70d5..2781270dd0 100644
--- a/src/Trigger.cc
+++ b/src/Trigger.cc
@@ -16,6 +16,7 @@
 #include "iosource/Manager.h"
 
 using namespace trigger;
+using namespace zeek::detail;
 
 // Callback class to traverse an expression, registering all relevant IDs and
 // Vals for change notifications.
@@ -30,7 +31,7 @@ public:
 	~TriggerTraversalCallback()
 		{ Unref(trigger); }
 
-	virtual TraversalCode PreExpr(const Expr*);
+	virtual TraversalCode PreExpr(const zeek::detail::Expr*);
 
 private:
 	Trigger* trigger;
@@ -38,7 +39,7 @@ private:
 
 }
 
-TraversalCode TriggerTraversalCallback::PreExpr(const Expr* expr)
+TraversalCode TriggerTraversalCallback::PreExpr(const zeek::detail::Expr* expr)
 	{
 	// We catch all expressions here which in some way reference global
 	// state.
@@ -46,7 +47,7 @@ TraversalCode TriggerTraversalCallback::PreExpr(const Expr* expr)
 	switch ( expr->Tag() ) {
 	case EXPR_NAME:
 		{
-		const NameExpr* e = static_cast<const NameExpr*>(expr);
+		const auto* e = static_cast<const zeek::detail::NameExpr*>(expr);
 		if ( e->Id()->IsGlobal() )
 			trigger->Register(e->Id());
 
@@ -59,7 +60,7 @@ TraversalCode TriggerTraversalCallback::PreExpr(const Expr* expr)
 
 	case EXPR_INDEX:
 		{
-		const IndexExpr* e = static_cast<const IndexExpr*>(expr);
+		const auto* e = static_cast<const zeek::detail::IndexExpr*>(expr);
 		BroObj::SuppressErrors no_errors;
 
 		try
@@ -122,9 +123,9 @@ protected:
 
 }
 
-Trigger::Trigger(Expr* arg_cond, zeek::detail::Stmt* arg_body,
+Trigger::Trigger(zeek::detail::Expr* arg_cond, zeek::detail::Stmt* arg_body,
 			zeek::detail::Stmt* arg_timeout_stmts,
-			Expr* arg_timeout, Frame* arg_frame,
+			zeek::detail::Expr* arg_timeout, Frame* arg_frame,
 			bool arg_is_return, const Location* arg_location)
 	{
 	cond = arg_cond;
@@ -441,7 +442,7 @@ void Trigger::Attach(Trigger *trigger)
 	Hold();
 	}
 
-bool Trigger::Cache(const CallExpr* expr, Val* v)
+bool Trigger::Cache(const zeek::detail::CallExpr* expr, Val* v)
 	{
 	if ( disabled || ! v )
 		return false;
@@ -464,7 +465,7 @@ bool Trigger::Cache(const CallExpr* expr, Val* v)
 	}
 
 
-Val* Trigger::Lookup(const CallExpr* expr)
+Val* Trigger::Lookup(const zeek::detail::CallExpr* expr)
 	{
 	assert(! disabled);
 
diff --git a/src/Trigger.h b/src/Trigger.h
index bc6dcf50fd..7a20bf40ee 100644
--- a/src/Trigger.h
+++ b/src/Trigger.h
@@ -9,14 +9,14 @@
 #include "iosource/IOSource.h"
 #include "util.h"
 
-class CallExpr;
-class Expr;
 class Frame;
 class Val;
 class ID;
 class ODesc;
 
 FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
+FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
+FORWARD_DECLARE_NAMESPACED(CallExpr, zeek::detail);
 
 namespace trigger {
 // Triggers are the heart of "when" statements: expressions that when
@@ -31,7 +31,7 @@ public:
 	// instantiation.  Note that if the condition is already true, the
 	// statements are executed immediately and the object is deleted
 	// right away.
-	Trigger(Expr* cond, zeek::detail::Stmt* body, zeek::detail::Stmt* timeout_stmts, Expr* timeout,
+	Trigger(zeek::detail::Expr* cond, zeek::detail::Stmt* body, zeek::detail::Stmt* timeout_stmts, zeek::detail::Expr* timeout,
 		Frame* f, bool is_return, const Location* loc);
 	~Trigger() override;
 
@@ -62,8 +62,8 @@ public:
 	// Cache for return values of delayed function calls.  Returns whether
 	// the trigger is queued for later evaluation -- it may not be queued
 	// if the Val is null or it's disabled.
-	bool Cache(const CallExpr* expr, Val* val);
-	Val* Lookup(const CallExpr*);
+	bool Cache(const zeek::detail::CallExpr* expr, Val* val);
+	Val* Lookup(const zeek::detail::CallExpr*);
 
 	// Disable this trigger completely. Needed because Unref'ing the trigger
 	// may not immediately delete it as other references may still exist.
@@ -93,10 +93,10 @@ private:
 	void Register(Val* val);
 	void UnregisterAll();
 
-	Expr* cond;
+	zeek::detail::Expr* cond;
 	zeek::detail::Stmt* body;
 	zeek::detail::Stmt* timeout_stmts;
-	Expr* timeout;
+	zeek::detail::Expr* timeout;
 	double timeout_value;
 	Frame* frame;
 	bool is_return;
@@ -110,7 +110,7 @@ private:
 
 	std::vector<std::pair<BroObj *, notifier::Modifiable*>> objs;
 
-	using ValCache = std::map<const CallExpr*, Val*>;
+	using ValCache = std::map<const zeek::detail::CallExpr*, Val*>;
 	ValCache cache;
 };
 
diff --git a/src/Type.cc b/src/Type.cc
index 382da6cb8c..a6bbed2098 100644
--- a/src/Type.cc
+++ b/src/Type.cc
@@ -95,7 +95,7 @@ IntrusivePtr<BroType> BroType::ShallowClone()
 	return nullptr;
 	}
 
-int BroType::MatchesIndex(ListExpr* const index) const
+int BroType::MatchesIndex(zeek::detail::ListExpr* const index) const
 	{
 	if ( Tag() == TYPE_STRING )
 		{
@@ -220,7 +220,7 @@ unsigned int TypeList::MemoryAllocation() const
 
 IndexType::~IndexType() = default;
 
-int IndexType::MatchesIndex(ListExpr* const index) const
+int IndexType::MatchesIndex(zeek::detail::ListExpr* const index) const
 	{
 	// If we have a type indexed by subnets, addresses are ok.
 	const auto& types = indices->Types();
@@ -353,7 +353,7 @@ bool TableType::IsUnspecifiedTable() const
 	return indices->Types().empty();
 	}
 
-SetType::SetType(IntrusivePtr<TypeList> ind, IntrusivePtr<ListExpr> arg_elements)
+SetType::SetType(IntrusivePtr<TypeList> ind, IntrusivePtr<zeek::detail::ListExpr> arg_elements)
 	: TableType(std::move(ind), nullptr), elements(std::move(arg_elements))
 	{
 	if ( elements )
@@ -471,7 +471,7 @@ string FuncType::FlavorString() const
 
 FuncType::~FuncType() = default;
 
-int FuncType::MatchesIndex(ListExpr* const index) const
+int FuncType::MatchesIndex(zeek::detail::ListExpr* const index) const
 	{
 	return check_and_promote_args(index, args.get()) ?
 			MATCHES_INDEX_SCALAR : DOES_NOT_MATCH_INDEX;
@@ -995,7 +995,7 @@ string RecordType::GetFieldDeprecationWarning(int field, bool has_check) const
 		string result;
 		if ( const auto& deprecation = decl->GetAttr(ATTR_DEPRECATED) )
 			{
-			auto expr = static_cast<ConstExpr*>(deprecation->GetExpr().get());
+			auto expr = static_cast<zeek::detail::ConstExpr*>(deprecation->GetExpr().get());
 			if ( expr )
 				{
 				StringVal* text = expr->Value()->AsStringVal();
@@ -1094,7 +1094,7 @@ EnumType::~EnumType() = default;
 // Note, we use reporter->Error() here (not Error()) to include the current script
 // location in the error message, rather than the one where the type was
 // originally defined.
-void EnumType::AddName(const string& module_name, const char* name, bool is_export, Expr* deprecation)
+void EnumType::AddName(const string& module_name, const char* name, bool is_export, zeek::detail::Expr* deprecation)
 	{
 	/* implicit, auto-increment */
 	if ( counter < 0)
@@ -1107,7 +1107,7 @@ void EnumType::AddName(const string& module_name, const char* name, bool is_expo
 	counter++;
 	}
 
-void EnumType::AddName(const string& module_name, const char* name, bro_int_t val, bool is_export, Expr* deprecation)
+void EnumType::AddName(const string& module_name, const char* name, bro_int_t val, bool is_export, zeek::detail::Expr* deprecation)
 	{
 	/* explicit value specified */
 	if ( counter > 0 )
@@ -1121,7 +1121,7 @@ void EnumType::AddName(const string& module_name, const char* name, bro_int_t va
 	}
 
 void EnumType::CheckAndAddName(const string& module_name, const char* name,
-                               bro_int_t val, bool is_export, Expr* deprecation)
+                               bro_int_t val, bool is_export, zeek::detail::Expr* deprecation)
 	{
 	if ( Lookup(val) )
 		{
@@ -1325,7 +1325,7 @@ const IntrusivePtr<BroType>& VectorType::Yield() const
 	return yield_type;
 	}
 
-int VectorType::MatchesIndex(ListExpr* const index) const
+int VectorType::MatchesIndex(zeek::detail::ListExpr* const index) const
 	{
 	expr_list& el = index->Exprs();
 
@@ -1938,7 +1938,7 @@ IntrusivePtr<BroType> merge_types(const IntrusivePtr<BroType>& arg_t1,
 	}
 	}
 
-IntrusivePtr<BroType> merge_type_list(ListExpr* elements)
+IntrusivePtr<BroType> merge_type_list(zeek::detail::ListExpr* elements)
 	{
 	TypeList* tl_type = elements->GetType()->AsTypeList();
 	const auto& tl = tl_type->Types();
@@ -1983,9 +1983,9 @@ static BroType* reduce_type(BroType* t)
 		return t;
 	}
 
-IntrusivePtr<BroType> init_type(Expr* init)
+IntrusivePtr<BroType> init_type(zeek::detail::Expr* init)
 	{
-	if ( init->Tag() != EXPR_LIST )
+	if ( init->Tag() != zeek::detail::EXPR_LIST )
 		{
 		auto t = init->InitType();
 
@@ -2002,7 +2002,7 @@ IntrusivePtr<BroType> init_type(Expr* init)
 		return t;
 		}
 
-	ListExpr* init_list = init->AsListExpr();
+	zeek::detail::ListExpr* init_list = init->AsListExpr();
 	const expr_list& el = init_list->Exprs();
 
 	if ( el.length() == 0 )
@@ -2012,7 +2012,7 @@ IntrusivePtr<BroType> init_type(Expr* init)
 		}
 
 	// Could be a record, a set, or a list of table elements.
-	Expr* e0 = el[0];
+	zeek::detail::Expr* e0 = el[0];
 
 	if ( e0->IsRecordElement(nullptr) )
 		// ListExpr's know how to build a record from their
diff --git a/src/Type.h b/src/Type.h
index 80cd024ce5..66100a65c8 100644
--- a/src/Type.h
+++ b/src/Type.h
@@ -119,7 +119,6 @@ constexpr InternalTypeTag to_internal_type_tag(TypeTag tag) noexcept
 // Returns the name of the type.
 extern const char* type_name(TypeTag t);
 
-class Expr;
 class Attributes;
 class TypeList;
 class TableType;
@@ -127,7 +126,6 @@ class SetType;
 class RecordType;
 class SubNetType;
 class FuncType;
-class ListExpr;
 class EnumType;
 class VectorType;
 class TypeType;
@@ -135,6 +133,9 @@ class OpaqueType;
 class EnumVal;
 class TableVal;
 
+FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
+FORWARD_DECLARE_NAMESPACED(ListExpr, zeek::detail);
+
 const int DOES_NOT_MATCH_INDEX = 0;
 const int MATCHES_INDEX_SCALAR = 1;
 const int MATCHES_INDEX_VECTOR = 2;
@@ -168,7 +169,7 @@ public:
 	// if it matches and produces a vector result; and
 	// DOES_NOT_MATCH_INDEX = 0 if it can't match (or the type
 	// is not an indexable type).
-	virtual int MatchesIndex(ListExpr* index) const;
+	virtual int MatchesIndex(zeek::detail::ListExpr* index) const;
 
 	// Returns the type yielded by this type.  For example, if
 	// this type is a table[string] of port, then returns the "port"
@@ -398,7 +399,7 @@ protected:
 
 class IndexType : public BroType {
 public:
-	int MatchesIndex(ListExpr* index) const override;
+	int MatchesIndex(zeek::detail::ListExpr* index) const override;
 
 	const IntrusivePtr<TypeList>& GetIndices() const
 		{ return indices; }
@@ -445,19 +446,19 @@ public:
 
 class SetType final : public TableType {
 public:
-	SetType(IntrusivePtr<TypeList> ind, IntrusivePtr<ListExpr> arg_elements);
+	SetType(IntrusivePtr<TypeList> ind, IntrusivePtr<zeek::detail::ListExpr> arg_elements);
 	~SetType() override;
 
 	IntrusivePtr<BroType> ShallowClone() override;
 
 	[[deprecated("Remove in v4.1.  Use Elements() isntead.")]]
-	ListExpr* SetElements() const	{ return elements.get(); }
+	zeek::detail::ListExpr* SetElements() const	{ return elements.get(); }
 
-	const IntrusivePtr<ListExpr>& Elements() const
+	const IntrusivePtr<zeek::detail::ListExpr>& Elements() const
 		{ return elements; }
 
 protected:
-	IntrusivePtr<ListExpr> elements;
+	IntrusivePtr<zeek::detail::ListExpr> elements;
 };
 
 class FuncType final : public BroType {
@@ -498,7 +499,7 @@ public:
 	void ClearYieldType(function_flavor arg_flav)
 		{ yield = nullptr; flavor = arg_flav; }
 
-	int MatchesIndex(ListExpr* index) const override;
+	int MatchesIndex(zeek::detail::ListExpr* index) const override;
 	bool CheckArgs(const type_list* args, bool is_init = false) const;
 	bool CheckArgs(const std::vector<IntrusivePtr<BroType>>& args,
 	               bool is_init = false) const;
@@ -736,12 +737,12 @@ public:
 
 	// The value of this name is next internal counter value, starting
 	// with zero. The internal counter is incremented.
-	void AddName(const std::string& module_name, const char* name, bool is_export, Expr* deprecation = nullptr);
+	void AddName(const std::string& module_name, const char* name, bool is_export, zeek::detail::Expr* deprecation = nullptr);
 
 	// The value of this name is set to val. Once a value has been
 	// explicitly assigned using this method, no further names can be
 	// added that aren't likewise explicitly initalized.
-	void AddName(const std::string& module_name, const char* name, bro_int_t val, bool is_export, Expr* deprecation = nullptr);
+	void AddName(const std::string& module_name, const char* name, bro_int_t val, bool is_export, zeek::detail::Expr* deprecation = nullptr);
 
 	// -1 indicates not found.
 	bro_int_t Lookup(const std::string& module_name, const char* name) const;
@@ -761,7 +762,7 @@ protected:
 
 	void CheckAndAddName(const std::string& module_name,
 	                     const char* name, bro_int_t val, bool is_export,
-	                     Expr* deprecation = nullptr);
+	                     zeek::detail::Expr* deprecation = nullptr);
 
 	typedef std::map<std::string, bro_int_t> NameMap;
 	NameMap names;
@@ -786,7 +787,7 @@ public:
 
 	const IntrusivePtr<BroType>& Yield() const override;
 
-	int MatchesIndex(ListExpr* index) const override;
+	int MatchesIndex(zeek::detail::ListExpr* index) const override;
 
 	// Returns true if this table type is "unspecified", which is what one
 	// gets using an empty "vector()" constructor.
@@ -865,10 +866,10 @@ IntrusivePtr<BroType> merge_types(const IntrusivePtr<BroType>& t1,
 // Given a list of expressions, returns a (ref'd) type reflecting
 // a merged type consistent across all of them, or nil if this
 // cannot be done.
-IntrusivePtr<BroType> merge_type_list(ListExpr* elements);
+IntrusivePtr<BroType> merge_type_list(zeek::detail::ListExpr* elements);
 
 // Given an expression, infer its type when used for an initialization.
-IntrusivePtr<BroType> init_type(Expr* init);
+IntrusivePtr<BroType> init_type(zeek::detail::Expr* init);
 
 // Returns true if argument is an atomic type.
 bool is_atomic_type(const BroType& t);
diff --git a/src/Val.cc b/src/Val.cc
index 66a01f1677..31b906d18d 100644
--- a/src/Val.cc
+++ b/src/Val.cc
@@ -1824,8 +1824,9 @@ IntrusivePtr<Val> TableVal::Default(const IntrusivePtr<Val>& index)
 						 ytype->AsRecordType()) )
 			{
 			auto rt = cast_intrusive<RecordType>(ytype);
-			auto coerce = make_intrusive<RecordCoerceExpr>(def_attr->GetExpr(),
-			                                               std::move(rt));
+			auto coerce = make_intrusive<zeek::detail::RecordCoerceExpr>(
+				def_attr->GetExpr(), std::move(rt));
+
 			def_val = coerce->Eval(nullptr);
 			}
 
@@ -2865,9 +2866,9 @@ IntrusivePtr<RecordVal> RecordVal::CoerceTo(IntrusivePtr<RecordType> t,
 
 		if ( ft->Tag() == TYPE_RECORD && ! same_type(ft, v->GetType()) )
 			{
-			auto rhs = make_intrusive<ConstExpr>(v);
-			auto e = make_intrusive<RecordCoerceExpr>(std::move(rhs),
-			                                          cast_intrusive<RecordType>(ft));
+			auto rhs = make_intrusive<zeek::detail::ConstExpr>(v);
+			auto e = make_intrusive<zeek::detail::RecordCoerceExpr>(std::move(rhs),
+			                                                        cast_intrusive<RecordType>(ft));
 			aggr->Assign(t_i, e->Eval(nullptr));
 			continue;
 			}
diff --git a/src/Val.h b/src/Val.h
index 6a7587da37..36e0114a31 100644
--- a/src/Val.h
+++ b/src/Val.h
@@ -1050,13 +1050,13 @@ protected:
 	IntrusivePtr<TableType> table_type;
 	CompositeHash* table_hash;
 	IntrusivePtr<Attributes> attrs;
-	IntrusivePtr<Expr> expire_time;
-	IntrusivePtr<Expr> expire_func;
+	IntrusivePtr<zeek::detail::Expr> expire_time;
+	IntrusivePtr<zeek::detail::Expr> expire_func;
 	TableValTimer* timer;
 	IterCookie* expire_cookie;
 	PrefixTable* subnets;
 	IntrusivePtr<Val> def_val;
-	IntrusivePtr<Expr> change_func;
+	IntrusivePtr<zeek::detail::Expr> change_func;
 	// prevent recursion of change functions
 	bool in_change_func = false;
 
diff --git a/src/Var.cc b/src/Var.cc
index 6f989174a8..e751600096 100644
--- a/src/Var.cc
+++ b/src/Var.cc
@@ -17,7 +17,7 @@
 #include "module_util.h"
 #include "ID.h"
 
-static IntrusivePtr<Val> init_val(Expr* init, const BroType* t,
+static IntrusivePtr<Val> init_val(zeek::detail::Expr* init, const BroType* t,
                                   IntrusivePtr<Val> aggr)
 	{
 	try
@@ -32,7 +32,7 @@ static IntrusivePtr<Val> init_val(Expr* init, const BroType* t,
 
 static bool add_prototype(const IntrusivePtr<ID>& id, BroType* t,
                           std::vector<IntrusivePtr<Attr>>* attrs,
-                          const IntrusivePtr<Expr>& init)
+                          const IntrusivePtr<zeek::detail::Expr>& init)
 	{
 	if ( ! IsFunc(id->GetType()->Tag()) )
 		return false;
@@ -109,7 +109,7 @@ static bool add_prototype(const IntrusivePtr<ID>& id, BroType* t,
 	}
 
 static void make_var(const IntrusivePtr<ID>& id, IntrusivePtr<BroType> t, init_class c,
-                     IntrusivePtr<Expr> init,
+                     IntrusivePtr<zeek::detail::Expr> init,
                      std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attr,
                      decl_type dt,
                      bool do_init)
@@ -204,17 +204,17 @@ static void make_var(const IntrusivePtr<ID>& id, IntrusivePtr<BroType> t, init_c
 	if ( init )
 		{
 		switch ( init->Tag() ) {
-		case EXPR_TABLE_CONSTRUCTOR:
+		case zeek::detail::EXPR_TABLE_CONSTRUCTOR:
 			{
-			TableConstructorExpr* ctor = (TableConstructorExpr*) init.get();
+			auto* ctor = static_cast<zeek::detail::TableConstructorExpr*>(init.get());
 			if ( ctor->GetAttrs() )
 				id->AddAttrs(ctor->GetAttrs());
 			}
 			break;
 
-		case EXPR_SET_CONSTRUCTOR:
+		case zeek::detail::EXPR_SET_CONSTRUCTOR:
 			{
-			SetConstructorExpr* ctor = (SetConstructorExpr*) init.get();
+			auto* ctor = static_cast<zeek::detail::SetConstructorExpr*>(init.get());
 			if ( ctor->GetAttrs() )
 				id->AddAttrs(ctor->GetAttrs());
 			}
@@ -228,7 +228,7 @@ static void make_var(const IntrusivePtr<ID>& id, IntrusivePtr<BroType> t, init_c
 	if ( do_init )
 		{
 		if ( c == INIT_NONE && dt == VAR_REDEF && t->IsTable() &&
-		     init && init->Tag() == EXPR_ASSIGN )
+		     init && init->Tag() == zeek::detail::EXPR_ASSIGN )
 			// e.g. 'redef foo["x"] = 1' is missing an init class, but the
 			// intention clearly isn't to overwrite entire existing table val.
 			c = INIT_EXTRA;
@@ -248,7 +248,7 @@ static void make_var(const IntrusivePtr<ID>& id, IntrusivePtr<BroType> t, init_c
 
 				if ( init && t )
 					// Have an initialization and type is not deduced.
-					init = make_intrusive<RecordCoerceExpr>(std::move(init),
+					init = make_intrusive<zeek::detail::RecordCoerceExpr>(std::move(init),
 					        IntrusivePtr{NewRef{}, t->AsRecordType()});
 				}
 
@@ -307,9 +307,8 @@ static void make_var(const IntrusivePtr<ID>& id, IntrusivePtr<BroType> t, init_c
 		}
 	}
 
-
 void add_global(const IntrusivePtr<ID>& id, IntrusivePtr<BroType> t,
-                init_class c, IntrusivePtr<Expr> init,
+                init_class c, IntrusivePtr<zeek::detail::Expr> init,
                 std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attr,
                 decl_type dt)
 	{
@@ -317,7 +316,7 @@ void add_global(const IntrusivePtr<ID>& id, IntrusivePtr<BroType> t,
 	}
 
 IntrusivePtr<zeek::detail::Stmt> add_local(IntrusivePtr<ID> id, IntrusivePtr<BroType> t,
-                             init_class c, IntrusivePtr<Expr> init,
+                             init_class c, IntrusivePtr<zeek::detail::Expr> init,
                              std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attr,
                              decl_type dt)
 	{
@@ -332,10 +331,10 @@ IntrusivePtr<zeek::detail::Stmt> add_local(IntrusivePtr<ID> id, IntrusivePtr<Bro
 		const Location location = init->GetLocationInfo() ?
 		        *init->GetLocationInfo() : no_location;
 
-		auto name_expr = make_intrusive<NameExpr>(id, dt == VAR_CONST);
-		auto assign_expr = make_intrusive<AssignExpr>(std::move(name_expr),
-		                                              std::move(init), 0,
-		                                              nullptr, id->GetAttrs());
+		auto name_expr = make_intrusive<zeek::detail::NameExpr>(id, dt == VAR_CONST);
+		auto assign_expr = make_intrusive<zeek::detail::AssignExpr>(std::move(name_expr),
+		                                                            std::move(init), 0,
+		                                                            nullptr, id->GetAttrs());
 		auto stmt = make_intrusive<zeek::detail::ExprStmt>(std::move(assign_expr));
 		stmt->SetLocationInfo(&location);
 		return stmt;
@@ -348,14 +347,14 @@ IntrusivePtr<zeek::detail::Stmt> add_local(IntrusivePtr<ID> id, IntrusivePtr<Bro
 		}
 	}
 
-extern IntrusivePtr<Expr> add_and_assign_local(IntrusivePtr<ID> id,
-                                               IntrusivePtr<Expr> init,
+extern IntrusivePtr<zeek::detail::Expr> add_and_assign_local(IntrusivePtr<ID> id,
+                                               IntrusivePtr<zeek::detail::Expr> init,
                                                IntrusivePtr<Val> val)
 	{
 	make_var(id, nullptr, INIT_FULL, init, nullptr, VAR_REGULAR, false);
-	auto name_expr = make_intrusive<NameExpr>(std::move(id));
-	return make_intrusive<AssignExpr>(std::move(name_expr), std::move(init),
-	                                  false, std::move(val));
+	auto name_expr = make_intrusive<zeek::detail::NameExpr>(std::move(id));
+	return make_intrusive<zeek::detail::AssignExpr>(std::move(name_expr), std::move(init),
+	                                                false, std::move(val));
 	}
 
 void add_type(ID* id, IntrusivePtr<BroType> t,
@@ -591,26 +590,26 @@ public:
 		scopes.emplace_back(s);
 		}
 
-	TraversalCode PreExpr(const Expr*) override;
-	TraversalCode PostExpr(const Expr*) override;
+	TraversalCode PreExpr(const zeek::detail::Expr*) override;
+	TraversalCode PostExpr(const zeek::detail::Expr*) override;
 
 	std::vector<Scope*> scopes;
-	std::vector<const NameExpr*> outer_id_references;
+	std::vector<const zeek::detail::NameExpr*> outer_id_references;
 };
 
-TraversalCode OuterIDBindingFinder::PreExpr(const Expr* expr)
+TraversalCode OuterIDBindingFinder::PreExpr(const zeek::detail::Expr* expr)
 	{
-	if ( expr->Tag() == EXPR_LAMBDA )
+	if ( expr->Tag() == zeek::detail::EXPR_LAMBDA )
 		{
-		auto le = static_cast<const LambdaExpr*>(expr);
+		auto le = static_cast<const zeek::detail::LambdaExpr*>(expr);
 		scopes.emplace_back(le->GetScope());
 		return TC_CONTINUE;
 		}
 
-	if ( expr->Tag() != EXPR_NAME )
+	if ( expr->Tag() != zeek::detail::EXPR_NAME )
 		return TC_CONTINUE;
 
-	const NameExpr* e = static_cast<const NameExpr*>(expr);
+	auto* e = static_cast<const zeek::detail::NameExpr*>(expr);
 
 	if ( e->Id()->IsGlobal() )
 		return TC_CONTINUE;
@@ -625,9 +624,9 @@ TraversalCode OuterIDBindingFinder::PreExpr(const Expr* expr)
 	return TC_CONTINUE;
 	}
 
-TraversalCode OuterIDBindingFinder::PostExpr(const Expr* expr)
+TraversalCode OuterIDBindingFinder::PostExpr(const zeek::detail::Expr* expr)
 	{
-	if ( expr->Tag() == EXPR_LAMBDA )
+	if ( expr->Tag() == zeek::detail::EXPR_LAMBDA )
 		scopes.pop_back();
 
 	return TC_CONTINUE;
diff --git a/src/Var.h b/src/Var.h
index ba44b8de00..92805676b1 100644
--- a/src/Var.h
+++ b/src/Var.h
@@ -6,7 +6,6 @@
 #include "ID.h"
 #include "Type.h"
 
-class Expr;
 class FuncType;
 class Scope;
 class EventHandlerPtr;
@@ -15,25 +14,26 @@ class TableVal;
 class ListVal;
 
 FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
+FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
 
 typedef enum { VAR_REGULAR, VAR_CONST, VAR_REDEF, VAR_OPTION, } decl_type;
 
 extern void add_global(const IntrusivePtr<ID>& id,
                        IntrusivePtr<BroType> t,
                        init_class c,
-                       IntrusivePtr<Expr> init,
+                       IntrusivePtr<zeek::detail::Expr> init,
                        std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attr,
                        decl_type dt);
 
 extern IntrusivePtr<zeek::detail::Stmt> add_local(IntrusivePtr<ID> id,
                                                   IntrusivePtr<BroType> t,
                                                   init_class c,
-                                                  IntrusivePtr<Expr> init,
+                                                  IntrusivePtr<zeek::detail::Expr> init,
                                                   std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attr,
                                                   decl_type dt);
 
-extern IntrusivePtr<Expr> add_and_assign_local(IntrusivePtr<ID> id,
-                                               IntrusivePtr<Expr> init,
+extern IntrusivePtr<zeek::detail::Expr> add_and_assign_local(IntrusivePtr<ID> id,
+                                               IntrusivePtr<zeek::detail::Expr> init,
                                                IntrusivePtr<Val> val = nullptr);
 
 extern void add_type(ID* id, IntrusivePtr<BroType> t,
diff --git a/src/broker/Store.h b/src/broker/Store.h
index 186bb519ba..9f9764b4b4 100644
--- a/src/broker/Store.h
+++ b/src/broker/Store.h
@@ -50,7 +50,7 @@ inline IntrusivePtr<RecordVal> query_result(IntrusivePtr<RecordVal> data)
  */
 class StoreQueryCallback {
 public:
-	StoreQueryCallback(trigger::Trigger* arg_trigger, const CallExpr* arg_call,
+	StoreQueryCallback(trigger::Trigger* arg_trigger, const zeek::detail::CallExpr* arg_call,
 			   broker::store store)
 		: trigger(arg_trigger), call(arg_call), store(std::move(store))
 		{
@@ -84,7 +84,7 @@ public:
 private:
 
 	trigger::Trigger* trigger;
-	const CallExpr* call;
+	const zeek::detail::CallExpr* call;
 	broker::store store;
 };
 
diff --git a/src/input.h b/src/input.h
index fa6da97cec..665273490d 100644
--- a/src/input.h
+++ b/src/input.h
@@ -22,7 +22,7 @@ extern void add_to_name_list(char* s, char delim, name_list& nl);
 
 extern void begin_RE();
 
-extern void do_atif(Expr* expr);
+extern void do_atif(zeek::detail::Expr* expr);
 extern void do_atifdef(const char* id);
 extern void do_atifndef(const char* id);
 extern void do_atelse();
diff --git a/src/parse.y b/src/parse.y
index 5900f7f64c..d6e03551a8 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -121,7 +121,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 Expr* g_curr_debug_expr;
+extern zeek::detail::Expr* g_curr_debug_expr;
 extern bool in_debug;
 extern const char* g_curr_debug_error;
 
@@ -212,9 +212,9 @@ make_attributes(std::vector<IntrusivePtr<Attr>>* attrs,
 	return rval;
 	}
 
-static bool expr_is_table_type_name(const Expr* expr)
+static bool expr_is_table_type_name(const zeek::detail::Expr* expr)
 	{
-	if ( expr->Tag() != EXPR_NAME )
+	if ( expr->Tag() != zeek::detail::EXPR_NAME )
 		return false;
 
 	const auto& type = expr->GetType();
@@ -237,10 +237,10 @@ static bool expr_is_table_type_name(const Expr* expr)
 	init_class ic;
 	Val* val;
 	RE_Matcher* re;
-	Expr* expr;
-	EventExpr* event_expr;
+	zeek::detail::Expr* expr;
+	zeek::detail::EventExpr* event_expr;
 	zeek::detail::Stmt* stmt;
-	ListExpr* list;
+	zeek::detail::ListExpr* list;
 	BroType* type;
 	RecordType* record;
 	FuncType* func_type;
@@ -300,169 +300,169 @@ expr:
 	|	TOK_COPY '(' expr ')'
 			{
 			set_location(@1, @4);
-			$$ = new CloneExpr({AdoptRef{}, $3});
+			$$ = new zeek::detail::CloneExpr({AdoptRef{}, $3});
 			}
 
 	|	TOK_INCR expr
 			{
 			set_location(@1, @2);
-			$$ = new IncrExpr(EXPR_INCR, {AdoptRef{}, $2});
+			$$ = new zeek::detail::IncrExpr(zeek::detail::EXPR_INCR, {AdoptRef{}, $2});
 			}
 
 	|	TOK_DECR expr
 			{
 			set_location(@1, @2);
-			$$ = new IncrExpr(EXPR_DECR, {AdoptRef{}, $2});
+			$$ = new zeek::detail::IncrExpr(zeek::detail::EXPR_DECR, {AdoptRef{}, $2});
 			}
 
 	|	'!' expr
 			{
 			set_location(@1, @2);
-			$$ = new NotExpr({AdoptRef{}, $2});
+			$$ = new zeek::detail::NotExpr({AdoptRef{}, $2});
 			}
 
 	|	'~' expr
 			{
 			set_location(@1, @2);
-			$$ = new ComplementExpr({AdoptRef{}, $2});
+			$$ = new zeek::detail::ComplementExpr({AdoptRef{}, $2});
 			}
 
 	|	'-' expr	%prec '!'
 			{
 			set_location(@1, @2);
-			$$ = new NegExpr({AdoptRef{}, $2});
+			$$ = new zeek::detail::NegExpr({AdoptRef{}, $2});
 			}
 
 	|	'+' expr	%prec '!'
 			{
 			set_location(@1, @2);
-			$$ = new PosExpr({AdoptRef{}, $2});
+			$$ = new zeek::detail::PosExpr({AdoptRef{}, $2});
 			}
 
 	|	expr '+' expr
 			{
 			set_location(@1, @3);
-			$$ = new AddExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::AddExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_ADD_TO expr
 			{
 			set_location(@1, @3);
-			$$ = new AddToExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::AddToExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '-' expr
 			{
 			set_location(@1, @3);
-			$$ = new SubExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::SubExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_REMOVE_FROM expr
 			{
 			set_location(@1, @3);
-			$$ = new RemoveFromExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::RemoveFromExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '*' expr
 			{
 			set_location(@1, @3);
-			$$ = new TimesExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::TimesExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '/' expr
 			{
 			set_location(@1, @3);
-			$$ = new DivideExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::DivideExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '%' expr
 			{
 			set_location(@1, @3);
-			$$ = new ModExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::ModExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '&' expr
 			{
 			set_location(@1, @3);
-			$$ = new BitExpr(EXPR_AND, {AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::BitExpr(zeek::detail::EXPR_AND, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '|' expr
 			{
 			set_location(@1, @3);
-			$$ = new BitExpr(EXPR_OR, {AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::BitExpr(zeek::detail::EXPR_OR, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '^' expr
 			{
 			set_location(@1, @3);
-			$$ = new BitExpr(EXPR_XOR, {AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::BitExpr(zeek::detail::EXPR_XOR, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_AND_AND expr
 			{
 			set_location(@1, @3);
-			$$ = new BoolExpr(EXPR_AND_AND, {AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::BoolExpr(zeek::detail::EXPR_AND_AND, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_OR_OR expr
 			{
 			set_location(@1, @3);
-			$$ = new BoolExpr(EXPR_OR_OR, {AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::BoolExpr(zeek::detail::EXPR_OR_OR, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_EQ expr
 			{
 			set_location(@1, @3);
-			$$ = new EqExpr(EXPR_EQ, {AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::EqExpr(zeek::detail::EXPR_EQ, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_NE expr
 			{
 			set_location(@1, @3);
-			$$ = new EqExpr(EXPR_NE, {AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::EqExpr(zeek::detail::EXPR_NE, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '<' expr
 			{
 			set_location(@1, @3);
-			$$ = new RelExpr(EXPR_LT, {AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::RelExpr(zeek::detail::EXPR_LT, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_LE expr
 			{
 			set_location(@1, @3);
-			$$ = new RelExpr(EXPR_LE, {AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::RelExpr(zeek::detail::EXPR_LE, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '>' expr
 			{
 			set_location(@1, @3);
-			$$ = new RelExpr(EXPR_GT, {AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::RelExpr(zeek::detail::EXPR_GT, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_GE expr
 			{
 			set_location(@1, @3);
-			$$ = new RelExpr(EXPR_GE, {AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::RelExpr(zeek::detail::EXPR_GE, {AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr '?' expr ':' expr
 			{
 			set_location(@1, @5);
-			$$ = new CondExpr({AdoptRef{}, $1}, {AdoptRef{}, $3}, {AdoptRef{}, $5});
+			$$ = new zeek::detail::CondExpr({AdoptRef{}, $1}, {AdoptRef{}, $3}, {AdoptRef{}, $5});
 			}
 
 	|	expr '=' expr
 			{
 			set_location(@1, @3);
 
-			if ( $1->Tag() == EXPR_INDEX && $1->AsIndexExpr()->IsSlice() )
+			if ( $1->Tag() == zeek::detail::EXPR_INDEX && $1->AsIndexExpr()->IsSlice() )
 				reporter->Error("index slice assignment may not be used"
 				                " in arbitrary expression contexts, only"
 				                " as a statement");
 
-			$$ = get_assign_expr({AdoptRef{}, $1}, {AdoptRef{}, $3}, in_init).release();
+			$$ = zeek::detail::get_assign_expr({AdoptRef{}, $1}, {AdoptRef{}, $3}, in_init).release();
 			}
 
 	|	TOK_LOCAL local_id '=' expr
@@ -475,7 +475,7 @@ expr:
 	|	expr '[' expr_list ']'
 			{
 			set_location(@1, @4);
-			$$ = new IndexExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::IndexExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	index_slice
@@ -483,13 +483,13 @@ expr:
 	|	expr '$' TOK_ID
 			{
 			set_location(@1, @3);
-			$$ = new FieldExpr({AdoptRef{}, $1}, $3);
+			$$ = new zeek::detail::FieldExpr({AdoptRef{}, $1}, $3);
 			}
 
 	|	'$' TOK_ID '=' expr
 			{
 			set_location(@1, @4);
-			$$ = new FieldAssignExpr($2, {AdoptRef{}, $4});
+			$$ = new zeek::detail::FieldAssignExpr($2, {AdoptRef{}, $4});
 			}
 
 	|	'$' TOK_ID func_params '='
@@ -503,21 +503,21 @@ expr:
 			}
 		 lambda_body
 			{
-			$$ = new FieldAssignExpr($2, IntrusivePtr{AdoptRef{}, $6});
+			$$ = new zeek::detail::FieldAssignExpr($2, IntrusivePtr{AdoptRef{}, $6});
 			}
 
 	|	expr TOK_IN expr
 			{
 			set_location(@1, @3);
-			$$ = new InExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::InExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|	expr TOK_NOT_IN expr
 			{
 			set_location(@1, @3);
-			$$ = new NotExpr(make_intrusive<InExpr>(
-			        IntrusivePtr<Expr>{AdoptRef{}, $1},
-			        IntrusivePtr<Expr>{AdoptRef{}, $3}));
+			$$ = new zeek::detail::NotExpr(make_intrusive<zeek::detail::InExpr>(
+			        IntrusivePtr<zeek::detail::Expr>{AdoptRef{}, $1},
+			        IntrusivePtr<zeek::detail::Expr>{AdoptRef{}, $3}));
 			}
 
 	|	'[' expr_list ']'
@@ -532,7 +532,7 @@ expr:
 
 			for ( int i = 0; i < $2->Exprs().length(); ++i )
 				{
-				if ( $2->Exprs()[i]->Tag() != EXPR_FIELD_ASSIGN )
+				if ( $2->Exprs()[i]->Tag() != zeek::detail::EXPR_FIELD_ASSIGN )
 					{
 					is_record_ctor = false;
 					break;
@@ -540,7 +540,7 @@ expr:
 				}
 
 			if ( is_record_ctor )
-				$$ = new RecordConstructorExpr({AdoptRef{}, $2});
+				$$ = new zeek::detail::RecordConstructorExpr({AdoptRef{}, $2});
 			else
 				$$ = $2;
 			}
@@ -548,14 +548,14 @@ expr:
 	|	'[' ']'
 			{
 			// We interpret this as an empty record constructor.
-			$$ = new RecordConstructorExpr(make_intrusive<ListExpr>());
+			$$ = new zeek::detail::RecordConstructorExpr(make_intrusive<zeek::detail::ListExpr>());
 			}
 
 
 	|	TOK_RECORD '(' expr_list ')'
 			{
 			set_location(@1, @4);
-			$$ = new RecordConstructorExpr({AdoptRef{}, $3});
+			$$ = new zeek::detail::RecordConstructorExpr({AdoptRef{}, $3});
 			}
 
 	|	TOK_TABLE '(' { ++in_init; } opt_expr_list ')' { --in_init; }
@@ -563,20 +563,20 @@ expr:
 			{ // the ++in_init fixes up the parsing of "[x] = y"
 			set_location(@1, @5);
 			std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs{$7};
-			$$ = new TableConstructorExpr({AdoptRef{}, $4}, std::move(attrs));
+			$$ = new zeek::detail::TableConstructorExpr({AdoptRef{}, $4}, std::move(attrs));
 			}
 
 	|	TOK_SET '(' opt_expr_list ')' opt_attr
 			{
 			set_location(@1, @4);
 			std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs{$5};
-			$$ = new SetConstructorExpr({AdoptRef{}, $3}, std::move(attrs));
+			$$ = new zeek::detail::SetConstructorExpr({AdoptRef{}, $3}, std::move(attrs));
 			}
 
 	|	TOK_VECTOR '(' opt_expr_list ')'
 			{
 			set_location(@1, @4);
-			$$ = new VectorConstructorExpr({AdoptRef{}, $3});
+			$$ = new zeek::detail::VectorConstructorExpr({AdoptRef{}, $3});
 			}
 
 	|	expr '('
@@ -595,30 +595,30 @@ expr:
 			{
 			set_location(@1, @6);
 
-			if ( $1->Tag() == EXPR_NAME && $1->AsNameExpr()->Id()->IsType() )
+			if ( $1->Tag() == zeek::detail::EXPR_NAME && $1->AsNameExpr()->Id()->IsType() )
 				{
 				const auto& ctor_type = $1->AsNameExpr()->Id()->GetType();
 
 				switch ( ctor_type->Tag() ) {
 				case TYPE_RECORD:
 					{
-					auto rce = make_intrusive<RecordConstructorExpr>(
-					            IntrusivePtr<ListExpr>{AdoptRef{}, $4});
+					auto rce = make_intrusive<zeek::detail::RecordConstructorExpr>(
+						IntrusivePtr<zeek::detail::ListExpr>{AdoptRef{}, $4});
 					auto rt = cast_intrusive<RecordType>(ctor_type);
-					$$ = new RecordCoerceExpr(std::move(rce), std::move(rt));
+					$$ = new zeek::detail::RecordCoerceExpr(std::move(rce), std::move(rt));
 					}
 					break;
 
 				case TYPE_TABLE:
 					if ( ctor_type->IsTable() )
-						$$ = new TableConstructorExpr({AdoptRef{}, $4}, 0, ctor_type);
+						$$ = new zeek::detail::TableConstructorExpr({AdoptRef{}, $4}, 0, ctor_type);
 					else
-						$$ = new SetConstructorExpr({AdoptRef{}, $4}, 0, ctor_type);
+						$$ = new zeek::detail::SetConstructorExpr({AdoptRef{}, $4}, 0, ctor_type);
 
 					break;
 
 				case TYPE_VECTOR:
-					$$ = new VectorConstructorExpr({AdoptRef{}, $4}, ctor_type);
+					$$ = new zeek::detail::VectorConstructorExpr({AdoptRef{}, $4}, ctor_type);
 					break;
 
 				default:
@@ -628,14 +628,14 @@ expr:
 				}
 
 			else
-				$$ = new CallExpr({AdoptRef{}, $1}, {AdoptRef{}, $4}, in_hook > 0);
+				$$ = new zeek::detail::CallExpr({AdoptRef{}, $1}, {AdoptRef{}, $4}, in_hook > 0);
 			}
 
 	|	TOK_HOOK { ++in_hook; } expr
 			{
 			--in_hook;
 			set_location(@1, @3);
-			if ( $3->Tag() != EXPR_CALL )
+			if ( $3->Tag() != zeek::detail::EXPR_CALL )
 				$3->Error("not a valid hook call expression");
 			$$ = $3;
 			}
@@ -643,7 +643,7 @@ expr:
 	|	expr TOK_HAS_FIELD TOK_ID
 			{
 			set_location(@1, @3);
-			$$ = new HasFieldExpr({AdoptRef{}, $1}, $3);
+			$$ = new zeek::detail::HasFieldExpr({AdoptRef{}, $1}, $3);
 			}
 
 	|	anonymous_function
@@ -652,7 +652,7 @@ expr:
 	|	TOK_SCHEDULE expr '{' event '}'
 			{
 			set_location(@1, @5);
-			$$ = new ScheduleExpr({AdoptRef{}, $2}, {AdoptRef{}, $4});
+			$$ = new zeek::detail::ScheduleExpr({AdoptRef{}, $2}, {AdoptRef{}, $4});
 			}
 
 	|	TOK_ID
@@ -687,7 +687,7 @@ expr:
 					{
 					id->Error("undeclared variable");
 					id->SetType(error_type());
-					$$ = new NameExpr(std::move(id));
+					$$ = new zeek::detail::NameExpr(std::move(id));
 					}
 
 				else if ( id->IsEnumConst() )
@@ -697,11 +697,11 @@ expr:
 							       id->Name());
 					if ( intval < 0 )
 						reporter->InternalError("enum value not found for %s", id->Name());
-					$$ = new ConstExpr(t->GetVal(intval));
+					$$ = new zeek::detail::ConstExpr(t->GetVal(intval));
 					}
 				else
 					{
-					$$ = new NameExpr(std::move(id));
+					$$ = new zeek::detail::NameExpr(std::move(id));
 					}
 				}
 			}
@@ -709,7 +709,7 @@ expr:
 	|	TOK_CONSTANT
 			{
 			set_location(@1);
-			$$ = new ConstExpr({AdoptRef{}, $1});
+			$$ = new zeek::detail::ConstExpr({AdoptRef{}, $1});
 			}
 
 	|	'/' { begin_RE(); } TOK_PATTERN_TEXT TOK_PATTERN_END
@@ -723,30 +723,30 @@ expr:
 				re->MakeCaseInsensitive();
 
 			re->Compile();
-			$$ = new ConstExpr(make_intrusive<PatternVal>(re));
+			$$ = new zeek::detail::ConstExpr(make_intrusive<PatternVal>(re));
 			}
 
 	|       '|' expr '|'	%prec '('
 			{
 			set_location(@1, @3);
-			IntrusivePtr<Expr> e{AdoptRef{}, $2};
+			IntrusivePtr<zeek::detail::Expr> e{AdoptRef{}, $2};
 
 			if ( IsIntegral(e->GetType()->Tag()) )
-				e = make_intrusive<ArithCoerceExpr>(std::move(e), TYPE_INT);
+				e = make_intrusive<zeek::detail::ArithCoerceExpr>(std::move(e), TYPE_INT);
 
-			$$ = new SizeExpr(std::move(e));
+			$$ = new zeek::detail::SizeExpr(std::move(e));
 			}
 
 	|       expr TOK_AS type
 			{
 			set_location(@1, @3);
-			$$ = new CastExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::CastExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 
 	|       expr TOK_IS type
 			{
 			set_location(@1, @3);
-			$$ = new IsExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
+			$$ = new zeek::detail::IsExpr({AdoptRef{}, $1}, {AdoptRef{}, $3});
 			}
 	;
 
@@ -760,14 +760,14 @@ expr_list:
 	|	expr
 			{
 			set_location(@1);
-			$$ = new ListExpr({AdoptRef{}, $1});
+			$$ = new zeek::detail::ListExpr({AdoptRef{}, $1});
 			}
 	;
 
 opt_expr_list:
 		expr_list
 	|
-		{ $$ = new ListExpr(); }
+		{ $$ = new zeek::detail::ListExpr(); }
 	;
 
 enum_body:
@@ -1109,7 +1109,7 @@ decl:
 	|	TOK_REDEF global_id opt_type init_class opt_init opt_attr ';'
 			{
 			IntrusivePtr id{AdoptRef{}, $2};
-			IntrusivePtr<Expr> init{AdoptRef{}, $5};
+			IntrusivePtr<zeek::detail::Expr> init{AdoptRef{}, $5};
 			add_global(id, {AdoptRef{}, $3}, $4, init,
 			           std::unique_ptr<std::vector<IntrusivePtr<Attr>>>{$6},
 			           VAR_REDEF);
@@ -1262,7 +1262,7 @@ lambda_body:
 			auto ingredients = std::make_unique<function_ingredients>(IntrusivePtr{NewRef{}, current_scope()}, IntrusivePtr{AdoptRef{}, $3});
 			id_list outer_ids = gather_outer_ids(pop_scope().get(), ingredients->body.get());
 
-			$$ = new LambdaExpr(std::move(ingredients), std::move(outer_ids));
+			$$ = new zeek::detail::LambdaExpr(std::move(ingredients), std::move(outer_ids));
 			}
 	;
 
@@ -1321,19 +1321,19 @@ index_slice:
 			{
 			set_location(@1, @6);
 
-			auto low = $3 ? IntrusivePtr<Expr>{AdoptRef{}, $3} :
-			                make_intrusive<ConstExpr>(val_mgr->Count(0));
+			auto low = $3 ? IntrusivePtr<zeek::detail::Expr>{AdoptRef{}, $3} :
+			                make_intrusive<zeek::detail::ConstExpr>(val_mgr->Count(0));
 
-			auto high = $5 ? IntrusivePtr<Expr>{AdoptRef{}, $5} :
-			                 make_intrusive<SizeExpr>(
-			                     IntrusivePtr<Expr>{NewRef{}, $1});
+			auto high = $5 ? IntrusivePtr<zeek::detail::Expr>{AdoptRef{}, $5} :
+			                 make_intrusive<zeek::detail::SizeExpr>(
+			                     IntrusivePtr<zeek::detail::Expr>{NewRef{}, $1});
 
 			if ( ! IsIntegral(low->GetType()->Tag()) || ! IsIntegral(high->GetType()->Tag()) )
 				reporter->Error("slice notation must have integral values as indexes");
 
-			auto le = make_intrusive<ListExpr>(std::move(low));
+			auto le = make_intrusive<zeek::detail::ListExpr>(std::move(low));
 			le->Append(std::move(high));
-			$$ = new IndexExpr({AdoptRef{}, $1}, std::move(le), true);
+			$$ = new zeek::detail::IndexExpr({AdoptRef{}, $1}, std::move(le), true);
 			}
 
 opt_attr:
@@ -1388,7 +1388,7 @@ attr:
 	|	TOK_ATTR_DEPRECATED '=' TOK_CONSTANT
 			{
 			if ( IsString($3->GetType()->Tag()) )
-				$$ = new Attr(ATTR_DEPRECATED, make_intrusive<ConstExpr>(IntrusivePtr{AdoptRef{}, $3}));
+				$$ = new Attr(ATTR_DEPRECATED, make_intrusive<zeek::detail::ConstExpr>(IntrusivePtr{AdoptRef{}, $3}));
 			else
 				{
 				ODesc d;
@@ -1568,7 +1568,7 @@ stmt:
 	|	index_slice '=' expr ';' opt_no_test
 			{
 			set_location(@1, @4);
-			$$ = new zeek::detail::ExprStmt(get_assign_expr({AdoptRef{}, $1},
+			$$ = new zeek::detail::ExprStmt(zeek::detail::get_assign_expr({AdoptRef{}, $1},
 			                                  {AdoptRef{}, $3}, in_init));
 
 			if ( ! $5 )
@@ -1622,7 +1622,7 @@ event:
 					reporter->Warning("%s", id->GetDeprecationWarning().c_str());
 				}
 
-			$$ = new EventExpr($1, {AdoptRef{}, $3});
+			$$ = new zeek::detail::EventExpr($1, {AdoptRef{}, $3});
 			}
 	;
 
@@ -1878,19 +1878,19 @@ opt_no_test_block:
 
 opt_deprecated:
 		TOK_ATTR_DEPRECATED
-			{ $$ = new ConstExpr(make_intrusive<StringVal>("")); }
+			{ $$ = new zeek::detail::ConstExpr(make_intrusive<StringVal>("")); }
 	|
 		TOK_ATTR_DEPRECATED '=' TOK_CONSTANT
 			{
 			if ( IsString($3->GetType()->Tag()) )
-				$$ = new ConstExpr({AdoptRef{}, $3});
+				$$ = new zeek::detail::ConstExpr({AdoptRef{}, $3});
 			else
 				{
 				ODesc d;
 				$3->Describe(&d);
 				reporter->Error("'&deprecated=%s' must use a string literal",
 				                d.Description());
-				$$ = new ConstExpr(make_intrusive<StringVal>(""));
+				$$ = new zeek::detail::ConstExpr(make_intrusive<StringVal>(""));
 				}
 			}
 	|
diff --git a/src/scan.l b/src/scan.l
index f1c37f494e..961841daa2 100644
--- a/src/scan.l
+++ b/src/scan.l
@@ -37,6 +37,8 @@
 
 #include "plugin/Manager.h"
 
+using namespace zeek::detail;
+
 namespace {
 struct ZeekINode {
 	dev_t dev;
@@ -724,12 +726,12 @@ public:
 	LocalNameFinder()
 		{}
 
-	virtual TraversalCode PreExpr(const Expr* expr)
+	virtual TraversalCode PreExpr(const zeek::detail::Expr* expr)
 		{
 		if ( expr->Tag() != EXPR_NAME )
 			return TC_CONTINUE;
 
-		const NameExpr* name_expr = static_cast<const NameExpr*>(expr);
+		const zeek::detail::NameExpr* name_expr = static_cast<const zeek::detail::NameExpr*>(expr);
 
 		if ( name_expr->Id()->IsGlobal() )
 			return TC_CONTINUE;
@@ -738,10 +740,10 @@ public:
 		return TC_CONTINUE;
 		}
 
-	std::vector<const NameExpr*> local_names;
+	std::vector<const zeek::detail::NameExpr*> local_names;
 };
 
-void do_atif(Expr* expr)
+void do_atif(zeek::detail::Expr* expr)
 	{
 	++current_depth;
 
diff --git a/src/zeek.bif b/src/zeek.bif
index 1c81e87026..daef9f6c28 100644
--- a/src/zeek.bif
+++ b/src/zeek.bif
@@ -3479,7 +3479,7 @@ function dump_packet%(pkt: pcap_packet, file_name: string%) : bool
 
 class LookupHostCallback : public DNS_Mgr::LookupCallback {
 public:
-	LookupHostCallback(trigger::Trigger* arg_trigger, const CallExpr* arg_call,
+	LookupHostCallback(trigger::Trigger* arg_trigger, const zeek::detail::CallExpr* arg_call,
 				bool arg_lookup_name)
 		{
 		Ref(arg_trigger);
@@ -3532,7 +3532,7 @@ public:
 
 private:
 	trigger::Trigger* trigger;
-	const CallExpr* call;
+	const zeek::detail::CallExpr* call;
 	bool lookup_name;
 };
 %%}
diff --git a/src/zeekygen/IdentifierInfo.cc b/src/zeekygen/IdentifierInfo.cc
index 744aab928b..e31651f39e 100644
--- a/src/zeekygen/IdentifierInfo.cc
+++ b/src/zeekygen/IdentifierInfo.cc
@@ -32,7 +32,7 @@ IdentifierInfo::~IdentifierInfo()
 	}
 
 void IdentifierInfo::AddRedef(const string& script, init_class ic,
-                              IntrusivePtr<Expr> init_expr, const vector<string>& comments)
+                              IntrusivePtr<zeek::detail::Expr> init_expr, const vector<string>& comments)
 	{
 	Redefinition* redef = new Redefinition(script, ic, std::move(init_expr), comments);
 	redefs.push_back(redef);
@@ -142,7 +142,7 @@ time_t IdentifierInfo::DoGetModificationTime() const
 IdentifierInfo::Redefinition::Redefinition(
                        std::string arg_script,
                        init_class arg_ic,
-                       IntrusivePtr<Expr> arg_expr,
+                       IntrusivePtr<zeek::detail::Expr> arg_expr,
                        std::vector<std::string> arg_comments)
 			: from_script(std::move(arg_script)),
 			  ic(arg_ic),
diff --git a/src/zeekygen/IdentifierInfo.h b/src/zeekygen/IdentifierInfo.h
index a2292844d1..fc75b3af18 100644
--- a/src/zeekygen/IdentifierInfo.h
+++ b/src/zeekygen/IdentifierInfo.h
@@ -71,7 +71,7 @@ public:
 	 * @param comments Comments associated with the redef statement.
 	 */
 	void AddRedef(const std::string& from_script, init_class ic,
-	              IntrusivePtr<Expr> init_expr,
+	              IntrusivePtr<zeek::detail::Expr> init_expr,
 	              const std::vector<std::string>& comments);
 
 	/**
@@ -128,11 +128,11 @@ public:
 	struct Redefinition {
 		std::string from_script; /**< Name of script doing the redef. */
 		init_class ic;
-		IntrusivePtr<Expr> init_expr;
+		IntrusivePtr<zeek::detail::Expr> init_expr;
 		std::vector<std::string> comments; /**< Zeekygen comments on redef. */
 
 		Redefinition(std::string arg_script, init_class arg_ic,
-		             IntrusivePtr<Expr> arg_expr,
+		             IntrusivePtr<zeek::detail::Expr> arg_expr,
 		             std::vector<std::string> arg_comments);
 
 		~Redefinition();
diff --git a/src/zeekygen/Manager.cc b/src/zeekygen/Manager.cc
index 868b27e39b..b1a6892b48 100644
--- a/src/zeekygen/Manager.cc
+++ b/src/zeekygen/Manager.cc
@@ -54,7 +54,7 @@ static string RemoveLeadingSpace(const string& s)
 // use for indexing.
 static string NormalizeScriptPath(const string& path)
 	{
-	if ( auto p = plugin_mgr->LookupPluginByPath(path) ) 
+	if ( auto p = plugin_mgr->LookupPluginByPath(path) )
 		{
 		auto rval = normalize_path(path);
 		auto prefix = SafeBasename(p->PluginDirectory()).result;
@@ -361,7 +361,7 @@ void Manager::RecordField(const ID* id, const TypeDecl* field,
 	}
 
 void Manager::Redef(const ID* id, const string& path,
-                    init_class ic, IntrusivePtr<Expr> init_expr)
+	init_class ic, IntrusivePtr<zeek::detail::Expr> init_expr)
 	{
 	if ( disabled )
 		return;
diff --git a/src/zeekygen/Manager.h b/src/zeekygen/Manager.h
index 6edc9c1d17..e45784cf51 100644
--- a/src/zeekygen/Manager.h
+++ b/src/zeekygen/Manager.h
@@ -139,7 +139,7 @@ public:
 	 * @param init_expr The intiialization expression that was used.
 	 */
 	void Redef(const ID* id, const std::string& path,
-	           init_class ic, IntrusivePtr<Expr> init_expr);
+		init_class ic, IntrusivePtr<zeek::detail::Expr> init_expr);
 	void Redef(const ID* id, const std::string& path,
 	           init_class ic = INIT_NONE);