Inconsistent behavior with casts involving tuples / headers

[jnfoster]

Compiling the following program

#include <v1model.p4>

header h_t {
  bit<8> f;
}

struct my_packet {
  h_t h;
}

struct my_metadata { }

parser MyParser(packet_in b, out my_packet p, inout my_metadata m, inout standard_metadata_t s) {
  state start {
   transition accept;
  }
}

control MyVerifyChecksum(in my_packet hdr, inout my_metadata meta) {
  apply { }
}


control MyIngress(inout my_packet p, inout my_metadata m, inout standard_metadata_t s) {
  apply {
    h_t h1 = p.h;              // ok
    h_t h2 = (h_t) p.h;        // ok
    h_t h3 = { p.h.f };        // ok
    h_t h4 = (h_t) { p.h.f };  // fails
  }
}

control MyEgress(inout my_packet p, inout my_metadata m, inout standard_metadata_t s) {
  apply { }
}

control MyComputeChecksum(inout my_packet p, inout my_metadata m) {
  apply { }
}

control MyDeparser(packet_out b, in my_packet p) {
  apply { }
}

V1Switch(MyParser(), MyVerifyChecksum(), MyIngress(), MyEgress(), MyComputeChecksum(), MyDeparser()) main;

Produces an error:

/home/ubuntu/min.p4(29): error: cast: Illegal cast from Tuple(1) to header h_t
    h_t h4 = (h_t) { p.h.f };
             ^^^^^^^^^^^^^^^
/home/ubuntu/min.p4(28)
    h_t h3 = { p.h.f };
             ^^^^^^^^^
/home/ubuntu/min.p4(3)
header h_t {
       ^^^

It seems like these should all work...

In addition, reporting the tuple on line 28 as an error is wrong. It has nothing to do with the declaration involving h4.

[jnfoster]

Some more examples:

    struct bs { bool y; bool z; }
    ...
    bool b = true;
    bit<1> c = 0;
    bool d = false;     
    // bs x = { b, c };    // fails
    bs x = { b, (bool) c}; // ok
    bs y = { b, d };       // ok

[mihaibudiu]

What is bs?

[jnfoster]

Sorry, just a pair of bools.

[jnfoster]

Further, constant propagation seems inconsistent:

    const bool b = true;
    const bit<1> c = 0;
    const bool d = false;     
    bs x = { b, (bool) c}; // ok
    bs y = { b, d };       // ok

becomes

        const bool b = true;
        const bit<1> c = 1w0;
        const bool d = false;
        bs x = { b, false };
        bs y = { b, d };

after the first constant folding pass.

[jnfoster]

Closed by #593