diff --git a/NEWS b/NEWS
index b0b0d49126..047d24b202 100644
--- a/NEWS
+++ b/NEWS
@@ -114,9 +114,9 @@ Deprecated Functionality
   method to now use is called ``HookFunctionCall`` and uses ``IntrusivePtr``
   arguments and return value.
 
-- The ``Func::Call(val_list*, ...)`` method is now deprecated.  Use operator()
+- The ``Func::Call(val_list*, ...)`` method is now deprecated.  Use ``Invoke()``
   instead which takes a ``zeek::Args`` (``std::vector<IntrusivePtr<Val>>``).
-  There's also a variadic template for operator() that forwards all arguments
+  There's also a variadic template for ``Invoke()`` that forwards all arguments
   into a ``zeek::Args`` for you.
 
 - The ``EventMgr::QueueEvent()`` and EventMgr::QueueEventFast()`` methods
@@ -151,7 +151,7 @@ Deprecated Functionality
 
 - Various methods of converting protocol structures, like IP or packet headers,
   to associated ``Val`` type are now deprecated, the deprecation warning
-  message will advice what new method to use instead.
+  message will advise what new method to use instead.
 
 - Various methods of ``Tag`` classes are deprecated with the warning
   message advising what new method to use instead.
diff --git a/src/Discard.cc b/src/Discard.cc
index c5563f1cd8..6625786e3b 100644
--- a/src/Discard.cc
+++ b/src/Discard.cc
@@ -43,7 +43,7 @@ bool Discarder::NextPacket(const IP_Hdr* ip, int len, int caplen)
 
 		try
 			{
-			discard_packet = check_ip->operator()(&args)->AsBool();
+			discard_packet = check_ip->Invoke(&args)->AsBool();
 			}
 
 		catch ( InterpreterException& e )
@@ -98,7 +98,7 @@ bool Discarder::NextPacket(const IP_Hdr* ip, int len, int caplen)
 
 			try
 				{
-				discard_packet = check_tcp->operator()(&args)->AsBool();
+				discard_packet = check_tcp->Invoke(&args)->AsBool();
 				}
 
 			catch ( InterpreterException& e )
@@ -122,7 +122,7 @@ bool Discarder::NextPacket(const IP_Hdr* ip, int len, int caplen)
 
 			try
 				{
-				discard_packet = check_udp->operator()(&args)->AsBool();
+				discard_packet = check_udp->Invoke(&args)->AsBool();
 				}
 
 			catch ( InterpreterException& e )
@@ -142,7 +142,7 @@ bool Discarder::NextPacket(const IP_Hdr* ip, int len, int caplen)
 
 			try
 				{
-				discard_packet = check_icmp->operator()(&args)->AsBool();
+				discard_packet = check_icmp->Invoke(&args)->AsBool();
 				}
 
 			catch ( InterpreterException& e )
diff --git a/src/EventHandler.cc b/src/EventHandler.cc
index 5e75fa6731..68673801d1 100644
--- a/src/EventHandler.cc
+++ b/src/EventHandler.cc
@@ -98,7 +98,7 @@ void EventHandler::Call(zeek::Args* vl, bool no_remote)
 
 	if ( local )
 		// No try/catch here; we pass exceptions upstream.
-		local->operator()(vl);
+		local->Invoke(vl);
 	}
 
 void EventHandler::NewEvent(zeek::Args* vl)
diff --git a/src/Expr.cc b/src/Expr.cc
index 3943786560..667b563373 100644
--- a/src/Expr.cc
+++ b/src/Expr.cc
@@ -4131,7 +4131,7 @@ IntrusivePtr<Val> CallExpr::Eval(Frame* f) const
 			f->SetCall(this);
 
 		auto& args = *v;
-		ret = funcv->operator()(&args, f);
+		ret = funcv->Invoke(&args, f);
 
 		if ( f )
 			f->SetCall(current_call);
diff --git a/src/Func.cc b/src/Func.cc
index e8a29612bb..f0cb8e693a 100644
--- a/src/Func.cc
+++ b/src/Func.cc
@@ -301,10 +301,10 @@ bool BroFunc::IsPure() const
 Val* Func::Call(val_list* args, Frame* parent) const
 	{
 	auto zargs = zeek::val_list_to_args(*args);
-	return operator()(&zargs, parent).release();
+	return Invoke(&zargs, parent).release();
 	};
 
