various accessors used by ZAM compiler

src/Expr.h

@@ -94,12 +94,16 @@ class ForExpr;
 class HasFieldExpr;
 class IndexAssignExpr;
 class IndexExpr;
-class IsExpr;
 class InlineExpr;
+class IsExpr;
 class LambdaExpr;
 class ListExpr;
 class NameExpr;
+class RecordCoerceExpr;
+class RecordConstructorExpr;
 class RefExpr;
+class SetConstructorExpr;
+class TableConstructorExpr;
 
 class Expr;
 using CallExprPtr = IntrusivePtr<CallExpr>;
@@ -215,12 +219,16 @@ public:
 	ZEEK_EXPR_ACCESSOR_DECLS(HasFieldExpr)
 	ZEEK_EXPR_ACCESSOR_DECLS(IndexAssignExpr)
 	ZEEK_EXPR_ACCESSOR_DECLS(IndexExpr)
-	ZEEK_EXPR_ACCESSOR_DECLS(IsExpr)
 	ZEEK_EXPR_ACCESSOR_DECLS(InlineExpr)
+	ZEEK_EXPR_ACCESSOR_DECLS(IsExpr)
 	ZEEK_EXPR_ACCESSOR_DECLS(LambdaExpr)
 	ZEEK_EXPR_ACCESSOR_DECLS(ListExpr)
 	ZEEK_EXPR_ACCESSOR_DECLS(NameExpr)
+	ZEEK_EXPR_ACCESSOR_DECLS(RecordCoerceExpr)
+	ZEEK_EXPR_ACCESSOR_DECLS(RecordConstructorExpr)
 	ZEEK_EXPR_ACCESSOR_DECLS(RefExpr)
+	ZEEK_EXPR_ACCESSOR_DECLS(SetConstructorExpr)
+	ZEEK_EXPR_ACCESSOR_DECLS(TableConstructorExpr)
 
 	void Describe(ODesc* d) const override final;
 
@@ -1291,6 +1299,7 @@ public:
 
 	Expr* Func() const	{ return func.get(); }
 	ListExpr* Args() const	{ return args.get(); }
+	ListExprPtr ArgsPtr() const	{ return args; }
 
 	bool IsPure() const override;
 

src/Stmt.h

@@ -16,9 +16,12 @@ class CompositeHash;
 class NameExpr;
 using NameExprPtr = IntrusivePtr<zeek::detail::NameExpr>;
 
