.append(newLine)
            }
            sb.append(newLine)
        }
        if (includeLink) {
            sb.append(outro)
        }
        sb.toString().trim()
    }

    StringBuilder label(String newLine = "") {
        new StringBuilder(intro)
            .append(endLineWithDot(description))
            .append(newLine)
            .append(newLine)
    }

		p.printf("%s", strings.TrimSpace(com.Token))
		p.newline()
	}

	for i, stmt := range f.Stmt {
		switch x := stmt.(type) {
		case *CommentBlock:
			// comments already handled
			p.expr(x)

		default:
			p.expr(x)
			p.newline()
		}

		for _, com := range stmt.Comment().After {
			p.printf("%s", strings.TrimSpace(com.Token))
			p.newline()
		}

		if i+1 < len(f.Stmt) {
			p.newline()

// Test error recovery after missing closing parentheses in lists.

package p

func f() {
	x := f(g() // ERROR "unexpected newline"
	y := 1
}

func g() {
}

func h() {
	x := f(g() // ERROR "unexpected newline"
}

func i() {
	x := []int{1, 2, 3 // ERROR "unexpected newline"
	y := 0

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

// errors for the //line-adjusted code below
// ERROR "newline in string"
// ERROR "newline in character literal|newline in rune literal"
// ERROR "newline in string"
// ERROR "string not terminated"

//line :10:1
import "foo

//line :19:1
func _() {
	0x // ERROR "hexadecimal literal has no digits"
}

      val length = logMessage.length
      while (i < length) {
        var newline = logMessage.indexOf('\n', i)
        newline = if (newline != -1) newline else length
        do {
          val end = minOf(newline, i + MAX_LOG_LENGTH)
          Log.println(logLevel, tag, logMessage.substring(i, end))
          i = end
        } while (i < newline)
        i++
      }
    }
  }

	case 1:
		2:	// ERROR "unexpected :|expected .*;.* or .*}.* or newline|value computed is not used"
	case 2:
	}

	switch x {
	case 1:
		2: ;	// ERROR "unexpected :|expected .*;.* or .*}.* or newline|value computed is not used"
	case 2:
	}

	var y string
	switch y {
	case "foo":
		"bar":	// ERROR "unexpected :|expected .*;.* or .*}.* or newline|value computed is not used"
	case "bar":
	}

	switch y {

	}
}

func detectMobileProvisionFiles(udids [][]byte) []string {
	cmd := exec.Command("mdfind", "-name", ".mobileprovision")
	lines := getLines(cmd)

	var files []string
	for _, line := range lines {
		if len(line) == 0 {
			continue
		}
		xmlLines := getLines(parseMobileProvision(string(line)))
		matches := 0
		for _, udid := range udids {
			for _, xmlLine := range xmlLines {

        interaction {
            (progressArea.getHeight() - 1) * ansi.newline()
            0 * ansi._
        }
    }

    def "redraw the work in progress area"() {
        given:
        fillArea()

        when:
        redraw()

        then:
        interaction {
            (progressArea.getHeight() - 1) * ansi.newline()
            1 * ansi.cursorUp(5)

            expectAreaRedraw()

[GOOS:plan9] skip 'filesystem disallows \n in paths'

# If the directory path containing a package to be built includes a newline,
# the go command should refuse to even try to build the package.

env DIR=$WORK${/}${newline}'package main'${newline}'func main() { panic("uh-oh")'${newline}'/*'

mkdir $DIR
cd $DIR
exec pwd
cp $WORK/go.mod ./go.mod
cp $WORK/main.go ./main.go
cp $WORK/main_nocgo.go ./main_nocgo.go

// test case from issue

type _ interface{
	m /* ERROR unexpected name int in interface type; possibly missing semicolon or newline or } */ int
}

// other cases where the fix for this issue affects the error message

const (
	x int = 10 /* ERROR unexpected literal "foo" in grouped declaration; possibly missing semicolon or newline or \) */ "foo"
)