diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 7a2dcfedf7..b4d4951ff4 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -200,7 +200,7 @@ install(FILES ${PRELOAD_SCRIPT} DESTINATION ${ZEEK_SCRIPT_INSTALL_PATH}/builtin-
 install(FILES ${LOAD_SCRIPT} DESTINATION ${ZEEK_SCRIPT_INSTALL_PATH}/builtin-plugins/)
 
 ########################################################################
-## bro target
+## zeek target
 
 find_package (Threads)
 
@@ -234,7 +234,7 @@ endmacro(COLLECT_HEADERS _var)
 cmake_policy(POP)
 
 # define a command that's used to run the make_dbg_constants.py script
-# building the bro binary depends on the outputs of this script
+# building the zeek binary depends on the outputs of this script
 add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/DebugCmdConstants.h
                           ${CMAKE_CURRENT_BINARY_DIR}/DebugCmdInfoConstants.cc
                    COMMAND ${PYTHON_EXECUTABLE}
diff --git a/src/Expr.cc b/src/Expr.cc
index 31679edf49..e7ff145042 100644
--- a/src/Expr.cc
+++ b/src/Expr.cc
@@ -83,103 +83,103 @@ Expr::Expr(BroExprTag arg_tag) : tag(arg_tag), paren(false), type(nullptr)
 
 const ListExpr* Expr::AsListExpr() const
 	{
-	CHECK_TAG(tag, EXPR_LIST, "ExprVal::AsListExpr", expr_name)
+	CHECK_TAG(tag, EXPR_LIST, "Expr::AsListExpr", expr_name)
 	return (const ListExpr*) this;
 	}
 
 ListExpr* Expr::AsListExpr()
 	{
-	CHECK_TAG(tag, EXPR_LIST, "ExprVal::AsListExpr", expr_name)
+	CHECK_TAG(tag, EXPR_LIST, "Expr::AsListExpr", expr_name)
 	return (ListExpr*) this;
 	}
 
 ListExprPtr Expr::AsListExprPtr()
 	{
-	CHECK_TAG(tag, EXPR_LIST, "ExprVal::AsListExpr", expr_name)
+	CHECK_TAG(tag, EXPR_LIST, "Expr::AsListExpr", expr_name)
 	return {NewRef{}, (ListExpr*) this};
 	}
 
 const NameExpr* Expr::AsNameExpr() const
 	{
-	CHECK_TAG(tag, EXPR_NAME, "ExprVal::AsNameExpr", expr_name)
+	CHECK_TAG(tag, EXPR_NAME, "Expr::AsNameExpr", expr_name)
 	return (const NameExpr*) this;
 	}
 
 NameExpr* Expr::AsNameExpr()
 	{
-	CHECK_TAG(tag, EXPR_NAME, "ExprVal::AsNameExpr", expr_name)
+	CHECK_TAG(tag, EXPR_NAME, "Expr::AsNameExpr", expr_name)
 	return (NameExpr*) this;
 	}
 
 NameExprPtr Expr::AsNameExprPtr()
 	{
-	CHECK_TAG(tag, EXPR_NAME, "ExprVal::AsNameExpr", expr_name)
+	CHECK_TAG(tag, EXPR_NAME, "Expr::AsNameExpr", expr_name)
 	return {NewRef{}, (NameExpr*) this};
 	}
 
 const ConstExpr* Expr::AsConstExpr() const
 	{
-	CHECK_TAG(tag, EXPR_CONST, "ExprVal::AsConstExpr", expr_name)
+	CHECK_TAG(tag, EXPR_CONST, "Expr::AsConstExpr", expr_name)
 	return (const ConstExpr*) this;
 	}
 
 ConstExprPtr Expr::AsConstExprPtr()
 	{
-	CHECK_TAG(tag, EXPR_CONST, "ExprVal::AsConstExpr", expr_name)
+	CHECK_TAG(tag, EXPR_CONST, "Expr::AsConstExpr", expr_name)
 	return {NewRef{}, (ConstExpr*) this};
 	}
 
 const CallExpr* Expr::AsCallExpr() const
 	{
-	CHECK_TAG(tag, EXPR_CALL, "ExprVal::AsCallExpr", expr_name)
+	CHECK_TAG(tag, EXPR_CALL, "Expr::AsCallExpr", expr_name)
 	return (const CallExpr*) this;
 	}
 
 const AssignExpr* Expr::AsAssignExpr() const
 	{
-	CHECK_TAG(tag, EXPR_ASSIGN, "ExprVal::AsAssignExpr", expr_name)
+	CHECK_TAG(tag, EXPR_ASSIGN, "Expr::AsAssignExpr", expr_name)
 	return (const AssignExpr*) this;
 	}
 
 AssignExpr* Expr::AsAssignExpr()
 	{
-	CHECK_TAG(tag, EXPR_ASSIGN, "ExprVal::AsAssignExpr", expr_name)
+	CHECK_TAG(tag, EXPR_ASSIGN, "Expr::AsAssignExpr", expr_name)
 	return (AssignExpr*) this;
 	}
 
 const IndexExpr* Expr::AsIndexExpr() const
 	{
-	CHECK_TAG(tag, EXPR_INDEX, "ExprVal::AsIndexExpr", expr_name)
+	CHECK_TAG(tag, EXPR_INDEX, "Expr::AsIndexExpr", expr_name)
 	return (const IndexExpr*) this;
 	}
 
 IndexExpr* Expr::AsIndexExpr()
 	{
-	CHECK_TAG(tag, EXPR_INDEX, "ExprVal::AsIndexExpr", expr_name)
+	CHECK_TAG(tag, EXPR_INDEX, "Expr::AsIndexExpr", expr_name)
 	return (IndexExpr*) this;
 	}
 
 const EventExpr* Expr::AsEventExpr() const
 	{
-	CHECK_TAG(tag, EXPR_EVENT, "ExprVal::AsEventExpr", expr_name)
+	CHECK_TAG(tag, EXPR_EVENT, "Expr::AsEventExpr", expr_name)
 	return (const EventExpr*) this;
 	}
 
 EventExprPtr Expr::AsEventExprPtr()
 	{
-	CHECK_TAG(tag, EXPR_EVENT, "ExprVal::AsEventExpr", expr_name)
+	CHECK_TAG(tag, EXPR_EVENT, "Expr::AsEventExpr", expr_name)
 	return {NewRef{}, (EventExpr*) this};
 	}
 
 const RefExpr* Expr::AsRefExpr() const
 	{
-	CHECK_TAG(tag, EXPR_REF, "ExprVal::AsRefExpr", expr_name)
+	CHECK_TAG(tag, EXPR_REF, "Expr::AsRefExpr", expr_name)
 	return (const RefExpr*) this;
 	}
 
 RefExprPtr Expr::AsRefExprPtr()
 	{
-	CHECK_TAG(tag, EXPR_REF, "ExprVal::AsRefExpr", expr_name)
+	CHECK_TAG(tag, EXPR_REF, "Expr::AsRefExpr", expr_name)
 	return {NewRef{}, (RefExpr*) this};
 	}
 
diff --git a/src/ZVal.h b/src/ZVal.h
index 629d63e77d..2dce0e0925 100644
--- a/src/ZVal.h
+++ b/src/ZVal.h
@@ -70,9 +70,9 @@ union ZVal {
 	ZVal(OpaqueVal* v)	{ opaque_val = v; }
 	ZVal(PatternVal* v)	{ re_val = v; }
 	ZVal(TableVal* v)	{ table_val = v; }
-	ZVal(TypeVal* v)	{ type_val = v; }
 	ZVal(RecordVal* v)	{ record_val = v; }
 	ZVal(VectorVal* v)	{ vector_val = v; }
+	ZVal(TypeVal* v)	{ type_val = v; }
 	ZVal(Val* v)		{ any_val = v; }
 
 	ZVal(StringValPtr v)	{ string_val = v.release(); }
@@ -82,9 +82,9 @@ union ZVal {
 	ZVal(OpaqueValPtr v)	{ opaque_val = v.release(); }
 	ZVal(PatternValPtr v)	{ re_val = v.release(); }
 	ZVal(TableValPtr v)	{ table_val = v.release(); }
-	ZVal(TypeValPtr v)	{ type_val = v.release(); }
 	ZVal(RecordValPtr v)	{ record_val = v.release(); }
 	ZVal(VectorValPtr v)	{ vector_val = v.release(); }
+	ZVal(TypeValPtr v)	{ type_val = v.release(); }
 
 	// Convert to a higher-level script value.  The caller needs to
 	// ensure that they're providing the correct type.
@@ -170,8 +170,8 @@ private:
 	// Used for double, time, interval.
 	double double_val;
 
-	// The types are all variants of Val, Type, or more fundamentally
-	// Obj.  They are raw pointers rather than IntrusivePtr's because
+	// The types are all variants of Val, or more fundamentally Obj.
+	// They are raw pointers rather than IntrusivePtr's because
 	// unions can't contain the latter.  For memory management, we use
 	// Ref/Unref.
 	StringVal* string_val;
diff --git a/src/script_opt/CPP/README.md b/src/script_opt/CPP/README.md
index 1ba87ec6ea..e2790320fd 100644
--- a/src/script_opt/CPP/README.md
+++ b/src/script_opt/CPP/README.md
@@ -78,8 +78,8 @@ a file `CPP-hashes.dat`, for use by an advanced feature, and an
 empty `CPP-gen-addl.h` file (same).
 2. `ninja` or `make` to recompile Zeek
 3. `./src/zeek -O use-C++ target.zeek`  
-Executes with each function/hook/
-event handler pulled in by `target.zeek` replaced with its compiled version.
+Executes with each function/hook/event
+handler pulled in by `target.zeek` replaced with its compiled version.
 
 Instead of the last line above, you can use the following variants:
 
diff --git a/src/script_opt/GenRDs.cc b/src/script_opt/GenRDs.cc
index a2f7000652..0ab24eea19 100644
--- a/src/script_opt/GenRDs.cc
+++ b/src/script_opt/GenRDs.cc
@@ -634,7 +634,7 @@ bool RD_Decorate::CheckLHS(const Expr* lhs, const Expr* e)
 		for ( const auto& expr : l->Exprs() )
 			{
 			if ( expr->Tag() != EXPR_NAME )
-				// This will happen for table initialiers,
+				// This will happen for table initializers,
 				// for example.
 				return false;