remove redundant return after panic to keep vet happy

template.go

@@ -53,7 +53,7 @@ Fake{{.Name}} is a mock implementation of {{.Name}} for testing.
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to Fake{{.Name}}.
 {{end}}{{end}}*/
 type Fake{{.Name}} struct {
@@ -67,7 +67,6 @@ func NewFake{{.Name}}DefaultPanic() *Fake{{.Name}} {
 	return &Fake{{.Name}}{
 {{range .Methods}}		{{.Name}}Hook: func({{.ParametersSignature}}) ({{.ResultsDeclaration}}) {
 			panic("Unexpected call to {{.Interface}}.{{.Name}}")
-			return
 		},
 {{end}}
 	}

testdata/array/array.go

@@ -56,7 +56,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeArrayParameter.
 */
 type FakeArray struct {
@@ -76,19 +76,15 @@ func NewFakeArrayDefaultPanic() *FakeArray {
 	return &FakeArray{
 		ArrayParameterHook: func([3]string) {
 			panic("Unexpected call to Array.ArrayParameter")
-			return
 		},
 		ArrayReturnHook: func() (ident2 [3]string) {
 			panic("Unexpected call to Array.ArrayReturn")
-			return
 		},
 		SliceParameterHook: func([]string) {
 			panic("Unexpected call to Array.SliceParameter")
-			return
 		},
 		SliceReturnHook: func() (ident4 []string) {
 			panic("Unexpected call to Array.SliceReturn")
-			return
 		},
 	}
 }

testdata/channeler/channeler.go

@@ -78,7 +78,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeChannel.
 */
 type FakeChanneler struct {
@@ -100,23 +100,18 @@ func NewFakeChannelerDefaultPanic() *FakeChanneler {
 	return &FakeChanneler{
 		ChannelHook: func(chan int) (ident2 chan int) {
 			panic("Unexpected call to Channeler.Channel")
-			return
 		},
 		ChannelReceiveHook: func(<-chan int) (ident4 <-chan int) {
 			panic("Unexpected call to Channeler.ChannelReceive")
-			return
 		},
 		ChannelSendHook: func(chan<- int) (ident6 chan<- int) {
 			panic("Unexpected call to Channeler.ChannelSend")
-			return
 		},
 		ChannelPointerHook: func(*chan int) (ident8 *chan int) {
 			panic("Unexpected call to Channeler.ChannelPointer")
-			return
 		},
 		ChannelInterfaceHook: func(chan interface{}) (ident10 chan interface{}) {
 			panic("Unexpected call to Channeler.ChannelInterface")
-			return
 		},
 	}
 }

testdata/embedder/embedder.go

@@ -55,7 +55,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeString.
 */
 type FakeEmbedder struct {
@@ -73,15 +73,12 @@ func NewFakeEmbedderDefaultPanic() *FakeEmbedder {
 	return &FakeEmbedder{
 		StringHook: func() (ident5 string) {
 			panic("Unexpected call to Embedder.String")
-			return
 		},
 		EmbedHook: func(string) (ident9 string) {
 			panic("Unexpected call to Embedder.Embed")
-			return
 		},
 		OtherHook: func(string) (ident7 string) {
 			panic("Unexpected call to Embedder.Other")
-			return
 		},
 	}
 }

testdata/funcer/funcer.go

@@ -42,7 +42,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeFuncParameter.
 */
 type FakeFuncer struct {
@@ -58,11 +58,9 @@ func NewFakeFuncerDefaultPanic() *FakeFuncer {
 	return &FakeFuncer{
 		FuncParameterHook: func(func(string) string) {
 			panic("Unexpected call to Funcer.FuncParameter")
-			return
 		},
 		FuncReturnHook: func() (ident2 func(string) string) {
 			panic("Unexpected call to Funcer.FuncReturn")
-			return
 		},
 	}
 }

testdata/importer/importer.go

@@ -40,7 +40,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeScan.
 */
 type FakeImporter struct {
@@ -54,7 +54,6 @@ func NewFakeImporterDefaultPanic() *FakeImporter {
 	return &FakeImporter{
 		ScanHook: func(*Scanner) (ident10 z.Reader) {
 			panic("Unexpected call to Importer.Scan")
-			return
 		},
 	}
 }

testdata/interfacer/interfacer.go

@@ -48,7 +48,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeInterface.
 */
 type FakeInterfacer struct {
@@ -64,11 +64,9 @@ func NewFakeInterfacerDefaultPanic() *FakeInterfacer {
 	return &FakeInterfacer{
 		InterfaceHook: func(interface{}) (ident2 interface{}) {
 			panic("Unexpected call to Interfacer.Interface")
-			return
 		},
 		NamedInterfaceHook: func(interface{}) (z interface{}) {
 			panic("Unexpected call to Interfacer.NamedInterface")
-			return
 		},
 	}
 }

testdata/mapper/mapper.go

@@ -42,7 +42,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeMapParameter.
 */
 type FakeMapper struct {
@@ -58,11 +58,9 @@ func NewFakeMapperDefaultPanic() *FakeMapper {
 	return &FakeMapper{
 		MapParameterHook: func(map[string]string) {
 			panic("Unexpected call to Mapper.MapParameter")
-			return
 		},
 		MapReturnHook: func() (ident2 map[string]string) {
 			panic("Unexpected call to Mapper.MapReturn")
-			return
 		},
 	}
 }

testdata/multireturner/multireturner.go

@@ -45,7 +45,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeMultiReturn.
 */
 type FakeMultireturner struct {
@@ -61,11 +61,9 @@ func NewFakeMultireturnerDefaultPanic() *FakeMultireturner {
 	return &FakeMultireturner{
 		MultiReturnHook: func() (ident1 string, ident2 int) {
 			panic("Unexpected call to Multireturner.MultiReturn")
-			return
 		},
 		NamedReturnHook: func() (a int, b int, c int, d int) {
 			panic("Unexpected call to Multireturner.NamedReturn")
-			return
 		},
 	}
 }

testdata/namedvaluer/namedvaluer.go

@@ -52,7 +52,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeManyNamed.
 */
 type FakeNamedvaluer struct {
@@ -68,11 +68,9 @@ func NewFakeNamedvaluerDefaultPanic() *FakeNamedvaluer {
 	return &FakeNamedvaluer{
 		ManyNamedHook: func(string, string, int, int) (ret bool) {
 			panic("Unexpected call to Namedvaluer.ManyNamed")
-			return
 		},
 		NamedHook: func(int, string) (ret bool) {
 			panic("Unexpected call to Namedvaluer.Named")
-			return
 		},
 	}
 }

testdata/pointer/pointer.go

@@ -38,7 +38,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakePoint.
 */
 type FakePointer struct {
@@ -52,7 +52,6 @@ func NewFakePointerDefaultPanic() *FakePointer {
 	return &FakePointer{
 		PointHook: func(*string) (ident2 int) {
 			panic("Unexpected call to Pointer.Point")
-			return
 		},
 	}
 }

testdata/qualifier/qualifier.go

@@ -51,7 +51,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeQualify.
 */
 type FakeQualifier struct {
@@ -67,11 +67,9 @@ func NewFakeQualifierDefaultPanic() *FakeQualifier {
 	return &FakeQualifier{
 		QualifyHook: func(fmt.Scanner) (ident7 fmt.Scanner) {
 			panic("Unexpected call to Qualifier.Qualify")
-			return
 		},
 		NamedQualifyHook: func(fmt.Scanner, fmt.Scanner, fmt.Scanner) (d fmt.Scanner) {
 			panic("Unexpected call to Qualifier.NamedQualify")
-			return
 		},
 	}
 }

testdata/structer/structer.go

@@ -66,7 +66,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeStruct.
 */
 type FakeStructer struct {
@@ -100,7 +100,6 @@ func NewFakeStructerDefaultPanic() *FakeStructer {
 			d string
 		}) {
 			panic("Unexpected call to Structer.Struct")
-			return
 		},
 		NamedStructHook: func(struct {
 			a string
@@ -110,7 +109,6 @@ func NewFakeStructerDefaultPanic() *FakeStructer {
 			d string
 		}) {
 			panic("Unexpected call to Structer.NamedStruct")
-			return
 		},
 	}
 }

testdata/variadic/variadic.go

@@ -45,7 +45,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeSingleVariadic.
 */
 type FakeVariadic struct {
@@ -61,11 +61,9 @@ func NewFakeVariadicDefaultPanic() *FakeVariadic {
 	return &FakeVariadic{
 		SingleVariadicHook: func(...string) {
 			panic("Unexpected call to Variadic.SingleVariadic")
-			return
 		},
 		MixedVariadicHook: func(int, int, int, ...string) {
 			panic("Unexpected call to Variadic.MixedVariadic")
-			return
 		},
 	}
 }

testdata/voider/voider.go

@@ -31,7 +31,7 @@ Use it in your tests as in this example:
 	}
 
 Create anonymous function implementations for only those interface methods that
-should be called in the code under test.  This will force a painc if any
+should be called in the code under test.  This will force a panic if any
 unexpected calls are made to FakeVoidMethod.
 */
 type FakeVoider struct {
@@ -45,7 +45,6 @@ func NewFakeVoiderDefaultPanic() *FakeVoider {
 	return &FakeVoider{
 		VoidMethodHook: func() {
 			panic("Unexpected call to Voider.VoidMethod")
-			return
 		},
 	}
 }