omit_return.swift

// RUN: %target-swift-frontend %s -typecheck -verify

// MARK: - Helpers



@discardableResult
func logAndReturn<T :CustomStringConvertible>(_ t:T)->String{
letlog="\(t)"
print(log)
return log
}

@discardableResult
func failableLogAndReturn<T :CustomStringConvertible>(_ t:T)throws->String{
letlog="\(t)"
print(log)
return log
}


typealiasMyOwnVoid=()

func failableIdentity<T>(_ t:T)throws->T{ t }

enumMyOwnNever{}

func myOwnFatalError()->MyOwnNever{fatalError()}

structMyOwnInt:ExpressibleByIntegerLiteral{init(integerLiteral:Int){}}
structMyOwnFloat:ExpressibleByFloatLiteral{init(floatLiteral:Double){}}
structMyOwnBoolean:ExpressibleByBooleanLiteral{init(booleanLiteral:Bool){}}
structMyOwnString:ExpressibleByStringLiteral{init(stringLiteral:String){}}
structMyOwnInterpolation:ExpressibleByStringInterpolation{init(stringLiteral:String){}}

enumUnit{
case only
}

structInitable{}

structStructWithProperty{
varfoo:Int
}

@dynamicMemberLookup
structDynamicStruct{
 subscript(dynamicMember input:String)->String{return input }
}

structMyOwnArray<Element>:ExpressibleByArrayLiteral{
init(arrayLiteral elements:Element...){}
}

structMyOwnDictionary<Key, Value>:ExpressibleByDictionaryLiteral{
init(dictionaryLiteral elements:(Key,Value)...){}
}

structSubscriptableStruct{
 subscript(int:Int)->Int{ int }
}

extensionInt{
varzero:Int{0}
}

extensionOptionalwhere Wrapped ==Int{
varsomeZero:Int?{.some(0)}
}

protocolSomeProto{
func foo()->String
}

structSomeProtoConformer:SomeProto{
func foo()->String{"howdy"}
}

classBase{}
classDerived:Base{}

extensionInt{
init(){self=0}
}


// MARK: - Notable Free Functions



func identity<T>(_ t:T)->T{ t }

internalfunc _fatalErrorFlags()->UInt32{
return0
}
internalfunc _assertionFailure(
 _ prefix:StaticString, _ message:String,
 flags:UInt32
)->Never{
fatalError()
}
internalfunc _diagnoseUnexpectedEnumCaseValue<SwitchedValue, RawValue>(
 type:SwitchedValue.Type,
 rawValue:RawValue
)->Never{
_assertionFailure("Fatal error",
"unexpected enum case '\(type)(rawValue: \(rawValue))'",
 flags:_fatalErrorFlags())
}


// MARK: - Free Functions



func ff_nop(){
}

func ff_missing()->String{
}

func ff_implicit()->String{
"hello"
}

func ff_explicit()->String{
return"hello"
}

func ff_explicitClosure()->()->Void{
return{print("howdy")}
}

func ff_implicitClosure()->()->Void{
{print("howdy")}
}

func ff_explicitMultilineClosure()->()->String{
return{
letone="big a"
lettwo="little a"
return"\(one) + \(two)"
}
}

func ff_implicitMultilineClosure()->()->String{
{
letone="big a"
lettwo="little a"
return"\(one) + \(two)"
}
}

func ff_implicitWrong()->String{
17 // expected-error {{cannot convert return expression of type 'Int' to return type 'String'}}
}

func ff_explicitWrong()->String{
return17 // expected-error {{cannot convert return expression of type 'Int' to return type 'String'}}
}

func ff_implicitMulti()->String{
print("uh oh")
"shucks howdy" // expected-warning {{string literal is unused}}
}

func ff_explicitMulti()->String{
print("okay")
return"all right"
}

func ff_effectfulUsed()->String{
logAndReturn("okay")
}

// Unused Returns

func ff_effectfulIgnored(){
logAndReturn("okay")
}

func ff_effectfulIgnoredExplicitReturnTypeVoid()->Void{
logAndReturn("okay")
}

func ff_effectfulIgnoredExplicitReturnTypeSwiftVoid()->Swift.Void{
logAndReturn("okay")
}

func ff_effectfulIgnoredExplicitReturnTypeMyVoidTypealias()->MyOwnVoid{
logAndReturn("okay")
}

