[Spec Deviation] Freezing a container should narrow its inherent type to a type that consists of just its current shape

[MaryamZi]

Description:
According to the spec (v0.990:2019-01-16 - page 17), "A frozen container value belongs to a type if and only if the type contains the shape of the value. Thus after a container value is frozen, its inherent type does not provide additional information that cannot be derived from the value. In other words, freezing a container narrows its inherent type to a type that consists of just its current shape"

The is check works as expected after freezing a value:

import ballerina/io;

public function main(string... args) {
    map<string|int> m1 = { str: "string only" };
    anydata a = m1;  
    io:println(a is map<string>); // false

    _ = a.freeze();
    io:println(a is map<string>); // true
}

But when trying to use such a value in the context of the narrowed type, the original type is still considered.

import ballerina/io;

public function main(string... args) {
    map<string|int> m1 = { str: "string only" };
    anydata a = m1;

    _ = a.freeze();
    io:println(a is map<string>); // true

    map<map<string>> m2 = {};
    insertMemberToMap(m2, "strMap", a); // panics with {ballerina}InherentTypeViolation {"message":"invalid map insertion: expected value of type 'map<string>', found 'map<string|int>'"}
}

public function insertMemberToMap(map<any> mapVal, string index, any member) {
    mapVal[index] = member;
}

Casting/assertion also fails similarly.

Affected Versions:
0.990.2

[hasithaa]

@MaryamZi Please verify this w.r.t 2019R3

[MaryamZi]

IMO, this is still valid.

The 2019R3 spec says

• "For an immutable value, looking like a type and belonging to a type are the same thing." (5. Values, types and variables)

• "The inherent type of an immutable container is a singleton type with the container's shape as its single member. Thus, an immutable container value belongs to a type if and only if the type contains the shape of the value." (Structured values)

[vinok88]

Following code runs fine now with v1-0-0-alpha3 pack. Do we need any fixes here?

import ballerina/io;

public function main(string... args) {
    map<string|int> m1 = { str: "string only" };
    anydata a = m1.cloneReadOnly();

    // _ = a.freeze();
    io:println(a is map<string>); // true

    map<map<string>> m2 = {};
    insertMemberToMap(m2, "strMap", a); // panics with {ballerina}InherentTypeViolation {"message":"invalid map insertion: expected value of type 'map<string>', found 'map<string|int>'"}
}

public function insertMemberToMap(map<any> mapVal, string index, any member) {
    mapVal[index] = member;
}

[MaryamZi]

Yeah, this scenario seems to work fine.

Even though we don't change the inherent type, since most updates are done by first checking checkIsType() we should be able to achieve the expected behaviour in general. May have to validate if there are any related paths that do not go through checkIsType() though.

However as mentioned in #15278 (comment), typeof should return a singleton type representing the shape of the value if it is immutable. This is not implemented yet, and we have to do one of the following

• change the inherent type itself as mentioned in this issue
• check if the value is immutable when evaluating typeof and return a new typedesc there (but this could cause issues since we expect a single typedesc - reference equality will fail)