+class ZAMCompiler;	// for "friend" declarations
+
 class ExprListStmt : public Stmt {
 public:
 	const ListExpr* ExprList() const	{ return l.get(); }
+	const ListExprPtr& ExprListPtr() const	{ return l; }
 
 	TraversalCode Traverse(TraversalCallback* cb) const override;
 
@@ -523,6 +526,7 @@ public:
 	const Stmt* Body() const	{ return s1.get(); }
 	const Expr* TimeoutExpr() const	{ return timeout.get(); }
 	const Stmt* TimeoutBody() const	{ return s2.get(); }
+	bool IsReturn() const		{ return is_return; }
 
 	void StmtDescribe(ODesc* d) const override;
 
@@ -597,6 +601,8 @@ class CheckAnyLenStmt : public ExprStmt {
 public:
 	explicit CheckAnyLenStmt(ExprPtr e, int expected_len);
 
+	int ExpectedLen() const		{ return expected_len; }
+
 	ValPtr Exec(Frame* f, StmtFlowType& flow) override;
 
 	StmtPtr Duplicate() override;

src/Val.cc

@@ -84,6 +84,7 @@ CONVERTERS(TYPE_STRING, StringVal*, Val::AsStringVal)
 CONVERTERS(TYPE_VECTOR, VectorVal*, Val::AsVectorVal)
 CONVERTERS(TYPE_ENUM, EnumVal*, Val::AsEnumVal)
 CONVERTERS(TYPE_OPAQUE, OpaqueVal*, Val::AsOpaqueVal)
+CONVERTERS(TYPE_TYPE, TypeVal*, Val::AsTypeVal)
 
 ValPtr Val::CloneState::NewClone(Val* src, ValPtr dst)
 	{

src/Val.h

@@ -186,6 +186,9 @@ UNDERLYING_ACCESSOR_DECL(TypeVal, zeek::Type*, AsType)
 	OpaqueVal* AsOpaqueVal();
 	const OpaqueVal* AsOpaqueVal() const;
 
+	TypeVal* AsTypeVal();
+	const TypeVal* AsTypeVal() const;
+
 	void Describe(ODesc* d) const override;
 	virtual void DescribeReST(ODesc* d) const;
 

src/script_opt/Expr.cc

@@ -55,6 +55,12 @@ const FieldLHSAssignExpr* Expr::AsFieldLHSAssignExpr() const
 	return (const FieldLHSAssignExpr*) this;
 	}
 
+HasFieldExpr* Expr::AsHasFieldExpr()
+	{
+	CHECK_TAG(tag, EXPR_HAS_FIELD, "ExprVal::AsHasFieldExpr", expr_name)
+	return (HasFieldExpr*) this;
+	}
+
 const HasFieldExpr* Expr::AsHasFieldExpr() const
 	{
 	CHECK_TAG(tag, EXPR_HAS_FIELD, "ExprVal::AsHasFieldExpr", expr_name)
@@ -73,12 +79,60 @@ const IsExpr* Expr::AsIsExpr() const
 	return (const IsExpr*) this;
 	}
 
+CallExpr* Expr::AsCallExpr()
+	{
+	CHECK_TAG(tag, EXPR_CALL, "ExprVal::AsCallExpr", expr_name)
+	return (CallExpr*) this;
+	}
+
+FieldAssignExpr* Expr::AsFieldAssignExpr()
+	{
+	CHECK_TAG(tag, EXPR_FIELD_ASSIGN, "ExprVal::AsFieldAssignExpr", expr_name)
+	return (FieldAssignExpr*) this;
+	}
+
+const RecordCoerceExpr* Expr::AsRecordCoerceExpr() const
+	{
+	CHECK_TAG(tag, EXPR_RECORD_COERCE, "ExprVal::AsRecordCoerceExpr", expr_name)
+	return (const RecordCoerceExpr*) this;
+	}
+
+const RecordConstructorExpr* Expr::AsRecordConstructorExpr() const
+	{
+	CHECK_TAG(tag, EXPR_RECORD_CONSTRUCTOR, "ExprVal::AsRecordConstructorExpr", expr_name)
+	return (const RecordConstructorExpr*) this;
+	}
+
+const TableConstructorExpr* Expr::AsTableConstructorExpr() const
+	{
+	CHECK_TAG(tag, EXPR_TABLE_CONSTRUCTOR, "ExprVal::AsTableConstructorExpr", expr_name)
+	return (const TableConstructorExpr*) this;
+	}
+
+const SetConstructorExpr* Expr::AsSetConstructorExpr() const
+	{
+	CHECK_TAG(tag, EXPR_SET_CONSTRUCTOR, "ExprVal::AsSetConstructorExpr", expr_name)
+	return (const SetConstructorExpr*) this;
+	}
+
+RefExpr* Expr::AsRefExpr()
+	{
+	CHECK_TAG(tag, EXPR_REF, "ExprVal::AsRefExpr", expr_name)
+	return (RefExpr*) this;
+	}
+
 const InlineExpr* Expr::AsInlineExpr() const
 	{
 	CHECK_TAG(tag, EXPR_INLINE, "ExprVal::AsInlineExpr", expr_name)
 	return (const InlineExpr*) this;
 	}
 
+AnyIndexExpr* Expr::AsAnyIndexExpr()
+	{
+	CHECK_TAG(tag, EXPR_ANY_INDEX, "ExprVal::AsAnyIndexExpr", expr_name)
+	return (AnyIndexExpr*) this;
+	}
+
 const AnyIndexExpr* Expr::AsAnyIndexExpr() const
 	{
 	CHECK_TAG(tag, EXPR_ANY_INDEX, "ExprVal::AsAnyIndexExpr", expr_name)