swift-mirror/test/Constraints/bridging-nsnumber-and-nsvalue.swift.gyb

// RUN: %empty-directory(%t)
// RUN: %gyb %s -o %t/bridging-nsnumber-and-nsvalue.swift
// RUN: %target-swift-frontend -typecheck -verify %t/bridging-nsnumber-and-nsvalue.swift -swift-version 4

// REQUIRES: objc_interop

import Foundation
import CoreGraphics

%{
coercionTypes = {
  'NSNumber': [
    'Int',
    'UInt',
    'Int64',
    'UInt64',
    'Int32',
    'UInt32',
    'Int16',
    'UInt16',
    'Int8',
    'UInt8',
    'Float',
    'Double',
    'CGFloat',
  ],
  'NSValue': [
    'CGRect',
    'CGPoint',
    'CGSize',
  ],
}
}%

// For testing purposes, make everything Hashable. Don't do this at home
extension Equatable {
  public static func ==(x: Self, y: Self) -> Bool {
    fatalError("hella cray")
  }
}
extension Hashable {
  public func hash(into hasher: inout Hasher) {
    fatalError("trill hiphy")
  }
}

extension CGSize: @retroactive Hashable {}
extension CGPoint: @retroactive Hashable {}
extension CGRect: @retroactive Hashable {}

% for ObjectType, ValueTypes in coercionTypes.items():
func bridgeNSNumberBackToSpecificType(object: ${ObjectType},
                                      optional: ${ObjectType}?,
                                      array: [${ObjectType}],
                                      dictKeys: [${ObjectType}: Any],
                                      dictValues: [AnyHashable: ${ObjectType}],
                                      dictBoth: [${ObjectType}: ${ObjectType}],
                                      set: Set<${ObjectType}>) {
%   for Type in ValueTypes:
  _ = object as ${Type} // expected-error{{is not convertible to}} expected-note {{use 'as!'}}
  _ = object is ${Type}
  _ = object as? ${Type}
  _ = object as! ${Type}

  _ = optional as ${Type}? // expected-error{{cannot convert value of type '${ObjectType}?' to type '${Type}?' in coercion}} expected-note {{arguments to generic parameter 'Wrapped' ('${ObjectType}' and '${Type}') are expected to be equal}}
  _ = optional is ${Type}?
  _ = optional as? ${Type}?
  _ = optional as! ${Type}?

  _ = optional as ${Type} // expected-error{{is not convertible to}} expected-note {{use 'as!'}}
  _ = optional is ${Type}
  _ = optional as? ${Type}
  _ = optional as! ${Type}

  _ = array as [${Type}] // expected-error{{cannot convert value of type '[${ObjectType}]' to type '[${Type}]' in coercion}} expected-note {{arguments to generic parameter 'Element' ('${ObjectType}' and '${Type}') are expected to be equal}}
  _ = array is [${Type}]
  _ = array as? [${Type}]
  _ = array as! [${Type}]

  _ = dictKeys as [${Type}: Any] // expected-error{{cannot convert value of type '[${ObjectType} : Any]' to type '[${Type} : Any]' in coercion}} expected-note {{arguments to generic parameter 'Key' ('${ObjectType}' and '${Type}') are expected to be equal}}
  _ = dictKeys is [${Type}: Any]
  _ = dictKeys as? [${Type}: Any]
  _ = dictKeys as! [${Type}: Any]

  _ = dictKeys as [${Type}: AnyObject] // expected-error{{is not convertible to}} expected-note {{use 'as!'}}
  _ = dictKeys is [${Type}: AnyObject]
  _ = dictKeys as? [${Type}: AnyObject]
  _ = dictKeys as! [${Type}: AnyObject]

  _ = dictValues as [AnyHashable: ${Type}] // expected-error{{cannot convert value of type '[AnyHashable : ${ObjectType}]' to type '[AnyHashable : ${Type}]' in coercion}} expected-note {{arguments to generic parameter 'Value' ('${ObjectType}' and '${Type}') are expected to be equal}}
  _ = dictValues is [AnyHashable: ${Type}]
  _ = dictValues as? [AnyHashable: ${Type}]
  _ = dictValues as! [AnyHashable: ${Type}]

  _ = dictValues as [NSObject: ${Type}] // expected-error{{is not convertible to}} expected-note {{use 'as!'}}
  _ = dictValues is [NSObject: ${Type}]
  _ = dictValues as? [NSObject: ${Type}]
  _ = dictValues as! [NSObject: ${Type}]

  _ = dictBoth as [${ObjectType}: ${Type}] // expected-error{{cannot convert value of type '[${ObjectType} : ${ObjectType}]' to type '[${ObjectType} : ${Type}]' in coercion}} expected-note {{arguments to generic parameter 'Value' ('${ObjectType}' and '${Type}') are expected to be equal}}
  _ = dictBoth is [${ObjectType}: ${Type}]
  _ = dictBoth as? [${ObjectType}: ${Type}]
  _ = dictBoth as! [${ObjectType}: ${Type}]

  _ = dictBoth as [${Type}: ${ObjectType}] // expected-error{{cannot convert value of type '[${ObjectType} : ${ObjectType}]' to type '[${Type} : ${ObjectType}]' in coercion}} expected-note {{arguments to generic parameter 'Key' ('${ObjectType}' and '${Type}') are expected to be equal}}
  _ = dictBoth is [${Type}: ${ObjectType}]
  _ = dictBoth as? [${Type}: ${ObjectType}]
  _ = dictBoth as! [${Type}: ${ObjectType}]

  _ = dictBoth as [${Type}: ${Type}] // expected-error{{is not convertible to}} expected-note {{use 'as!'}}
  _ = dictBoth is [${Type}: ${Type}]
  _ = dictBoth as? [${Type}: ${Type}]
  _ = dictBoth as! [${Type}: ${Type}]

  _ = set as Set<${Type}> // expected-error{{cannot convert value of type 'Set<${ObjectType}>' to type 'Set<${Type}>' in coercion}} expected-note {{arguments to generic parameter 'Element' ('${ObjectType}' and '${Type}') are expected to be equal}}
  _ = set is Set<${Type}>
  _ = set as? Set<${Type}>
  _ = set as! Set<${Type}>
%   end

  _ = object is String // expected-warning{{always fails}}
  _ = object as? String // expected-warning{{always fails}}
  _ = object as! String // expected-warning{{always fails}}
}
% end