[tests] Fixing tests under test/type, test/expr and test/Parse

Author: LucianoPAlmeida

test/Parse/omit_return.swift

@@ -510,7 +510,7 @@ func ff_implicitIsExpr<T>(t: T) -> Bool {
 }
 
 func ff_implicitCoerceExpr<T>() -> T.Type {
-    T.self as T.Type
+    T.self as T.Type // expected-warning {{redundant cast to 'T.Type' has no effect}} {{12-22=}}
 }
 
 func ff_implicitConditionalCheckedCastExprAs<T>(t: T) -> Int? {

test/expr/cast/array_downcast.swift

@@ -24,7 +24,7 @@ var ta = [t]
 
 va = ta
 
-var va2: ([V])? = va as [V]
+var va2: ([V])? = va as [V] // expected-warning {{redundant cast to '[V]' has no effect}} {{22-29=}}
 var v2: V = va2![0]
 
 var ua2: ([U])? = va as? [U]

test/expr/cast/as_coerce.swift

@@ -81,7 +81,7 @@ c3 as C4 // expected-error {{'C3' is not convertible to 'C4'; did you mean to us
 // <rdar://problem/19495142> Various incorrect diagnostics for explicit type conversions
 1 as Double as Float // expected-error{{cannot convert value of type 'Double' to type 'Float' in coercion}}
 1 as Int as String // expected-error{{cannot convert value of type 'Int' to type 'String' in coercion}}
-Double(1) as Double as String // expected-error{{cannot convert value of type 'Double' to type 'String' in coercion}}
+Double(1) as Double as String // expected-error{{cannot convert value of type 'Double' to type 'String' in coercion}} expected-warning {{redundant cast to 'Double' has no effect}} {{11-21=}}
 ["awd"] as [Int] // expected-error{{cannot convert value of type 'String' to expected element type 'Int'}}
 ([1, 2, 1.0], 1) as ([String], Int)
 // expected-error@-1 2 {{cannot convert value of type 'Int' to expected element type 'String'}}
@@ -135,3 +135,182 @@ _ = sr6022 as! AnyObject // expected-warning {{forced cast from '() -> Any' to '
 _ = sr6022 as? AnyObject // expected-warning {{conditional cast from '() -> Any' to 'AnyObject' always succeeds}}
 _ = sr6022_1 as! Any // expected-warning {{forced cast from '() -> ()' to 'Any' always succeeds; did you mean to use 'as'?}}
 _ = sr6022_1 as? Any // expected-warning {{conditional cast from '() -> ()' to 'Any' always succeeds}}
+
+// SR-11295
+let sr11295a = "Hello"
+_ = sr11295a as String // expected-warning {{redundant cast to 'String' has no effect}} {{14-24=}}
+
+let sr11295b = 1
+_ = sr11295b as Int // expected-warning {{redundant cast to 'Int' has no effect}} {{14-21=}}
+
+typealias Type = String
+
+let sr11295c: Type = "Hello Typealias"
+_ = sr11295c as String // expected-warning {{redundant cast to 'String' has no effect}} {{14-24=}}
+
+let sr11295d = "Hello Typealias"
+_ = sr11295d as Type // expected-warning {{redundant cast to 'Type' (aka 'String') has no effect}} {{14-22=}}
+
+_ = "Hello" as String // Ok
+_ = 1 as Int64 // Ok
+_ = [] as Set<Int> // Ok
+
+class SR11295A {}
+class SR11295B: SR11295A {}
+
+var sr11295ap = SR11295A()
+var sr11295bc = SR11295B()
+
+_ = sr11295bc as SR11295A // Ok 
+
+_ = 1 as Double as Double // expected-warning {{redundant cast to 'Double' has no effect}} {{17-27=}}
+_ = Double(1) as Double // expected-warning {{redundant cast to 'Double' has no effect}} {{15-25=}}
+_ = Int(1) as Int  // expected-warning {{redundant cast to 'Int' has no effect}} {{12-19=}}
+
+typealias Double1 = Double
+typealias Double2 = Double
+
+let sr11295ta1: Double1 = 1.0
+_ = sr11295ta1 as Double2 // expected-warning {{redundant cast from 'Double1' (aka 'Double') to 'Double2' (aka 'Double') has no effect}} {{16-27=}}
+_ = sr11295ta1 as Double1 // expected-warning {{redundant cast to 'Double1' (aka 'Double') has no effect}} {{16-27=}}
+
+func ff11295_0<T>(_ t: T) -> T { return t }
+func ff11295_1(_ i: Int) -> Int { return i }
+
+// Function call expressions
+_ = ff11295_0(1 as Int) as Int // expected-warning {{redundant cast to 'Int' has no effect}} {{25-32=}}
+_ = ff11295_1(1) as Int // expected-warning {{redundant cast to 'Int' has no effect}} {{18-25=}}
+
+func ff11295_3(i: Int) {
+  let a: [Int] = []
+  _ = a.count - ((i + 1) as Int) // Ok
+}
+
+struct SR11295C {
+  var i: Int 
+}
+struct SR11295D<T> {
+  var t: T 
+
+  func f() -> T { return t }
+}
+enum SR11295_E: Int {
+  case a
+}
+
+// Coerce members
+_ = SR11295C(i: 1).i as Int // expected-warning {{redundant cast to 'Int' has no effect}} {{22-29=}}
+_ = SR11295D<Int>(t: 1).t as Int // expected-warning {{redundant cast to 'Int' has no effect}} {{27-34=}}
+_ = SR11295D(t: 1 as Int).t as Int // expected-warning {{redundant cast to 'Int' has no effect}} {{29-36=}}
+_ = SR11295D(t: 1).t as Int // Ok
+_ = SR11295D(t: 1).t as UInt // Ok
+_ = SR11295_E.a.rawValue as Int // expected-warning {{redundant cast to 'Int' has no effect}} {{26-33=}}
+_ = SR11295D(t: 1 as Int).f() as Int // expected-warning {{redundant cast to 'Int' has no effect}} {{31-38=}}
+_ = SR11295D(t: 1).f() as Int // Ok
+
+// Overload decl expr
+func f11295_Overload(a: Int, b: Int) -> Int { }
+func f11295_Overload(c: Double, d: Double) -> Double { }
+
+_ = (f11295_Overload as (Int, Int) -> Int)(0, 0)
+_ = (f11295_Overload as (Double, Double) -> Double)(0, 0)
+
+_ = (1 - 2 / 3 * 6) as UInt
+_ = 1/4 as Float > 3/2 as Float // Ok
+_ = 1/4 as Int > 3/2 as Int // Ok
+
+// Special cases where the coerced expression type is inferred by context.
+
+var f11295: (Float) -> Float = { $0 as Float } // expected-warning {{redundant cast to 'Float' has no effect}} {{37-46=}}
+var f11295_1 = { $0 as Float } // Ok
+
+func ff11295() -> (Int) -> Int {
+  return { $0 as Int } // expected-warning {{redundant cast to 'Int' has no effect}} {{15-22=}}
+}
+
+func f11295t_2<A: Hashable, R>(f: @escaping ((A) -> R, A) -> R) {}
+
+f11295t_2 { (f, n) in
+  n < 2 ? n : 0 // Ok
+}
+
+f11295t_2 { (f, n) in
+  n < 2 ? n as Int: 0 // Ok
+}
+
+f11295t_2 { (_, n) in
+  _ = n as Int // Ok
+}
+
+f11295t_2 { (f, n: Int) in
+  n < 2 ? n as Int : 0 // expected-warning {{redundant cast to 'Int' has no effect}} {{13-20=}}
+}
+
+f11295t_2 { (_, n) in
+  _ = SR11295D(t: n as Int).t as Int // expected-warning {{redundant cast to 'Int' has no effect}} {{31-38=}}
+}
+
+f11295t_2 { (_, n) in
+  _ = SR11295D(t: n).t as Int // Ok
+}
+
+func ff11295_g<T>(_ v: T) {
+  let _ = { v as T } // expected-warning {{redundant cast to 'T' has no effect}} {{15-20=}}
+} 
+
+func ff11295_g1(_ v: Int) { 
+  let _ = { v as Int } // expected-warning {{redundant cast to 'Int' has no effect}} {{15-22=}}
+}
+
+func ff11295_g2<T>(_ v: T) {
+  let _ = { $0 as T } // Ok
+} 
+
+func ff11295_g2<T>(_ v: T) -> (T) -> T {
+  let _ : (T) -> T = { $0 as T } // expected-warning {{redundant cast to 'T' has no effect}} {{27-32=}}
+  return { $0 as T } // expected-warning {{redundant cast to 'T' has no effect}} {{15-20=}}
+} 
+
+func ff11295_g3(_ v: Int) { 
+  let _ = { $0 as Int } // Ok
+}
+
+func ff11295_g4<T>(_ v: T) {
+  let c = v as T // expected-warning {{redundant cast to 'T' has no effect}} {{13-18=}}
+  let _ = { c as T } // expected-warning {{redundant cast to 'T' has no effect}} {{15-20=}}
+}
+
+func ff11295_g5<T>(_ v: T) {
+  // Nested closures
+  let _ = { { { $0 as T } } } // Ok
+  let _ = { { { v as T } } } // expected-warning {{redundant cast to 'T' has no effect}} {{19-24=}}
+}
+
+func ff11295_6(_ i: Int) -> Int { i }
+func ff11295_g6<T>(_ i: T) -> T { i }
+
+let _ = { ff11295_g6($0 as Int) } // Ok
+
+let _ = { ff11295_6($0) } // Ok
+
+let _ = { ff11295_6($0 as Int) } // Ok
+
+// A similar test case comming from validation-test/Sema/type_checker_perf/fast/rdar17077404.swift
+func f11295_3<A: Hashable, R>(
+  f: @escaping ((A) -> R, A) -> R
+) -> ((A) -> R) {
+  return { (a: A) -> R in
+    let r: R! 
+    return r
+  }
+}
+
+_ = f11295_3 { 
+  (f, n) in
+  f(n as Int) as Int // OK
+}
+
+_ = f11295_3 {
+  (f, n) in
+  n < 2 ? n as Int : f(n - 1) + f(n - 2) // OK 
+}

test/expr/postfix/dot/dot_keywords.swift

@@ -68,7 +68,7 @@ class ClassWithDeinitFunc {
 let instanceWithDeinitFunc = ClassWithDeinitFunc()
 instanceWithDeinitFunc.deinit()
 _ = instanceWithDeinitFunc.deinit(a:)
-_ = instanceWithDeinitFunc.deinit as () -> Void
+_ = instanceWithDeinitFunc.deinit as () -> Void // expected-warning {{redundant cast to '() -> Void' has no effect}} {{35-49=}}
 SR3043Derived.deinit() // expected-error {{deinitializers cannot be accessed}}
 
 class ClassWithDeinitMember {

test/expr/primary/selector/fixits.swift

@@ -4,24 +4,24 @@
 // RUN: %empty-directory(%t.overlays)
 
 // FIXME: BEGIN -enable-source-import hackaround
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-module -o %t.overlays %clang-importer-sdk-path/swift-modules/ObjectiveC.swift -disable-objc-attr-requires-foundation-module
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-module -o %t.overlays %clang-importer-sdk-path/swift-modules/CoreGraphics.swift
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-module -o %t.overlays %clang-importer-sdk-path/swift-modules/Foundation.swift
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-module -o %t.overlays %clang-importer-sdk-path/swift-modules/ObjectiveC.swift -disable-objc-attr-requires-foundation-module -disable-redundant-coercion-warning
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-module -o %t.overlays %clang-importer-sdk-path/swift-modules/CoreGraphics.swift -disable-redundant-coercion-warning
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-module -o %t.overlays %clang-importer-sdk-path/swift-modules/Foundation.swift -disable-redundant-coercion-warning
 // FIXME: END -enable-source-import hackaround
 
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-module -o %t.overlays %S/Inputs/fixits_helper.swift -module-name Helper
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-module -o %t.overlays %S/Inputs/fixits_helper.swift -module-name Helper -disable-redundant-coercion-warning
 
 // Make sure we get the right diagnostics.
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t.overlays) -typecheck %s -verify
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t.overlays) -disable-redundant-coercion-warning -typecheck %s -verify 
 
 // Copy the source, apply the Fix-Its, and compile it again, making
 // sure that we've cleaned up all of the deprecation warnings.
 // RUN: %empty-directory(%t.sources)
 // RUN: %empty-directory(%t.remapping)
 // RUN: cp %s %t.sources/fixits.swift
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t.overlays) -typecheck %t.sources/fixits.swift -fixit-all -emit-fixits-path %t.remapping/fixits.remap
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t.overlays) -disable-redundant-coercion-warning -typecheck %t.sources/fixits.swift -fixit-all -emit-fixits-path %t.remapping/fixits.remap
 // RUN: %{python} %utils/apply-fixit-edits.py %t.remapping
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t.overlays) -typecheck %t.sources/fixits.swift 2> %t.result
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t.overlays) -disable-redundant-coercion-warning -typecheck %t.sources/fixits.swift 2> %t.result
 
 // RUN: %FileCheck %s < %t.result
 // RUN: grep -c "warning:" %t.result | grep 3