func ff_effectfulIgnoredExplicitReturnTypeEmptyTuple()->(){
logAndReturn("okay")
}

// Stubs

func ff_stubImplicitReturn(){
fatalError()
}

func ff_stubExplicitReturnTypeVoid()->Void{
fatalError()
}

func ff_stubExplicitReturnTypeSwiftVoid()->Swift.Void{
fatalError()
}

func ff_stubExplicitReturnTypeMyVoidTypealias()->MyOwnVoid{
fatalError()
}

func ff_stubExplicitReturnTypeEmptyTuple()->(){
fatalError()
}

func ff_stubImplicitReturnNever()->Never{
fatalError()
}

func ff_stubExplicitReturnNever()->Never{
returnfatalError()
}

func ff_stubExplicitReturnNeverAsMyOwnNever()->MyOwnNever{
returnfatalError() // expected-error {{cannot convert return expression of type 'Never' to return type 'MyOwnNever'}}
}

func ff_stubExplicitReturnMyOwnNeverAsNever()->Never{
returnmyOwnFatalError() // expected-error {{cannot convert return expression of type 'MyOwnNever' to return type 'Never'}}
}

func ff_stubImplicitReturnNeverAsMyOwnNever()->MyOwnNever{
fatalError()
}

func ff_stubImplicitReturnMyOwnNeverAsNever()->Never{
myOwnFatalError()
}

func ff_stubReturnString()->String{
fatalError()
}

func ff_stubReturnGeneric<T>()->T{
fatalError()
}

// Trying

func ff_tryExplicit()throws->String{
returntryfailableIdentity("shucks")
}

func ff_tryImplicit()throws->String{
tryfailableIdentity("howdy")
}

func ff_tryExplicitMissingThrows()->String{
returntryfailableIdentity("shucks") // expected-error {{errors thrown from here are not handled}}
}

func ff_tryImplicitMissingThrows()->String{
tryfailableIdentity("howdy") // expected-error {{errors thrown from here are not handled}}
}

// Forced Trying

func ff_forceTryExplicit()->String{
returntry!failableIdentity("howdy")
}

func ff_forceTryImplicit()->String{
try!failableIdentity("shucks")
}

func ff_forceTryExplicitAddingThrows()throws->String{
returntry!failableIdentity("howdy")
}

func ff_forceTryImplicitAddingThrows()throws->String{
try!failableIdentity("shucks")
}

// Optional Trying

func ff_optionalTryExplicit()->String?{
returntry?failableIdentity("howdy")
}

func ff_optionalTryImplicit()->String?{
try?failableIdentity("shucks")
}

func ff_optionalTryExplicitAddingThrows()throws->String?{
returntry?failableIdentity("shucks")
}

func ff_optionalTryImplicitAddingThrows()throws->String?{
try?failableIdentity("howdy")
}

// Inferred Return Types

func ff_inferredIntegerLiteralInt()->Int{
0
}

func ff_inferredIntegerLiteralInt8()->Int8{
0
}

func ff_inferredIntegerLiteralInt16()->Int16{
0
}

func ff_inferredIntegerLiteralInt32()->Int32{
0
}

func ff_inferredIntegerLiteralInt64()->Int64{
0
}

func ff_inferredIntegerLiteralMyOwnInt()->MyOwnInt{
0
}

func ff_nilLiteralInt()->Int?{
nil
}

func ff_inferredFloatLiteralFloat()->Float{
0.0
}

func ff_inferredFloatLiteralDouble()->Double{
0.0
}

func ff_inferredFloatLiteralMyOwnDouble()->MyOwnFloat{
0.0
}

func ff_inferredBooleanLiteralBool()->Bool{
true
}

func ff_inferredBooleanLiteralMyOwnBoolean()->MyOwnBoolean{
true
}

func ff_inferredStringLiteralString()->String{
"howdy"
}

func ff_inferredStringLiteralMyOwnString()->MyOwnString{
"howdy"
}

func ff_inferredInterpolatedStringLiteralString()->String{
"\(0)\(1)"
}

func ff_inferredInterpolatedStringLiteralString()->MyOwnInterpolation{
"\(0)\(1)"
}

func ff_inferredMagicFile()->StaticString{
 #file
}

