Fix warnings in top level statements

Author: Brian King

test/ClangImporter/blocks_parse.swift

@@ -32,7 +32,7 @@ func checkTypeImpl<T>(_ a: inout T, _: T.Type) {}
 do {
   var blockOpt = blockWithoutNullability()
   checkTypeImpl(&blockOpt, Optional<my_block_t>.self)
-  var block: my_block_t = blockWithoutNullability()
+  var _: my_block_t = blockWithoutNullability()
 }
 do {
   var block = blockWithNonnull()
@@ -41,7 +41,7 @@ do {
 do {
   var blockOpt = blockWithNullUnspecified()
   checkTypeImpl(&blockOpt, Optional<my_block_t>.self)
-  var block: my_block_t = blockWithNullUnspecified()
+  var _: my_block_t = blockWithNullUnspecified()
 }
 do {
   var block = blockWithNullable()

test/Constraints/operator.swift

@@ -6,7 +6,7 @@ do {
   let a: String? = "a"
   let b: String? = "b"
   let c: String? = "c"
-  let d: String? = a! + b! + c!
+  let _: String? = a! + b! + c!
 
   let x: Double = 1
   _ = x + x + x

test/Parse/brace_recovery_eof.swift

@@ -2,5 +2,5 @@
 
 // Make sure source ranges satisfy the verifier.
 for foo in [1, 2] { // expected-note {{to match this opening '{'}}
-  var x = foo
+  _ = foo
 // expected-error@+1{{expected '}' at end of brace statement}}

test/Parse/c_function_pointers.swift

@@ -16,36 +16,36 @@ if true {
   func localWithContext() -> Int { return x }
 
   let a: @convention(c) () -> Int = global
-  let a2: @convention(c) () -> Int = main.global
-  let b: @convention(c) () -> Int = { 0 }
-  let c: @convention(c) () -> Int = local
+  let _: @convention(c) () -> Int = main.global
+  let _: @convention(c) () -> Int = { 0 }
+  let _: @convention(c) () -> Int = local
 
   // Can't convert a closure with context to a C function pointer
-  let d: @convention(c) () -> Int = { x } // expected-error{{cannot be formed from a closure that captures context}}
-  let d2: @convention(c) () -> Int = { [x] in x } // expected-error{{cannot be formed from a closure that captures context}}
-  let e: @convention(c) () -> Int = localWithContext // expected-error{{cannot be formed from a local function that captures context}}
+  let _: @convention(c) () -> Int = { x } // expected-error{{cannot be formed from a closure that captures context}}
+  let _: @convention(c) () -> Int = { [x] in x } // expected-error{{cannot be formed from a closure that captures context}}
+  let _: @convention(c) () -> Int = localWithContext // expected-error{{cannot be formed from a local function that captures context}}
 
   // Can't convert a closure value to a C function pointer
   let global2 = global
-  let f: @convention(c) () -> Int = global2 // expected-error{{can only be formed from a reference to a 'func' or a literal closure}}
+  let _: @convention(c) () -> Int = global2 // expected-error{{can only be formed from a reference to a 'func' or a literal closure}}
   let globalBlock: @convention(block) () -> Int = global
-  let g: @convention(c) () -> Int = globalBlock // expected-error{{can only be formed from a reference to a 'func' or a literal closure}}
+  let _: @convention(c) () -> Int = globalBlock // expected-error{{can only be formed from a reference to a 'func' or a literal closure}}
 
   // Can convert a function pointer to a block or closure, or assign to another
   // C function pointer
-  let h: @convention(c) () -> Int = a
-  let i: @convention(block) () -> Int = a
-  let j: () -> Int = a
+  let _: @convention(c) () -> Int = a
+  let _: @convention(block) () -> Int = a
+  let _: () -> Int = a
 
   // Can't convert a C function pointer from a method.
   // TODO: Could handle static methods.
-  let k: @convention(c) () -> Int = S.staticMethod // expected-error{{}}
-  let m: @convention(c) () -> Int = C.staticMethod // expected-error{{}}
-  let n: @convention(c) () -> Int = C.classMethod // expected-error{{}}
+  let _: @convention(c) () -> Int = S.staticMethod // expected-error{{}}
+  let _: @convention(c) () -> Int = C.staticMethod // expected-error{{}}
+  let _: @convention(c) () -> Int = C.classMethod // expected-error{{}}
 
   // <rdar://problem/22181714> Crash when typing "signal"
   let iuo_global: (() -> Int)! = global
-  let p: (@convention(c) () -> Int)! = iuo_global // expected-error{{a C function pointer can only be formed from a reference to a 'func' or a literal closure}}
+  let _: (@convention(c) () -> Int)! = iuo_global // expected-error{{a C function pointer can only be formed from a reference to a 'func' or a literal closure}}
 
   func handler(_ callback: (@convention(c) () -> Int)!) {}
   handler(iuo_global) // expected-error{{a C function pointer can only be formed from a reference to a 'func' or a literal closure}}

test/decl/func/throwing_functions_without_try.swift

@@ -22,7 +22,7 @@ doLazy(foo())
 
 // It doesn't include explicit closures.
 var closure: () -> () = {
-  var x = foo() // expected-error {{call can throw, but it is not marked with 'try' and the error is not handled}}
+  _ = foo() // expected-error {{call can throw, but it is not marked with 'try' and the error is not handled}}
   doLazy(foo()) // expected-error {{call can throw but is not marked with 'try'}}
 }
 

test/decl/var/usage.swift

@@ -252,3 +252,19 @@ func test2() {
   var c: Int = 4 // expected-warning {{variable 'c' was never used; consider replacing with '_' or removing it}} {{7-8=_}}
   let (d): Int = 9 // expected-warning {{immutable value 'd' was never used; consider replacing with '_' or removing it}} {{8-9=_}}
 }
+
+for i in 0..<10 { // expected-warning {{immutable value 'i' was never used; consider replacing with '_' or removing it}} {{5-6=_}}
+   print("")
+}
+
+// Due to the complexities of global variable tracing, these will not generate warnings
+let unusedVariable = ""
+var unNeededVar = false
+if unNeededVar {}
+
+let optionalString: String? = "check"
+if let string = optionalString {}  // expected-warning {{value 'string' was defined but never used; consider replacing with boolean test}} {{4-17=}} {{31-31= != nil}}
+
+let optionalAny: Any? = "check"
+if let string = optionalAny as? String {} // expected-warning {{value 'string' was defined but never used; consider replacing with boolean test}} {{4-17=(}} {{39-39=) != nil}}
+

test/expr/cast/dictionary_downcast.swift

@@ -29,17 +29,17 @@ var dictDC = dictCC as! Dictionary<D, C>
 var dictDD = dictCC as! Dictionary<D, D>
 
 // Test dictionary conditional downcasts
-if let dictCD = dictCC as? Dictionary<C, D> { }
-if let dictDC = dictCC as? Dictionary<D, C> { }
-if let dictDD = dictCC as? Dictionary<D, D> { }
+if let _ = dictCC as? Dictionary<C, D> { }
+if let _ = dictCC as? Dictionary<D, C> { }
+if let _ = dictCC as? Dictionary<D, D> { }
 
 // Test dictionary downcasts to unrelated types.
 dictCC as Dictionary<D, U> // expected-error{{cannot convert value of type 'Dictionary<C, C>' to type 'Dictionary<D, U>' in coercion}}
 dictCC as Dictionary<U, D> // expected-error{{cannot convert value of type 'Dictionary<C, C>' to type 'Dictionary<U, D>' in coercion}}
 dictCC as Dictionary<U, U> // expected-error{{cannot convert value of type 'Dictionary<C, C>' to type 'Dictionary<U, U>' in coercion}}
 
 // Test dictionary conditional downcasts to unrelated types
-if let dictDU = dictCC as? Dictionary<D, U> { } // expected-warning{{cast from 'Dictionary<C, C>' to unrelated type 'Dictionary<D, U>' always fails}}
-if let dictUD = dictCC as? Dictionary<U, D> { } // expected-warning{{cast from 'Dictionary<C, C>' to unrelated type 'Dictionary<U, D>' always fails}}
-if let dictUU = dictCC as? Dictionary<U, U> { } // expected-warning{{cast from 'Dictionary<C, C>' to unrelated type 'Dictionary<U, U>' always fails}}
+if let _ = dictCC as? Dictionary<D, U> { } // expected-warning{{cast from 'Dictionary<C, C>' to unrelated type 'Dictionary<D, U>' always fails}}
+if let _ = dictCC as? Dictionary<U, D> { } // expected-warning{{cast from 'Dictionary<C, C>' to unrelated type 'Dictionary<U, D>' always fails}}
+if let _ = dictCC as? Dictionary<U, U> { } // expected-warning{{cast from 'Dictionary<C, C>' to unrelated type 'Dictionary<U, U>' always fails}}
 

test/expr/cast/set_downcast.swift

@@ -29,10 +29,10 @@ var setD = Set<D>()
 setD = setC as! Set<D>
 
 // Test set conditional downcasts
-if let setD = setC as? Set<D> { }
+if let _ = setC as? Set<D> { }
 
 // Test set downcasts to unrelated types.
 _ = setC as! Set<U> // expected-warning{{cast from 'Set<C>' to unrelated type 'Set<U>' always fails}}
 
 // Test set conditional downcasts to unrelated types
-if let setU = setC as? Set<U> { } // expected-warning{{cast from 'Set<C>' to unrelated type 'Set<U>' always fails}}
+if let _ = setC as? Set<U> { } // expected-warning{{cast from 'Set<C>' to unrelated type 'Set<U>' always fails}}