@@ -55,7 +55,6 @@ func testDeprecatedStringLiteralSelector() {
   // We don't need coercion here because we get the right selector
   // from the static method.
   _ = "staticOrNonStatic:" as Selector // expected-warning{{use of string literal for Objective-C selectors is deprecated; use '#selector' instead}}{{7-39=#selector(Bar.staticOrNonStatic(_:))}}
-
   // We need coercion here because we asked for a selector from an
   // instance method with the same name as (but a different selector
   // from) a static method.

test/type/infer/local_variables.swift

@@ -30,6 +30,6 @@ func infer_generic_args() {
 
   // Function types
   let f : (Dictionary) -> Array = dict_to_array
-  _ = f(d) as [(String, Int)]
+  _ = f(d) as [(String, Int)] // expected-warning {{redundant cast to '[(String, Int)]' has no effect}} {{12-31=}}
 }
 

test/type/subclass_composition.swift

@@ -126,8 +126,8 @@ func basicSubtyping(
   let _: Derived & AnyObject = derived
 
   let _ = base as Base<Int> & P1
-  let _ = base as Base<Int> & AnyObject
-  let _ = derived as Derived & AnyObject
+  let _ = base as Base<Int> & AnyObject // expected-warning {{redundant cast to 'Base<Int>' has no effect}} {{16-41=}}
+  let _ = derived as Derived & AnyObject // expected-warning {{redundant cast to 'Derived' has no effect}} {{19-42=}}
 
   let _ = base as? Base<Int> & P1 // expected-warning {{always succeeds}}
   let _ = base as? Base<Int> & AnyObject // expected-warning {{always succeeds}}
@@ -170,7 +170,7 @@ func basicSubtyping(
   let _ = baseAndP1 as Base<Int>
   let _ = derivedAndP3 as Base<Int>
   let _ = derivedAndP2 as Derived
-  let _ = derivedAndAnyObject as Derived
+  let _ = derivedAndAnyObject as Derived // expected-warning {{redundant cast to 'Derived' has no effect}} {{31-42=}}
 
   let _ = baseAndP1 as? Base<Int> // expected-warning {{always succeeds}}
   let _ = derivedAndP3 as? Base<Int> // expected-warning {{always succeeds}}
@@ -343,8 +343,8 @@ func metatypeSubtyping(
 
   let _ = baseIntAndP2 as Base<Int>.Type
   let _ = baseIntAndP2AndAnyObject as Base<Int>.Type
-  let _ = derivedAndAnyObject as Derived.Type
-  let _ = baseIntAndP2AndAnyObject as BaseAndP2<Int>.Type
+  let _ = derivedAndAnyObject as Derived.Type // expected-warning {{redundant cast to 'Derived.Type' has no effect}} {{31-47=}}
+  let _ = baseIntAndP2AndAnyObject as BaseAndP2<Int>.Type // expected-warning {{redundant cast to 'BaseAndP2<Int>.Type' (aka '(Base<Int> & P2).Type') has no effect}} {{36-59=}}
 
   let _ = baseIntAndP2 as? Base<Int>.Type // expected-warning {{always succeeds}}
   let _ = baseIntAndP2AndAnyObject as? Base<Int>.Type // expected-warning {{always succeeds}}