fixits-apply.swift.result

// RUN: not %swift -typecheck -target %target-triple %s -emit-fixits-path %t.remap -I %S/Inputs
// RUN: c-arcmt-test %t.remap | arcmt-test -verify-transformed-files %s.result

class Base {}
class Derived : Base {}

var b : Base
b as! Derived
b as! Derived

b 

var opti : Int?
// Add bang.
var i : Int = opti!
// But remove unnecessary bang.
var i2 : Int = i

struct MyMask : OptionSet {
  init(_ rawValue: UInt) {}
  init(rawValue: UInt) {}
  init(nilLiteral: ()) {}

  var rawValue: UInt { return 0 }

  static var allZeros: MyMask { return MyMask(0) }
  static var Bingo: MyMask { return MyMask(1) }
}

let _: MyMask = []

func supported() -> MyMask {
  return MyMask(rawValue: UInt(MyMask.Bingo))
}

struct MyEventMask2 : OptionSet {
  init(rawValue: UInt64) {}
  var rawValue: UInt64 { return 0 }
}
func sendIt(_: MyEventMask2) {}
func sendItOpt(_: MyEventMask2?) {}
func sendItOpt3(_: MyEventMask2???) {}
func testMask1(a: Int) {
  sendIt(MyEventMask2(rawValue: UInt64(a)))
}
func testMask2(a: UInt64) {
  sendIt(MyEventMask2(rawValue: a))
}
func testMask3(a: MyEventMask2) {
  testMask1(a: Int(a.rawValue))
}
func testMask4(a: MyEventMask2) {
  testMask2(a: a.rawValue)
}
func testMask5(a: Int) {
  sendItOpt(MyEventMask2(rawValue: UInt64(a)))
}
func testMask6(a: Int) {
  sendItOpt(MyEventMask2(rawValue: UInt64(a)))
}
func testMask7(a: Int?) {
  sendItOpt(a.map { MyEventMask2(rawValue: UInt64($0)) })
}
func testMask8(a: UInt64?) {
  sendItOpt(a.map { MyEventMask2(rawValue: $0) })
}
func testMask9(a: Any) {
  sendItOpt((a as? Int).map { MyEventMask2(rawValue: UInt64($0)) })
}
func testMask10(a: Int?) {
  sendIt(a) // no fix, nullability mismatch.
}
func testMask11(a: MyEventMask2?) {
  testMask7(a: a.map { Int($0.rawValue) })
}
func testMask12(a: MyEventMask2?) {
  testMask8(a: a.map { $0.rawValue })
}
func testMask13(a: MyEventMask2?) {
  testMask1(a: a) // no fix, nullability mismatch.
}
func testMask14() {
  sendIt(MyEventMask2(rawValue: 1))
  sendItOpt(MyEventMask2(rawValue: 2))
}

struct Wrapper {
  typealias InnerMask = MyEventMask2
}
func sendItInner(_: Wrapper.InnerMask) {}
func testInnerMask(a: UInt64) {
  sendItInner(Wrapper.InnerMask(rawValue: a))
}

struct SomeName : RawRepresentable {
  init(_ rawValue: String) {}
  init(rawValue: String) {}
  var rawValue: String { return "" }
}
func testPassSomeName(_: SomeName) {}
func testConvertSomeName(s: String) {
  testPassSomeName(SomeName(rawValue: "\(s)}"))
}

class WrappedClass {}
class WrappedClassSub: WrappedClass {}
struct ClassWrapper : RawRepresentable {
  var rawValue: WrappedClass
}
func testPassAnyObject(_: AnyObject) {}
func testPassAnyObjectOpt(_: AnyObject?) {}
func testPassWrappedSub(_: WrappedClassSub) {}
func testConvertClassWrapper(_ x: ClassWrapper, _ sub: WrappedClassSub) {
  testPassAnyObject(x.rawValue)
  testPassAnyObjectOpt(x.rawValue)
  testPassWrappedSub(x)

  let iuo: ClassWrapper! = x
  testPassAnyObject(iuo)
  testPassAnyObjectOpt(iuo.map { $0.rawValue })

  let _: ClassWrapper = ClassWrapper(rawValue: sub)
  let _: ClassWrapper = ClassWrapper(rawValue: x.rawValue)
  // FIXME: This one inserts 'as!', which is incorrect.
  let _: ClassWrapper = sub as AnyObject as! ClassWrapper
}

enum MyEnumType : UInt32 {
  case invalid
}
_ = MyEnumType.invalid

func goo(e : Error) {
    var e = e
}
func goo2(e: Error) { var e = e }
func goo3(e: Int) { var e = e; e = 3 }
protocol A {
  func bar(s: Int)
}
extension A {
  func bar(s: Int) {
    var s = s
    s += 5
  }
}