func ff_inferredMagicLine()->UInt{
 #line // expected-error {{#line directive was renamed to #sourceLocation}}
} // expected-error {{parameterless closing #sourceLocation() directive without prior opening #sourceLocation(file:,line:) directive}}

func ff_inferredMagicColumn()->UInt{
 #column
}

func ff_inferredMagicFunction()->StaticString{
 #function
}

func ff_inferredMagicDSOHandle()->UnsafeRawPointer{
 #dsohandle
}

func ff_implicitDiscardExpr(){
 _ =3
}

func ff_implicitMetatype()->String.Type{
String.self
}

func ff_implicitMemberRef(_ instance:StructWithProperty)->Int{
 instance.foo
}

func ff_implicitDynamicMember(_ s:DynamicStruct)->String{
 s.foo
}

func ff_implicitParenExpr()->Int{
(3+5)
}

func ff_implicitTupleExpr()->(Int,Int){
(3,5)
}

func ff_implicitArrayExprArray()->[Int]{
[1,3,5]
}

func ff_implicitArrayExprSet()->Set<Int>{
[1,3,5]
}

func ff_implicitArrayExprMyOwnArray()->MyOwnArray<Int>{
[1,3,5]
}

func ff_implicitDictionaryExprDictionary()->[Int:Int]{
[1:1,2:2]
}

func ff_implicitDictionaryExprMyOwnDictionary()->MyOwnDictionary<Int,Int>{
[1:1,2:2]
}

func ff_implicitSubscriptExpr(_ s:SubscriptableStruct)->Int{
s[13]
}

func ff_implicitKeyPathExprWritableKeyPath()->WritableKeyPath<Int,Int>{
 \Int.self
}

func ff_implicitKeyPathExprKeyPath()->WritableKeyPath<Int,Int>{
 \Int.self.self
}

func ff_implicitTupleElementExpr()->Int{
(1,field:2).field
}

func ff_implicitBindExpr(_ opt:Int?)->Int?{
 opt?.zero
}

func ff_implicitOptionalEvaluation(_ opt:Int?)->Int?{
(opt?.zero.zero).someZero
}

func ff_implicitForceValue(_ opt:Int?)->Int{
 opt!
}

func ff_implicitTemporarilyEscapableExpr(_ cl:()->Void)->()->Void{
withoutActuallyEscaping(cl){ $0 }
}

func ff_implicitOpenExistentialExpr(_ f:SomeProto)->String{
 f.foo()
}

func ff_implicitInjectIntoOptionalExpr(_ int:Int)->Int?{
 int
}

func ff_implicitTupleShuffle(_ input:(one:Int, two:Int))->(two:Int, one:Int){
 input // expected-warning {{expression shuffles the elements of this tuple; this behavior is deprecated}}
}

func ff_implicitCollectionUpcast(_ derived:[Derived])->[Base]{
 derived
}

func ff_implicitErasureExpr(_ conformer:SomeProtoConformer)->SomeProto{
 conformer
}

func ff_implicitAnyHashableErasureExpr(_ int:Int)->AnyHashable{
 int
}

func ff_implicitCallExpr<Input, Output>(input:Input, function:(Input)->Output)->Output{
function(input)
}

func ff_implicitPrefixUnaryOperator(int:Int)->Int{
-int
}

func ff_implicitBinaryOperator(lhs:Int, rhs:Int)->Int{
 lhs - rhs
}

func ff_implicitConstructorCallRefExpr(lhs:Int, rhs:Int)->Int{
Int()
}

func ff_implicitIsExpr<T>(t:T)->Bool{
 t is Int
}

func ff_implicitCoerceExpr<T>()->T.Type{
T.self asT.Type
}

func ff_implicitConditionalCheckedCastExprAs<T>(t:T)->Int?{
 t as?Int
}

func ff_implicitForceCheckedCastExpr<T>(t:T)->Int{
 t as!Int
}

func ff_conditional(_ condition:Bool)->Int{
 condition ?1:-1
}

var__ff_implicitAssignExpr:Int=0
func ff_implicitAssignExpr(newValue:Int)->Void{
 __ff_implicitAssignExpr = newValue
}

func ff_implicitMemberAccessInit()->Initable{
.init()
}

func ff_implicitMemberAccessEnumCase()->Unit{
.only
}



