Find join of types, improve inference

[turbolent]

Context

Implement a function to return the least common supertype.

This improves type checking for:

• Conditionals: instead of just returning the left type (type of true branch) and requiring the right type (else branch) to be the same
• Array literals
• Dictionary literals

See "Types and Programming Languages, 16.3 Joins and Meets"

In the following example y should be inferred to String?:

let x: String? = ""
let y = true ? nil : x 

Definition of Done

• Sema:
  • Add function to find join of two or more types
  • Use join function for conditionals
  • Use join function for array literals
  • Use join function for dictionary literals
• Tests
• Documentation

[bluesign]

Sorry if this is not related but something I observed and curious if this fixes that:

   var  myDictionary = {
           1: true,
           2: false   
       }

  myDictionary = myDictionary as! {Int:AnyStruct};

Currently, this gives a conflicting error and warning:

Error:
mismatched types. expected {Int:Bool}, got {Int:AnyStruct}

Warning:
force cast ('as!') from to {Int:AnyStruct} always succeeds

[SupunS]

These errors are actually for two places.

The first error mismatched types. expected {Int:Bool}, got {Int:AnyStruct} is for the assignment:
myDictionary = ..., where rhs-expr is forced to have {Int:AnyStruct}. But the variable is {Int:Bool}. Assigning a broader-type to a narrower-type is not allowed.

The second warning is for the cast: myDictionary as! {Int:AnyStruct};. because the upcasting/boxing is always guaranteed to succeed.
i.e: Force-casting is not required.

So both the error and the warning are valid in this case. Here they have overlapped at the same place. If you break the second statement into two, the error/warning would look much more clear/sensible:. e.g:

  var temp = myDictionary as! {Int:AnyStruct}    // warning goes here

  myDictionary = temp;   // error goes here

The supertype calculation wouldn't change this behavior either. Supertype inferring only happens at the expression level. It wouldn't consider multiple statements for type infering. The least common supertype for {1: true, 2: false} (therefore, also for myDictionary) would still be {Int:Bool}.

[bluesign]

Thanks @SupunS, actually it makes sense when separating into two.