all: join some chained ifs to unindent code

Found with mvdan.cc/unindent. It skipped the cases where parentheses
would need to be added, where comments would have to be moved elsewhere,
or where actions and simple logic would mix.

One of them was of the form "err != nil && err == io.EOF", so the first
part was removed.

Change-Id: Ie504c2b03a2c87d10ecbca1b9270069be1171b91
Reviewed-on: https://go-review.googlesource.com/57690
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

diff --git a/src/crypto/cipher/io.go b/src/crypto/cipher/io.go
index 3938c0a4c8883e20a0d8989a9786bc09845d5d71..0974ac748e51f856c3137893ff85ab55e7d6db07 100644 (file)
--- a/src/crypto/cipher/io.go
+++ b/src/crypto/cipher/io.go
@@ -37,10 +37,8 @@ func (w StreamWriter) Write(src []byte) (n int, err error) {
        c := make([]byte, len(src))
        w.S.XORKeyStream(c, src)
        n, err = w.W.Write(c)
-       if n != len(src) {
-               if err == nil { // should never happen
-                       err = io.ErrShortWrite
-               }
+       if n != len(src) && err == nil { // should never happen
+               err = io.ErrShortWrite
        }
        return
 }

diff --git a/src/encoding/gob/decoder.go b/src/encoding/gob/decoder.go
index 9398b8f243fae9aca20b12f816ad5a5051b7ce3d..5ef03888621146da0d1f397ab7464a3ffa728429 100644 (file)
--- a/src/encoding/gob/decoder.go
+++ b/src/encoding/gob/decoder.go
@@ -99,10 +99,8 @@ func (dec *Decoder) readMessage(nbytes int) {
        // Read the data
        dec.buf.Size(nbytes)
        _, dec.err = io.ReadFull(dec.r, dec.buf.Bytes())
-       if dec.err != nil {
-               if dec.err == io.EOF {
-                       dec.err = io.ErrUnexpectedEOF
-               }
+       if dec.err == io.EOF {
+               dec.err = io.ErrUnexpectedEOF
        }
 }
 

diff --git a/src/net/http/fs.go b/src/net/http/fs.go
index aba08510dcab4c80b8431651451b5b78635872d8..ecad14ac1e4a62c08e1a0b244a4f6581c7ea6e61 100644 (file)
--- a/src/net/http/fs.go
+++ b/src/net/http/fs.go
@@ -530,10 +530,8 @@ func checkPreconditions(w ResponseWriter, r *Request, modtime time.Time) (done b
        }
 
        rangeHeader = r.Header.get("Range")
-       if rangeHeader != "" {
-               if checkIfRange(w, r, modtime) == condFalse {
-                       rangeHeader = ""
-               }
+       if rangeHeader != "" && checkIfRange(w, r, modtime) == condFalse {
+               rangeHeader = ""
        }
        return false, rangeHeader
 }

diff --git a/src/net/url/url.go b/src/net/url/url.go
index 2ac24725692f89f3c1e87c5023d12d8352856362..00e0df17ba4dab5b2fb61c092a2dd27d01e6aede 100644 (file)
--- a/src/net/url/url.go
+++ b/src/net/url/url.go
@@ -953,12 +953,10 @@ func (u *URL) ResolveReference(ref *URL) *URL {
                url.Path = ""
                return &url
        }
-       if ref.Path == "" {
-               if ref.RawQuery == "" {
-                       url.RawQuery = u.RawQuery
-                       if ref.Fragment == "" {
-                               url.Fragment = u.Fragment
-                       }
+       if ref.Path == "" && ref.RawQuery == "" {
+               url.RawQuery = u.RawQuery
+               if ref.Fragment == "" {
+                       url.Fragment = u.Fragment
                }
        }
        // The "abs_path" or "rel_path" cases.

diff --git a/src/runtime/cgocall.go b/src/runtime/cgocall.go
index 755269ebd2959f78e5d041f363cf47a171fb2d3a..ce4d707e0684b20ea9f44a623a6ae17711cb125d 100644 (file)
--- a/src/runtime/cgocall.go
+++ b/src/runtime/cgocall.go
@@ -580,10 +580,8 @@ func cgoCheckUnknownPointer(p unsafe.Pointer, msg string) (base, i uintptr) {
                                // No more possible pointers.
                                break
                        }
-                       if hbits.isPointer() {
-                               if cgoIsGoPointer(*(*unsafe.Pointer)(unsafe.Pointer(base + i))) {
-                                       panic(errorString(msg))
-                               }
+                       if hbits.isPointer() && cgoIsGoPointer(*(*unsafe.Pointer)(unsafe.Pointer(base + i))) {
+                               panic(errorString(msg))
                        }
                        hbits = hbits.next()
                }

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index cf2537c81251cf6fc544b844b7f6aa5fd5864413..06abdf2a9b68a921372358fd4794521700c5c0f7 100644 (file)
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3568,13 +3568,11 @@ func procresize(nprocs int32) *p {
        // free unused P's
        for i := nprocs; i < old; i++ {
                p := allp[i]
-               if trace.enabled {
-                       if p == getg().m.p.ptr() {
-                               // moving to p[0], pretend that we were descheduled
-                               // and then scheduled again to keep the trace sane.
-                               traceGoSched()
-                               traceProcStop(p)
-                       }
+               if trace.enabled && p == getg().m.p.ptr() {
+                       // moving to p[0], pretend that we were descheduled
+                       // and then scheduled again to keep the trace sane.
+                       traceGoSched()
+                       traceProcStop(p)
                }
                // move all runnable goroutines to the global queue
                for p.runqhead != p.runqtail {

diff --git a/src/runtime/select.go b/src/runtime/select.go
index bf3a550ea4bfe7eaace24b2aa1fa2405bfde46ec..a623735865a96521b5cac192c67ff9f6aa94cc81 100644 (file)
--- a/src/runtime/select.go
+++ b/src/runtime/select.go
@@ -457,10 +457,8 @@ loop:
                print("wait-return: sel=", sel, " c=", c, " cas=", cas, " kind=", cas.kind, "\n")
        }
 
-       if cas.kind == caseRecv {
-               if cas.receivedp != nil {
-                       *cas.receivedp = true
-               }
+       if cas.kind == caseRecv && cas.receivedp != nil {
+               *cas.receivedp = true
        }
 
        if raceenabled {

diff --git a/src/sync/waitgroup.go b/src/sync/waitgroup.go
index f266f7c2b97f94e04ea5d788c8e963cd77a17076..2fa7c3e07ed8660c1a017504757ff056a65ca238 100644 (file)
--- a/src/sync/waitgroup.go
+++ b/src/sync/waitgroup.go
@@ -63,13 +63,11 @@ func (wg *WaitGroup) Add(delta int) {
        state := atomic.AddUint64(statep, uint64(delta)<<32)
        v := int32(state >> 32)
        w := uint32(state)
-       if race.Enabled {
-               if delta > 0 && v == int32(delta) {
-                       // The first increment must be synchronized with Wait.
-                       // Need to model this as a read, because there can be
-                       // several concurrent wg.counter transitions from 0.
-                       race.Read(unsafe.Pointer(&wg.sema))
-               }
+       if race.Enabled && delta > 0 && v == int32(delta) {
+               // The first increment must be synchronized with Wait.
+               // Need to model this as a read, because there can be
+               // several concurrent wg.counter transitions from 0.
+               race.Read(unsafe.Pointer(&wg.sema))
        }
        if v < 0 {
                panic("sync: negative WaitGroup counter")

diff --git a/src/text/template/parse/lex.go b/src/text/template/parse/lex.go
index 6fbf36d7a4af8b1d55155437029787037f6fda13..cdecd412eea6234679b266069850e899408689ae 100644 (file)
--- a/src/text/template/parse/lex.go
+++ b/src/text/template/parse/lex.go
@@ -281,10 +281,9 @@ func (l *lexer) atRightDelim() (delim, trimSpaces bool) {
                return true, false
        }
        // The right delim might have the marker before.
-       if strings.HasPrefix(l.input[l.pos:], rightTrimMarker) {
-               if strings.HasPrefix(l.input[l.pos+trimMarkerLen:], l.rightDelim) {
-                       return true, true
-               }
+       if strings.HasPrefix(l.input[l.pos:], rightTrimMarker) &&
+               strings.HasPrefix(l.input[l.pos+trimMarkerLen:], l.rightDelim) {
+               return true, true
        }
        return false, false
 }