From dfc74a9af4b2dbdc952f8ab2436be2b77979d779 Mon Sep 17 00:00:00 2001
From: Vern Paxson <vern@corelight.com>
Date: Sun, 30 May 2021 18:44:41 -0700
Subject: [PATCH] switch ZVal representation of types from Type objects to
 TypeVal's

---
 src/ZVal.cc | 15 ++++-----------
 src/ZVal.h  | 11 ++++++-----
 2 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/src/ZVal.cc b/src/ZVal.cc
index 69f71250a2..fddb01279f 100644
--- a/src/ZVal.cc
+++ b/src/ZVal.cc
@@ -24,7 +24,7 @@ ZVal::ZVal(ValPtr v, const TypePtr& t)
 		return;
 		}
 
-	auto vt = v->GetType();
+	const auto& vt = v->GetType();
 
 	if ( vt->Tag() != t->Tag() && t->Tag() != TYPE_ANY )
 		{
@@ -102,7 +102,7 @@ ZVal::ZVal(ValPtr v, const TypePtr& t)
 		break;
 
 	case TYPE_TYPE:
-		type_val = t->Ref();
+		type_val = v.release()->AsTypeVal();
 		break;
 
 	case TYPE_ERROR:
@@ -222,15 +222,6 @@ ValPtr ZVal::ToVal(const TypePtr& t) const
 	case TYPE_ENUM:
 		return t->AsEnumType()->GetEnumVal(int_val);
 
-	case TYPE_ANY:
-		return {NewRef{}, any_val};
-
-	case TYPE_TYPE:
-		{
-		TypePtr tp = {NewRef{}, type_val};
-		return make_intrusive<TypeVal>(tp);
-		}
-
 	case TYPE_FUNC:
 		if ( func_val )
 			{
@@ -258,6 +249,8 @@ ValPtr ZVal::ToVal(const TypePtr& t) const
 	case TYPE_RECORD:	v = record_val; break;
 	case TYPE_VECTOR:	v = vector_val; break;
 	case TYPE_PATTERN:	v = re_val; break;
+	case TYPE_ANY:		v = any_val; break;
+	case TYPE_TYPE:		v = type_val; break;
 
 	case TYPE_ERROR:
 	case TYPE_TIMER:
diff --git a/src/ZVal.h b/src/ZVal.h
index 2a9cf2640e..413dc252a9 100644
--- a/src/ZVal.h
+++ b/src/ZVal.h
@@ -18,7 +18,7 @@ class RecordVal;
 class StringVal;
 class SubNetVal;
 class TableVal;
-class Type;
+class TypeVal;
 class Val;
 class VectorVal;
 
@@ -31,6 +31,7 @@ using RecordValPtr = IntrusivePtr<RecordVal>;
 using StringValPtr = IntrusivePtr<StringVal>;
 using SubNetValPtr = IntrusivePtr<SubNetVal>;
 using TableValPtr = IntrusivePtr<TableVal>;
+using TypeValPtr = IntrusivePtr<TypeVal>;
 using ValPtr = IntrusivePtr<Val>;
 using VectorValPtr = IntrusivePtr<VectorVal>;
 
@@ -69,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(Type* v)		{ type_val = v; }
 
 	ZVal(StringValPtr v)	{ string_val = v.release(); }
 	ZVal(AddrValPtr v)	{ addr_val = v.release(); }
@@ -80,9 +81,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(TypePtr v)		{ type_val = v.release(); }
 
 	// Convert to a higher-level script value.  The caller needs to
 	// ensure that they're providing the correct type.
@@ -103,7 +104,7 @@ union ZVal {
 	TableVal* AsTable() const	{ return table_val; }
 	RecordVal* AsRecord() const	{ return record_val; }
 	VectorVal* AsVector() const	{ return vector_val; }
-	Type* AsType() const		{ return type_val; }
+	TypeVal* AsType() const		{ return type_val; }
 	Val* AsAny() const		{ return any_val; }
 
 	Obj* ManagedVal() const		{ return managed_val; }
@@ -162,7 +163,7 @@ private:
 	TableVal* table_val;
 	RecordVal* record_val;
 	VectorVal* vector_val;
-	Type* type_val;
+	TypeVal* type_val;
 
 	// Used for "any" values.
 	Val* any_val;