// MARK: - Free Properties : Implicit Get



varfv_nop:(){
} // missing return expectations moved to `SILOptimizer/missing_returns`

varfv_missing:String{
} // missing return expectations moved to `SILOptimizer/missing_returns`

varfv_implicit:String{
"hello"
}

varfv_explicit:String{
return"hello"
}

varfv_explicitClosure:()->Void{
return{print("howdy")}
}

varfv_implicitClosure:()->Void{
{print("howdy")}
}

varfv_explicitMultilineClosure:()->String{
return{
letone="big a"
lettwo="little a"
return"\(one) + \(two)"
}
}

varfv_implicitMultilineClosure:()->String{
{
letone="big a"
lettwo="little a"
return"\(one) + \(two)"
}
}

varfv_implicitWrong:String{
17 // expected-error {{cannot convert return expression of type 'Int' to return type 'String'}}
}

varfv_explicitWrong:String{
return17 // expected-error {{cannot convert return expression of type 'Int' to return type 'String'}}
}

varfv_implicitMulti:String{
print("uh oh")
"shucks howdy" // expected-warning {{string literal is unused}}
}

varfv_explicitMulti:String{
print("okay")
return"all right"
}

varfv_effectfulUsed:String{
logAndReturn("okay")
}

// Unused returns

varfv_effectfulIgnored:(){
logAndReturn("okay")
}

varfv_effectfulIgnoredVoid:Void{
logAndReturn("okay")
}

varfv_effectfulIgnoredSwiftVoid:Swift.Void{
logAndReturn("okay")
}

// Stubs

varfv_stubEmptyTuple:(){
fatalError()
}

varfv_stubVoid:Void{
fatalError()
}

varfv_stubSwiftVoid:Swift.Void{
fatalError()
}

varfv_stubMyVoidTypealias:MyOwnVoid{
fatalError()
}

varfv_stubImplicitReturnNever:Never{
fatalError()
}

varfv_stubExplicitReturnNever:Never{
returnfatalError()
}

varfv_stubExplicitReturnNeverAsMyOwnNever:MyOwnNever{
returnfatalError() // expected-error {{cannot convert return expression of type 'Never' to return type 'MyOwnNever'}}
}

varfv_stubExplicitReturnMyOwnNeverAsNever:Never{
returnmyOwnFatalError() // expected-error {{cannot convert return expression of type 'MyOwnNever' to return type 'Never'}}
}

varfv_stubImplicitReturnNeverAsMyOwnNever:MyOwnNever{
fatalError()
}

varfv_stubImplicitReturnMyOwnNeverAsNever:Never{
myOwnFatalError()
}

varfv_stubString:String{
fatalError()
}

// Forced Trying

varfv_forceTryUnusedExplicit:(){
returntry!failableLogAndReturn("oh") //expected-error {{unexpected non-void return value in void function}}
}

varfv_forceTryUnusedImplicit:(){
try!failableLogAndReturn("uh")
}

varfv_forceTryExplicit:String{
returntry!failableIdentity("shucks")
}

varfv_forceTryImplicit:String{
try!failableIdentity("howdy")
}

// Optional Trying

varfv_optionalTryUnusedExplicit:(){
returntry?failableLogAndReturn("uh") //expected-error {{unexpected non-void return value in void function}}
}

varfv_optionalTryUnusedImplicit:(){
try?failableLogAndReturn("oh") //expected-warning {{result of 'try?' is unused}}
}

varfv_optionalTryExplicit:String?{
returntry?failableIdentity("shucks")
}

varfv_optionalTryImplicit:String?{
try?failableIdentity("howdy")
}



// MARK: - Free Properties : Get



varfvg_nop:(){
get{
}
}

varfvg_missing:String{
get{
}
}

varfvg_implicit:String{
get{
"hello"
}
}

varfvg_explicit:String{
get{
return"hello"
}
}

varfvg_explicitClosure:()->Void{
get{
return{print("howdy")}
}
}

varfvg_implicitClosure:()->Void{
get{
{print("howdy")}
}
}

varfvg_explicitMultilineClosure:()->String{
get{
return{
letone="big a"
lettwo="little a"
return"\(one) + \(two)"
}
}
}

varfvg_implicitMultilineClosure:()->String{
get{
{
letone="big a"
lettwo="little a"
return"\(one) + \(two)"
}
}
}