func baz(x: Int) {
  var x = x
  x += 10
}
func foo(y: String, x: inout Int) {

}

struct Test1 : OptionSet {
  init(rawValue: Int) {}
  var rawValue: Int { return 0 }
}

print("", false)

func ftest1() {
  // Don't replace the variable name with '_'
  let myvar = 0
}

func ftest2(x: @escaping (Int) -> Int) {}

protocol SomeProt {
  func protMeth(p: Int)
}
@objc protocol SomeObjCProt {
  func objcprotMeth(p: Int)
}
class Test2 : SomeProt, SomeObjCProt {
  func protMeth(_ p: Int) {}

  func instMeth(p: Int) {}
  func instMeth2(p: Int, p2: Int) {}
  func objcprotMeth(_ p: Int) {}
}
@objc class Test3 : SomeObjCProt {
  func objcprotMeth(_ p: Int) {}
}
class SubTest2 : Test2 {
  override func instMeth(_ p: Int) {}
}
Test2().instMeth(0)
Test2().instMeth2(0, p2:1)

func recit(_: Int32) {}
func ftest3(_ fd: CInt) {
  recit(fd)
}
func ftest4(_ fd: UInt) {
  recit(Int32(fd))
}

func letToVar1() {
  var x = 1
  if x == 2 {
    x += 3
  }
  var y = ""
  y.append("as")
  y.append("df")
}

class Node  {}
class Graph<NodeType : Node> {}
var graph: Graph<Node>

class Node2  {}
class Graph2<NodeType1 : Node, NodeType2 : Node2> {}
var graph: Graph2<Node, Node2>

@objc protocol ObjCProt { }
class Graph3<NodeType : ObjCProt> {}
var graph: Graph3<ObjCProt>

class Graph4<NodeType : SomeProt> {}
var graph: Graph4<<#NodeType: SomeProt#>>
var graphAgain = Graph4<<#NodeType: SomeProt#>>()

class GraphCombo<NodeType : SomeProt & ObjCProt> {}
var graph: GraphCombo<<#NodeType: ObjCProt & SomeProt#>>

func evilCommas(s: String) {
  _ = s[s.startIndex..<<#editorplaceholder#>]
  _ = true ? s[s.startIndex..<<#editorplaceholder#>] : ""
  _ = [s.startIndex..<<#editorplaceholder#>]
}

import Empty
func testGenericSig(x: Empty<Int>) -> Empty<String> {}

class NonObjC {}
protocol NonObjCProtocol {}
@objc class IBIssues {
  @IBOutlet static private var ibout1: IBIssues!
  @IBOutlet private var ibout2: NonObjC!
  @IBOutlet private var ibout3: NonObjCProtocol!
  @IBOutlet private let ibout4: IBIssues!
  @IBOutlet private var ibout5: [[IBIssues]]!
  @IBOutlet private var ibout6: [String: String]!
  @IBInspectable static private var ibinspect1: IBIssues!
  @IBAction static func ibact() {}
  @IBSegueAction static func ibsegact(_: String, _: IBIssues) -> IBIssues { return self }
}

@IBDesignable extension SomeProt {}

func attrNowOnType(foo: ()->()) {}

class InitDynType {
  init() {}
  func notInit() {
    self.init()
  }
}

class NoSemi {
  enum Bar { case bar }
  var foo: .Bar = .bar
}

func fnWithClosure(c: @escaping ()->()) {}
func testescape(rec: @escaping ()->()) {
  fnWithClosure { rec() }
}

func testDeprecatedAttr() -> Int { return 0 }

protocol Prot1 {}
protocol Prot2 {
  associatedtype Ty = Prot1
}
class Cls1 : Prot1 {}
func testwhere<T: Prot2>(_: T) where T.Ty == Cls1 {}

enum E {
  case abc
}
func testEnumRename() { _ = E.Abc }

func testAnyToAnyObject(x: Any) {
  (x as AnyObject).instMeth(p: 1)
}

func testProtocolCompositionSyntax() {
  var _: Any
  var _: Prot1
  var _: Prot1 & Prot2
}

func disable_unnamed_param_reorder(p: Int, _: String) {}
disable_unnamed_param_reorder(0, "") // no change.

prefix operator *****

class BoolFoo : Bool {
  var boolValue: Bool {return false}
}
func testBoolValue(a : BoolFoo) {
  if a.boolValue { }
  guard a.boolValue {}
  if (a as BoolFoo).boolValue {}
}

protocol P1 {}
protocol P2 {}
var a : (P1 & P2)?
var a2 : P1= 17 as! P1

class TestOptionalMethodFixit {
  func test() {}
}