Direct cast is possible between equivalent types

[MichalKekely]

The issue was that the following code ended with a CompilerBug:

bit_var0 = (bit<1>) (bool) (bool) bit_var1;

The problem is with the double cast to bool (more specifically casting bool into bool). The problem was that the source and destination types were two different objects of the same class:

[9144] Type_Boolean
[9142] Type_Boolean

Therefore the original check for canCastBetween did not match those as the same type (since the pointers are not equal):

p4c/frontends/p4/typeChecking/typeChecker.cpp

Lines 690 to 692 in 1b47d14

	bool TypeInference::canCastBetween(const IR::Type *dest, const IR::Type *src) const {
	if (src->is<IR::Type_Action>()) return false;
	if (src == dest) return true;

Which lead to a new cast being introduced (so essentially there were 3 casts to bool instead of 2), while one of the original ones was not added into the type map:

p4c/frontends/p4/typeChecking/typeChecker.cpp

Lines 2810 to 2828 in 1b47d14

	if (!canCastBetween(castType, sourceType)) {
	// This cast is not legal directly, but let's try to see whether
	// performing a substitution can help. This will allow the use
	// of constants on the RHS.
	const IR::Type *destType = castType;
	while (destType->is<IR::Type_Newtype>())
	destType = getTypeType(destType->to<IR::Type_Newtype>()->type);
	auto tvs = unify(expression, destType, sourceType, "Cannot cast from '%1%' to '%2%'",
	{sourceType, castType});
	if (tvs == nullptr) return expression;
	const IR::Expression *rhs = expression;
	if (!tvs->isIdentity()) {
	ConstantTypeSubstitution cts(tvs, refMap, typeMap, this);
	rhs = cts.convert(expression->expr); // sets type
	}
	if (rhs != expression->expr) {
	// if we are here we have performed a substitution on the rhs
	expression = new IR::Cast(expression->srcInfo, expression->destType, rhs);

[davidbolvansky]

any test?

[MichalKekely]

any test?

Added testcase: 4743bf4