varfvg_implicitWrong:String{
get{
17 // expected-error {{cannot convert return expression of type 'Int' to return type 'String'}}
}
}

varfvg_explicitWrong:String{
get{
return17 // expected-error {{cannot convert return expression of type 'Int' to return type 'String'}}
}
}

varfvg_implicitMulti:String{
get{
print("uh oh")
"shucks howdy" // expected-warning {{string literal is unused}}
}
}

varfvg_explicitMulti:String{
get{
print("okay")
return"all right"
}
}

varfvg_effectfulUsed:String{
get{
logAndReturn("okay")
}
}

// Unused returns

varfvg_effectfulIgnored:(){
get{
logAndReturn("okay")
}
}

varfvg_effectfulIgnoredVoid:Void{
get{
logAndReturn("okay")
}
}

varfvg_effectfulIgnoredSwiftVoid:Swift.Void{
get{
logAndReturn("okay")
}
}

// Stubs

varfvg_stubEmptyTuple:(){
get{
fatalError()
}
}

varfvg_stubVoid:Void{
get{
fatalError()
}
}

varfvg_stubSwiftVoid:Swift.Void{
get{
fatalError()
}
}

varfvg_stubMyVoidTypealias:MyOwnVoid{
get{
fatalError()
}
}

varfvg_stubImplicitReturnNever:Never{
get{
fatalError()
}
}

varfvg_stubExplicitReturnNever:Never{
get{
returnfatalError()
}
}

varfvg_stubExplicitReturnNeverAsMyOwnNever:MyOwnNever{
get{
returnfatalError() // expected-error {{cannot convert return expression of type 'Never' to return type 'MyOwnNever'}}
}
}

varfvg_stubExplicitReturnMyOwnNeverAsNever:Never{
get{
returnmyOwnFatalError() // expected-error {{cannot convert return expression of type 'MyOwnNever' to return type 'Never'}}
}
}

varfvg_stubImplicitReturnNeverAsMyOwnNever:MyOwnNever{
get{
fatalError()
}
}

varfvg_stubImplicitReturnMyOwnNeverAsNever:Never{
get{
myOwnFatalError()
}
}

varfvg_stubString:String{
get{
fatalError()
}
}

// Forced Trying

varfvg_forceTryExplicit:String{
get{
returntry!failableIdentity("shucks")
}
}

varfvg_forceTryImplicit:String{
get{
try!failableIdentity("howdy")
}
}

// Optional Trying

varfvg_optionalTryExplicit:String?{
get{
returntry?failableIdentity("shucks")
}
}

varfvg_optionalTryImplicit:String?{
get{
try?failableIdentity("howdy")
}
}



// MARK: - Free Properties : Set



varfvs_nop:(){
get{}
set{}
}

varfvs_implicit:String{
get{"ok"}
set{
"hello" // expected-warning {{string literal is unused}} 
}
}

varfvs_explicit:String{
get{"ok"}
set{
return"hello" // expected-error {{unexpected non-void return value in void function}}
}
}

varfvs_explicitClosure:()->Void{
get{return{print("howdy")}}
set{
return{print("howdy")} // expected-error {{unexpected non-void return value in void function}}
}
}

varfvs_implicitClosure:()->Void{
get{{print("howdy")}}
set{
{print("howdy")} // expected-error {{closure expression is unused}} expected-note {{did you mean to use a 'do' statement?}}
}
}

varfvs_implicitWrong:String{
get{"ok"}
set{
17 // expected-warning {{integer literal is unused}}
}
}

varfvs_explicitWrong:String{
get{"ok"}
set{
return17 // expected-error {{unexpected non-void return value in void function}}
}
}

varfvs_implicitMulti:String{
get{"ok"}
set{
print("uh oh")
"shucks howdy" // expected-warning {{string literal is unused}}
}
}

varfvs_explicitMulti:String{
get{"ok"}
set{
print("okay")
return"all right" // expected-error {{unexpected non-void return value in void function}}
}
}

varfvs_effectfulUsed:String{
get{"ok"}
set{
logAndReturn("okay")
}
}

// Stubs

varfvs_stub:(){
get{()}
set{
fatalError()
}
}

varfvs_stubMyOwnFatalError:(){
get{()}
set{
myOwnFatalError()
}