[New Feature] Support generic intersection types

[rdulmina]

We currently only support limited combinations for intersection types (i.e., readonly intersections and error intersections).

But according to the spec, this support should be available more generically. E.g., - the intersection of two records.

The set of shapes denoted by an intersection type is the intersection of the set of shapes denoted by T1 and the set of shapes denoted by T2. Thus, the type T1&T2 contains a shape if and only if the types denoted by T1 and T2 both contain the shape. It is a error to have an intersection type that denotes an empty set of shapes. In an intersection type T1&T2, it is an error if T1 and T2 are both function types unless there is a single function-type-descriptor that denotes a type that is a subtype of both T1 and T2. A type descriptor T1&T2 is not a class and cannot be used with new, even if one or both of T1 and T2 are classes.

The reason to introduce IntersectableReferenceType.java in the implementation was a requirement to get the intersection type given the effective type since in some cases intersection type information was unavailable.

This happens when there are places we return only the effective type. We decided to pass the Complete intersection type instead and get the effective type from the intersection type when needed via getReferredType method and removed the IntersectableReferenceType.java.. This is because if effective types of two intersections are the same type T then, T cannot hold more than one intersection type detail.

eg:

type Foo record {|
    int a;
|};

type FooA Foo & map<any>;

type FooB Foo & map<anydata>;

Since the effective of both the type definitions is Foo, we don’t create a new type as the effective type since Foo is an existing type and we directly use it as the effective type. But Foo can only hold one intersection type.

Please share your thoughts on this.

Related discussion doc https://docs.google.com/document/d/1hKGrr3DF3TEk7LaGURmRToWyxNVekkM9cYcL-E-rRlM

[rdulmina]

Currently allowed cases

Intersections with readonly

• [int, string] & readonly

• Int[] & readonly

• record {| record {| int a;|} a; string b;|} & readonly

• object { record {| int a;|} a; string b;} & readonly

Error intersections

• error<record {|int a; string b?;|}> & error<record {|int a;|}> b

Intersections that are going to be supported with this feature

All the intersections that the intersection is nonempty

• Int|string|boolean|xml & string|booolean|float —---> string|booolean

• record {|int a; string b?;|} & record {|int a;|} —---> record {|int a;|}

• record {|int a; anydata…|} & record {|string a; int…|} —---> record {|int…|}

• table<record {|int a; string b?;|}> & table<record {|int a;|}> —---> table<record {|int a;|}>