-IntrusivePtr<Val> BroFunc::operator()(zeek::Args* args, Frame* parent) const
+IntrusivePtr<Val> BroFunc::Invoke(zeek::Args* args, Frame* parent) const
 	{
 #ifdef PROFILE_BRO_FUNCTIONS
 	DEBUG_MSG("Function: %s\n", Name());
@@ -614,7 +614,7 @@ bool BuiltinFunc::IsPure() const
 	return is_pure;
 	}
 
-IntrusivePtr<Val> BuiltinFunc::operator()(zeek::Args* args, Frame* parent) const
+IntrusivePtr<Val> BuiltinFunc::Invoke(zeek::Args* args, Frame* parent) const
 	{
 #ifdef PROFILE_BRO_FUNCTIONS
 	DEBUG_MSG("Function: %s\n", Name());
diff --git a/src/Func.h b/src/Func.h
index f861171980..5b2ee5eebc 100644
--- a/src/Func.h
+++ b/src/Func.h
@@ -51,7 +51,7 @@ public:
 	const std::vector<Body>& GetBodies() const	{ return bodies; }
 	bool HasBodies() const	{ return bodies.size(); }
 
-	[[deprecated("Remove in v4.1. Use operator() instead.")]]
+	[[deprecated("Remove in v4.1. Use Invoke() instead.")]]
 	Val* Call(val_list* args, Frame* parent = nullptr) const;
 
 	/**
@@ -60,21 +60,21 @@ public:
 	 * @param parent  the frame from which the function is being called.
 	 * @return  the return value of the function call.
 	 */
-	virtual IntrusivePtr<Val> operator()(zeek::Args* args,
-	                                     Frame* parent = nullptr) const = 0;
+	virtual IntrusivePtr<Val> Invoke(zeek::Args* args,
+	                                   Frame* parent = nullptr) const = 0;
 
 	/**
-	 * A version of operator() taking a variable number of individual arguments.
+	 * A version of Invoke() taking a variable number of individual arguments.
 	 */
 	template <class... Args>
 	std::enable_if_t<
 	  std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>,
 	                        IntrusivePtr<Val>>,
 	  IntrusivePtr<Val>>
-	operator()(Args&&... args) const
+	Invoke(Args&&... args) const
 		{
 		auto zargs = zeek::Args{std::forward<Args>(args)...};
-		return operator()(&zargs);
+		return Invoke(&zargs);
 		}
 
 	// Add a new event handler to an existing function (event).
@@ -136,7 +136,7 @@ public:
 	~BroFunc() override;
 
 	bool IsPure() const override;
-	IntrusivePtr<Val> operator()(zeek::Args* args, Frame* parent) const override;
+	IntrusivePtr<Val> Invoke(zeek::Args* args, Frame* parent) const override;
 
 	/**
 	 * Adds adds a closure to the function. Closures are cloned and
@@ -234,7 +234,7 @@ public:
 	~BuiltinFunc() override;
 
 	bool IsPure() const override;
-	IntrusivePtr<Val> operator()(zeek::Args* args, Frame* parent) const override;
+	IntrusivePtr<Val> Invoke(zeek::Args* args, Frame* parent) const override;
 	built_in_func TheFunc() const	{ return func; }
 
 	void Describe(ODesc* d) const override;
diff --git a/src/Hash.h b/src/Hash.h
index bff33c2b9f..9e39909d58 100644
--- a/src/Hash.h
+++ b/src/Hash.h
@@ -30,9 +30,9 @@ class BroString;
 class Val;
 class Frame;
 class BifReturnVal;
-namespace zeek { namespace BifFunc {
+namespace zeek::BifFunc {
 	extern BifReturnVal md5_hmac_bif(Frame* frame, const zeek::Args*);
-}}
+}
 
 typedef uint64_t hash_t;
 typedef uint64_t hash64_t;
diff --git a/src/ID.h b/src/ID.h
index 4c7839bed9..5c0c5e84b7 100644
--- a/src/ID.h
+++ b/src/ID.h
@@ -164,7 +164,7 @@ protected:
 
 };
 
-namespace zeek { namespace id {
+namespace zeek::id {
 
 /**
  * Lookup an ID in the global module and return it, if one exists;
@@ -254,4 +254,4 @@ void init();
 
 } // namespace zeek::id::detail
 
-}} // namespace zeek::id
+} // namespace zeek::id
diff --git a/src/RuleCondition.cc b/src/RuleCondition.cc
index c66d3a3b3f..732c74b4ac 100644
--- a/src/RuleCondition.cc
+++ b/src/RuleCondition.cc
@@ -181,7 +181,7 @@ bool RuleConditionEval::DoMatch(Rule* rule, RuleEndpointState* state,
 
 	try
 		{
-		auto val = id->GetVal()->AsFunc()->operator()(&args);
+		auto val = id->GetVal()->AsFunc()->Invoke(&args);
 		result = val && val->AsBool();
 		}
 
diff --git a/src/Val.cc b/src/Val.cc
index 0d45446315..a2c062d3b2 100644
--- a/src/Val.cc
+++ b/src/Val.cc
@@ -1879,7 +1879,7 @@ IntrusivePtr<Val> TableVal::Default(const IntrusivePtr<Val>& index)
 
 	try
 		{
-		result = f->operator()(&vl);
+		result = f->Invoke(&vl);
 		}
 
 	catch ( InterpreterException& e )
@@ -2088,7 +2088,7 @@ void TableVal::CallChangeFunc(const Val* index,
 			vl.emplace_back(old_value);
 
 		in_change_func = true;
-		f->operator()(&vl);
+		f->Invoke(&vl);
 		}
 	catch ( InterpreterException& e )
 		{
@@ -2546,7 +2546,7 @@ double TableVal::CallExpireFunc(IntrusivePtr<ListVal> idx)
 				vl.emplace_back(std::move(idx));
 			}
 
-		auto result = f->operator()(&vl);
+		auto result = f->Invoke(&vl);
 
 		if ( result )
 			secs = result->AsInterval();
diff --git a/src/analyzer/protocol/arp/ARP.cc b/src/analyzer/protocol/arp/ARP.cc
index ec5906bdde..4d8b83b8b8 100644
--- a/src/analyzer/protocol/arp/ARP.cc
+++ b/src/analyzer/protocol/arp/ARP.cc
@@ -192,10 +192,10 @@ void ARP_Analyzer::BadARP(const struct arp_pkthdr* hdr, const char* msg)
 		return;
 
 	mgr.Enqueue(bad_arp,
-		ConstructAddrVal(ar_spa(hdr)),
-		EthAddrToStr((const u_char*) ar_sha(hdr)),
-		ConstructAddrVal(ar_tpa(hdr)),
-		EthAddrToStr((const u_char*) ar_tha(hdr)),
+		ToAddrVal(ar_spa(hdr)),
+		ToEthAddrStr((const u_char*) ar_sha(hdr)),
+		ToAddrVal(ar_tpa(hdr)),
+		ToEthAddrStr((const u_char*) ar_tha(hdr)),
 		make_intrusive<StringVal>(msg)
 	);
 	}
@@ -214,22 +214,28 @@ void ARP_Analyzer::RREvent(EventHandlerPtr e,
 		return;
 
 	mgr.Enqueue(e,
-		EthAddrToStr(src),
-		EthAddrToStr(dst),
-		ConstructAddrVal(spa),
-		EthAddrToStr((const u_char*) sha),
-		ConstructAddrVal(tpa),
-		EthAddrToStr((const u_char*) tha)
+		ToEthAddrStr(src),
+		ToEthAddrStr(dst),
+		ToAddrVal(spa),
+		ToEthAddrStr((const u_char*) sha),
+		ToAddrVal(tpa),
+		ToEthAddrStr((const u_char*) tha)
 	);
 	}
 
-IntrusivePtr<AddrVal> ARP_Analyzer::ConstructAddrVal(const void* addr)
+AddrVal* ARP_Analyzer::ConstructAddrVal(const void* addr)
+	{ return ToAddrVal(addr).release(); }
+
+IntrusivePtr<AddrVal> ARP_Analyzer::ToAddrVal(const void* addr)
 	{
 	// ### For now, we only handle IPv4 addresses.
 	return make_intrusive<AddrVal>(*(const uint32_t*) addr);
 	}
 
-IntrusivePtr<StringVal> ARP_Analyzer::EthAddrToStr(const u_char* addr)
+StringVal* ARP_Analyzer::EthAddrToStr(const u_char* addr)
+	{ return ToEthAddrStr(addr).release(); }
+
+IntrusivePtr<StringVal> ARP_Analyzer::ToEthAddrStr(const u_char* addr)
 	{
 	char buf[1024];
 	snprintf(buf, sizeof(buf), "%02x:%02x:%02x:%02x:%02x:%02x",
diff --git a/src/analyzer/protocol/arp/ARP.h b/src/analyzer/protocol/arp/ARP.h
index 62e1fbd8bb..d1de7de01f 100644
--- a/src/analyzer/protocol/arp/ARP.h
+++ b/src/analyzer/protocol/arp/ARP.h
@@ -45,8 +45,14 @@ public:
 			const char* tpa, const char* tha);
 
 protected:
-	IntrusivePtr<AddrVal> ConstructAddrVal(const void* addr);
-	IntrusivePtr<StringVal> EthAddrToStr(const u_char* addr);
+
+	[[deprecated("Remove in v4.1.  Use ToAddrVal().")]]
+	AddrVal* ConstructAddrVal(const void* addr);
+	[[deprecated("Remove in v4.1.  Use ToEthAddrStr().")]]
+	StringVal* EthAddrToStr(const u_char* addr);
+
+	IntrusivePtr<AddrVal> ToAddrVal(const void* addr);
+	IntrusivePtr<StringVal> ToEthAddrStr(const u_char* addr);
 	void BadARP(const struct arp_pkthdr* hdr, const char* string);
 	void Corrupted(const char* string);
 };
diff --git a/src/analyzer/protocol/http/HTTP.cc b/src/analyzer/protocol/http/HTTP.cc
index e2cc88b465..c8f2689dca 100644
--- a/src/analyzer/protocol/http/HTTP.cc
+++ b/src/analyzer/protocol/http/HTTP.cc
@@ -738,15 +738,15 @@ void HTTP_Message::SubmitAllHeaders(mime::MIME_HeaderList& hlist)
 		analyzer->EnqueueConnEvent(http_all_headers,
 			analyzer->ConnVal(),
 			val_mgr->Bool(is_orig),
-			BuildHeaderTable(hlist)
+			ToHeaderTable(hlist)
 		);
 
 	if ( http_content_type )
 		analyzer->EnqueueConnEvent(http_content_type,
 			analyzer->ConnVal(),
 			val_mgr->Bool(is_orig),
-			current_entity->ContentType(),
-			current_entity->ContentSubType()
+			current_entity->GetContentType(),
+			current_entity->GetContentSubType()
 		);
 	}
 
@@ -928,7 +928,7 @@ void HTTP_Analyzer::DeliverStream(int len, const u_char* data, bool is_orig)
 		return;
 		}
 
-	// HTTP_Event("HTTP line", new_string_val(length, line));
+	// HTTP_Event("HTTP line", to_string_val(length, line));
 
 	if ( is_orig )
 		{
@@ -961,7 +961,7 @@ void HTTP_Analyzer::DeliverStream(int len, const u_char* data, bool is_orig)
 				{
 				if ( ! RequestExpected() )
 					HTTP_Event("crud_trailing_HTTP_request",
-						   mime::new_string_val(line, end_of_line));
+						   mime::to_string_val(line, end_of_line));
 				else
 					{
 					// We do see HTTP requests with a
@@ -1304,10 +1304,10 @@ bool HTTP_Analyzer::ParseRequest(const char* line, const char* end_of_line)
 			version_end = version_start + 3;
 			if ( skip_whitespace(version_end, end_of_line) != end_of_line )
 				HTTP_Event("crud after HTTP version is ignored",
-					   mime::new_string_val(line, end_of_line));
+					   mime::to_string_val(line, end_of_line));
 			}
 		else
-			HTTP_Event("bad_HTTP_version", mime::new_string_val(line, end_of_line));
+			HTTP_Event("bad_HTTP_version", mime::to_string_val(line, end_of_line));
 		}
 
 	// NormalizeURI(line, end_of_uri);
@@ -1333,7 +1333,7 @@ HTTP_Analyzer::HTTP_VersionNumber HTTP_Analyzer::HTTP_Version(int len, const cha
 		}
 	else
 		{
-		HTTP_Event("bad_HTTP_version", mime::new_string_val(len, data));
+		HTTP_Event("bad_HTTP_version", mime::to_string_val(len, data));
 		return {};
 		}
 	}
@@ -1509,7 +1509,7 @@ int HTTP_Analyzer::HTTP_ReplyLine(const char* line, const char* end_of_line)
 		// ##TODO: some server replies with an HTML document
 		// without a status line and a MIME header, when the
 		// request is malformed.
-		HTTP_Event("bad_HTTP_reply", mime::new_string_val(line, end_of_line));
+		HTTP_Event("bad_HTTP_reply", mime::to_string_val(line, end_of_line));
 		return 0;
 		}
 
@@ -1522,7 +1522,7 @@ int HTTP_Analyzer::HTTP_ReplyLine(const char* line, const char* end_of_line)
 	if ( rest >= end_of_line )
 		{
 		HTTP_Event("HTTP_reply_code_missing",
-				mime::new_string_val(line, end_of_line));
+				mime::to_string_val(line, end_of_line));
 		return 0;
 		}
 
@@ -1531,7 +1531,7 @@ int HTTP_Analyzer::HTTP_ReplyLine(const char* line, const char* end_of_line)
 	if ( rest + 3 > end_of_line )
 		{
 		HTTP_Event("HTTP_reply_code_missing",
-			mime::new_string_val(line, end_of_line));
+			mime::to_string_val(line, end_of_line));
 		return 0;
 		}
 
@@ -1544,7 +1544,7 @@ int HTTP_Analyzer::HTTP_ReplyLine(const char* line, const char* end_of_line)
 	if ( rest >= end_of_line )
 		{
 		HTTP_Event("HTTP_reply_reason_phrase_missing",
-			mime::new_string_val(line, end_of_line));
+			mime::to_string_val(line, end_of_line));
 		// Tolerate missing reason phrase?
 		return 1;
 		}
@@ -1635,15 +1635,15 @@ void HTTP_Analyzer::HTTP_Header(bool is_orig, mime::MIME_Header* h)
 		if ( DEBUG_http )
 			DEBUG_MSG("%.6f http_header\n", network_time);
 
-		auto upper_hn = mime::new_string_val(h->get_name());
+		auto upper_hn = mime::to_string_val(h->get_name());
 		upper_hn->ToUpper();
 
 		EnqueueConnEvent(http_header,
 			ConnVal(),
 			val_mgr->Bool(is_orig),
-			mime::new_string_val(h->get_name()),
+			mime::to_string_val(h->get_name()),
 			std::move(upper_hn),
-			mime::new_string_val(h->get_value())
+			mime::to_string_val(h->get_value())
 		);
 		}
 	}
diff --git a/src/analyzer/protocol/mime/MIME.cc b/src/analyzer/protocol/mime/MIME.cc
index 81222adf97..dbe81f41a9 100644
--- a/src/analyzer/protocol/mime/MIME.cc
+++ b/src/analyzer/protocol/mime/MIME.cc
@@ -108,19 +108,28 @@ bool is_lws(char ch)
 	return ch == 9 || ch == 32;
 	}
 
-IntrusivePtr<StringVal> new_string_val(int length, const char* data)
+StringVal* new_string_val(int length, const char* data)
+	{ return to_string_val(length, data).release(); }
+
+StringVal* new_string_val(const char* data, const char* end_of_data)
+	{ return to_string_val(data, end_of_data).release(); }
+
+StringVal* new_string_val(const data_chunk_t buf)
+	{ return to_string_val(buf).release(); }
+
+IntrusivePtr<StringVal> to_string_val(int length, const char* data)
 	{
 	return make_intrusive<StringVal>(length, data);
 	}
 
-IntrusivePtr<StringVal> new_string_val(const char* data, const char* end_of_data)
+IntrusivePtr<StringVal> to_string_val(const char* data, const char* end_of_data)
 	{
 	return make_intrusive<StringVal>(end_of_data - data, data);
 	}
 
-IntrusivePtr<StringVal> new_string_val(const data_chunk_t buf)
+IntrusivePtr<StringVal> to_string_val(const data_chunk_t buf)
 	{
-	return new_string_val(buf.length, buf.data);
+	return to_string_val(buf.length, buf.data);
 	}
 
 static data_chunk_t get_data_chunk(BroString* s)
@@ -1287,19 +1296,25 @@ void MIME_Entity::DebugPrintHeaders()
 #endif
 	}
 
-IntrusivePtr<RecordVal> MIME_Message::BuildHeaderVal(MIME_Header* h)
+RecordVal* MIME_Message::BuildHeaderVal(MIME_Header* h)
+	{ return ToHeaderVal(h).release(); }
+
+IntrusivePtr<RecordVal> MIME_Message::ToHeaderVal(MIME_Header* h)
 	{
 	static auto mime_header_rec = zeek::id::find_type<RecordType>("mime_header_rec");
 	auto header_record = make_intrusive<RecordVal>(mime_header_rec);
-	header_record->Assign(0, new_string_val(h->get_name()));
-	auto upper_hn = new_string_val(h->get_name());
+	header_record->Assign(0, to_string_val(h->get_name()));
+	auto upper_hn = to_string_val(h->get_name());
 	upper_hn->ToUpper();
 	header_record->Assign(1, std::move(upper_hn));
-	header_record->Assign(2, new_string_val(h->get_value()));
+	header_record->Assign(2, to_string_val(h->get_value()));
 	return header_record;
 	}
 
-IntrusivePtr<TableVal> MIME_Message::BuildHeaderTable(MIME_HeaderList& hlist)
+TableVal* MIME_Message::BuildHeaderTable(MIME_HeaderList& hlist)
+	{ return ToHeaderTable(hlist).release(); }
+
+IntrusivePtr<TableVal> MIME_Message::ToHeaderTable(MIME_HeaderList& hlist)
 	{
 	static auto mime_header_list = zeek::id::find_type<TableType>("mime_header_list");
 	auto t = make_intrusive<TableVal>(mime_header_list);
@@ -1308,7 +1323,7 @@ IntrusivePtr<TableVal> MIME_Message::BuildHeaderTable(MIME_HeaderList& hlist)
 		{
 		auto index = val_mgr->Count(i + 1);	// index starting from 1
 		MIME_Header* h = hlist[i];
-		t->Assign(std::move(index), BuildHeaderVal(h));
+		t->Assign(std::move(index), ToHeaderVal(h));
 		}
 
 	return t;
@@ -1427,7 +1442,7 @@ void MIME_Mail::SubmitHeader(MIME_Header* h)
 	if ( mime_one_header )
 		analyzer->EnqueueConnEvent(mime_one_header,
 			analyzer->ConnVal(),
-			BuildHeaderVal(h)
+			ToHeaderVal(h)
 		);
 	}
 
@@ -1436,7 +1451,7 @@ void MIME_Mail::SubmitAllHeaders(MIME_HeaderList& hlist)
 	if ( mime_all_headers )
 		analyzer->EnqueueConnEvent(mime_all_headers,
 			analyzer->ConnVal(),
-			BuildHeaderTable(hlist)
+			ToHeaderTable(hlist)
 		);
 	}
 
diff --git a/src/analyzer/protocol/mime/MIME.h b/src/analyzer/protocol/mime/MIME.h
index f897b094a7..50fdb8366b 100644
--- a/src/analyzer/protocol/mime/MIME.h
+++ b/src/analyzer/protocol/mime/MIME.h
@@ -97,8 +97,12 @@ public:
 
 	MIME_Entity* Parent() const { return parent; }
 	int MIMEContentType() const { return content_type; }
-	const IntrusivePtr<StringVal>& ContentType() const { return content_type_str; }
-	const IntrusivePtr<StringVal>& ContentSubType() const { return content_subtype_str; }
+	[[deprecated("Remove in v4.1.  Use GetContentType().")]]
+	StringVal* ContentType() const { return content_type_str.get(); }
+	[[deprecated("Remove in v4.1.  Use GetContentSubType().")]]
+	StringVal* ContentSubType() const { return content_subtype_str.get(); }
+	const IntrusivePtr<StringVal>& GetContentType() const { return content_type_str; }
+	const IntrusivePtr<StringVal>& GetContentSubType() const { return content_subtype_str; }
 	int ContentTransferEncoding() const { return content_encoding; }
 
 protected:
@@ -225,8 +229,13 @@ protected:
 	MIME_Entity* top_level;
 	bool finished;
 
-	IntrusivePtr<RecordVal> BuildHeaderVal(MIME_Header* h);
-	IntrusivePtr<TableVal> BuildHeaderTable(MIME_HeaderList& hlist);
+	[[deprecated("Remove in v4.1.  Use ToHeaderVal().")]]
+	RecordVal* BuildHeaderVal(MIME_Header* h);
+	[[deprecated("Remove in v4.1.  Use ToHeaderTable().")]]
+	TableVal* BuildHeaderTable(MIME_HeaderList& hlist);
+
+	IntrusivePtr<RecordVal> ToHeaderVal(MIME_Header* h);
+	IntrusivePtr<TableVal> ToHeaderTable(MIME_HeaderList& hlist);
 };
 
 class MIME_Mail final : public MIME_Message {
@@ -265,9 +274,15 @@ protected:
 
 
 extern bool is_null_data_chunk(data_chunk_t b);
-extern IntrusivePtr<StringVal> new_string_val(int length, const char* data);
-extern IntrusivePtr<StringVal> new_string_val(const char* data, const char* end_of_data);
-extern IntrusivePtr<StringVal> new_string_val(const data_chunk_t buf);
+[[deprecated("Remove in v4.1.  Use analyzer::mime::to_string_val().")]]
+extern StringVal* new_string_val(int length, const char* data);
+[[deprecated("Remove in v4.1.  Use analyzer::mime::to_string_val().")]]
+extern StringVal* new_string_val(const char* data, const char* end_of_data);
+[[deprecated("Remove in v4.1.  Use analyzer::mime::to_string_val().")]]
+extern StringVal* new_string_val(const data_chunk_t buf);
+extern IntrusivePtr<StringVal> to_string_val(int length, const char* data);
+extern IntrusivePtr<StringVal> to_string_val(const char* data, const char* end_of_data);
+extern IntrusivePtr<StringVal> to_string_val(const data_chunk_t buf);
 extern int fputs(data_chunk_t b, FILE* fp);
 extern bool istrequal(data_chunk_t s, const char* t);
 extern bool is_lws(char ch);
diff --git a/src/broker/Manager.cc b/src/broker/Manager.cc
index 98f9651d41..469cc997f0 100644
--- a/src/broker/Manager.cc
+++ b/src/broker/Manager.cc
@@ -552,8 +552,8 @@ bool Manager::PublishLogWrite(EnumVal* stream, EnumVal* writer, string path, int
 	std::string serial_data(data, len);
 	free(data);
 
-	auto v = log_topic_func->operator()(IntrusivePtr{NewRef{}, stream},
-	                                    make_intrusive<StringVal>(path));
+	auto v = log_topic_func->Invoke(IntrusivePtr{NewRef{}, stream},
+	                                make_intrusive<StringVal>(path));
 
 	if ( ! v )
 		{
diff --git a/src/broker/messaging.bif b/src/broker/messaging.bif
index 14d6c43219..b88320bcd2 100644
--- a/src/broker/messaging.bif
+++ b/src/broker/messaging.bif
@@ -188,7 +188,7 @@ function Cluster::publish_rr%(pool: Pool, key: string, ...%): bool
 		topic_func = global_scope()->Find("Cluster::rr_topic")->GetVal()->AsFunc();
 
 	zeek::Args vl{{NewRef{}, pool}, {NewRef{}, key}};
-	auto topic = topic_func->operator()(&vl);
+	auto topic = topic_func->Invoke(&vl);
 
 	if ( ! topic->AsString()->Len() )
 		return val_mgr->False();
@@ -225,7 +225,7 @@ function Cluster::publish_hrw%(pool: Pool, key: any, ...%): bool
 		topic_func = global_scope()->Find("Cluster::hrw_topic")->GetVal()->AsFunc();
 
 	zeek::Args vl{{NewRef{}, pool}, {NewRef{}, key}};
-	auto topic = topic_func->operator()(&vl);
+	auto topic = topic_func->Invoke(&vl);
 
 	if ( ! topic->AsString()->Len() )
 		return val_mgr->False();
diff --git a/src/file_analysis/analyzer/x509/X509.cc b/src/file_analysis/analyzer/x509/X509.cc
index 8ad24921ef..016a265d8f 100644
--- a/src/file_analysis/analyzer/x509/X509.cc
+++ b/src/file_analysis/analyzer/x509/X509.cc
@@ -62,8 +62,8 @@ bool file_analysis::X509::EndOfFile()
 				return false;
 			// yup, let's call the callback.
 
-			cache_hit_callback->operator()(GetFile()->ToVal(), entry,
-			                               make_intrusive<StringVal>(cert_sha256));
+			cache_hit_callback->Invoke(GetFile()->ToVal(), entry,
+			                           make_intrusive<StringVal>(cert_sha256));
 			return false;
 			}
 		}
diff --git a/src/input/Manager.cc b/src/input/Manager.cc
index f98c60684c..4914fc6fe4 100644
--- a/src/input/Manager.cc
+++ b/src/input/Manager.cc
@@ -480,11 +480,11 @@ bool Manager::CreateTableStream(RecordVal* fval)
 	auto dst = fval->GetFieldOrDefault("destination");
 
 	// check if index fields match table description
-	int num = idx->NumFields();
+	size_t num = idx->NumFields();
 	const auto& tl = dst->GetType()->AsTableType()->IndexTypes();
-	int j;
+	size_t j;
 
-	for ( j = 0; j < static_cast<int>(tl.size()); ++j )
+	for ( j = 0; j < tl.size(); ++j )
 		{
 		if ( j >= num )
 			{
@@ -1768,7 +1768,7 @@ bool Manager::CallPred(Func* pred_func, const int numvals, ...) const
 
 	va_end(lP);
 
-	auto v = pred_func->operator()(&vl);
+	auto v = pred_func->Invoke(&vl);
 
 	if ( v )
 		result = v->AsBool();
diff --git a/src/logging/Manager.cc b/src/logging/Manager.cc
index 7fc6cab918..8ab3ba9f51 100644
--- a/src/logging/Manager.cc
+++ b/src/logging/Manager.cc
@@ -717,7 +717,7 @@ bool Manager::Write(EnumVal* id, RecordVal* columns_arg)
 			// See whether the predicates indicates that we want
 			// to log this record.
 			int result = 1;
-			auto v = filter->pred->operator()(columns);
+			auto v = filter->pred->Invoke(columns);
 
 			if ( v )
 				result = v->AsBool();
@@ -744,9 +744,9 @@ bool Manager::Write(EnumVal* id, RecordVal* columns_arg)
 				// Can be TYPE_ANY here.
 				rec_arg = columns;
 
-			auto v = filter->path_func->operator()(IntrusivePtr{NewRef{}, id},
-			                                       std::move(path_arg),
-			                                       std::move(rec_arg));
+			auto v = filter->path_func->Invoke(IntrusivePtr{NewRef{}, id},
+			                                   std::move(path_arg),
+			                                   std::move(rec_arg));
 
 			if ( ! v )
 				return false;
@@ -1050,7 +1050,7 @@ threading::Value** Manager::RecordToFilterVals(Stream* stream, Filter* filter,
 
 	if ( filter->num_ext_fields > 0 )
 		{
-		auto res = filter->ext_func->operator()(IntrusivePtr{NewRef{}, filter->path_val});
+		auto res = filter->ext_func->Invoke(IntrusivePtr{NewRef{}, filter->path_val});
 
 		if ( res )
 			ext_rec = {AdoptRef{}, res.release()->AsRecordVal()};
@@ -1527,7 +1527,7 @@ bool Manager::FinishedRotation(WriterFrontend* writer, const char* new_name, con
 	// Call the postprocessor function.
 	int result = 0;
 
-	auto v = func->operator()(std::move(info));
+	auto v = func->Invoke(std::move(info));
 	if ( v )
 		result = v->AsBool();
 
diff --git a/src/option.bif b/src/option.bif
index 91d5509c3c..f2024062c4 100644
--- a/src/option.bif
+++ b/src/option.bif
@@ -24,7 +24,7 @@ static bool call_option_handlers_and_set_value(StringVal* name, const IntrusiveP
 			if ( add_loc )
 				vl.emplace_back(NewRef{}, location);
 
-			val = handler_function->operator()(&vl); // consumed by next call.
+			val = handler_function->Invoke(&vl); // consumed by next call.
 
 			if ( ! val )
 				{
diff --git a/src/zeek.bif b/src/zeek.bif
index 8079ed8af9..fceaa3ac5f 100644
--- a/src/zeek.bif
+++ b/src/zeek.bif
@@ -1338,7 +1338,7 @@ bool sort_function(const IntrusivePtr<Val>& a, const IntrusivePtr<Val>& b)
 	if ( ! b )
 		return 1;
 
-	auto result = sort_function_comp->operator()(a, b);
+	auto result = sort_function_comp->Invoke(a, b);
 	int int_result = result->CoerceToInt();
 
 	return int_result < 0;
@@ -1516,7 +1516,7 @@ function order%(v: any, ...%) : index_vec
 
 	if ( comp )
 		{
-		const auto& comp_type = comp->GetType()->AsFuncType();
+		const auto& comp_type = comp->GetType();
 		if ( comp_type->Yield()->Tag() != TYPE_INT ||
 		     ! comp_type->ParamList()->AllMatch(elt_type, 0) )
 			{