*
     * @param version the version string to parse, must not be {@code null}
     * @return the parsed version, never {@code null}
     * @throws VersionParserException if the string violates the syntax rules of this scheme
     * @see org.apache.maven.api.Session#parseVersion(String)
     */
    @Nonnull
    Version parseVersion(@Nonnull String version);

    /**

-- syntaxerr/syntaxerr.go --
package syntaxerr

import _ "pkgdep"

-- syntaxerr/syntaxerr_ie_test.go --
package syntaxerr

!!!syntax error

-- syntaxerr/syntaxerr_xe_test.go --
package syntaxerr_test

!!!syntax error

-- syntaxerr/syntaxerr_i_test.go --
package syntaxerr

import _ "testdep_a"

-- syntaxerr/syntaxerr_x_test.go --
package syntaxerr

import (
	"bytes"
	"cmd/compile/internal/syntax"
	"fmt"
	"strconv"
	"strings"
)

func sprintf(qf Qualifier, tpSubscripts bool, format string, args ...any) string {
	for i, arg := range args {
		switch a := arg.(type) {
		case nil:
			arg = "<nil>"
		case operand:
			panic("got operand instead of *operand")
		case *operand:
			arg = operandString(a, qf)
		case syntax.Pos:
			arg = a.String()
		case syntax.Expr:

	t.check = nil
	t.embedPos = nil
}

func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType, def *TypeName) {
	addEmbedded := func(pos syntax.Pos, typ Type) {
		ityp.embeddeds = append(ityp.embeddeds, typ)
		if ityp.embedPos == nil {
			ityp.embedPos = new([]syntax.Pos)
		}
		*ityp.embedPos = append(*ityp.embedPos, pos)
	}

	for _, f := range iface.MethodList {

// setConst sets x to the untyped constant for literal lit.
func (x *operand) setConst(k syntax.LitKind, lit string) {
	var kind BasicKind
	switch k {
	case syntax.IntLit:
		kind = UntypedInt
	case syntax.FloatLit:
		kind = UntypedFloat
	case syntax.ImagLit:
		kind = UntypedComplex
	case syntax.RuneLit:
		kind = UntypedRune
	case syntax.StringLit:
		kind = UntypedString
	default:
		panic("unreachable")
	}

	uses := make(map[*syntax.Name]Object)
	types := make(map[syntax.Expr]TypeAndValue)
	mustTypecheck(src, nil, &Info{Uses: uses, Types: types})

	// find called function
	n := 0
	var fun syntax.Expr
	for x := range types {
		if call, _ := x.(*syntax.CallExpr); call != nil {
			fun = call.Fun
			n++
		}
	}
	if n != 1 {

		src := "package p; type T interface" + body
		file, err := syntax.Parse(nil, strings.NewReader(src), errh, nil, 0)
		if err != nil {
			t.Fatalf("%s: %v (invalid test case)", body, err)
		}

		// type check
		var conf Config
		pkg, err := conf.Check(file.PkgName.Value, []*syntax.File{file}, nil)
		if err != nil {
			t.Fatalf("%s: %v (invalid test case)", body, err)
		}

cmp go.mod.orig go.mod

cd importsyntax


# A syntax error in a dependency prevents the compiler from needing that
# dependency's imports, so 'go get' should not report an error when those
# imports cannot be resolved: it has all of the dependencies that the compiler
# needs, and the user did not request to run the compiler.

go get
cmp ../go.mod.syntax-d ../go.mod


-- go.mod --
module example.com/m

go 1.16

main.go.c:24: error: for each function it appears in.)
main.go.c:24: error: syntax error before ‘def’
main.go.c:24: error: missing terminating " character
main.go.c:25: warning: excess elements in struct initializer
main.go.c:25: warning: (near initialization for ‘slit’)
main.go.c:36: error: syntax error at end of input

            <para>The <filename>buildscript</filename> directory contains a project that uses the old <code>buildscript</code> syntax for using plugins.</para>
        </listitem>
        <listitem>
            <para>The <filename>dsl</filename> directory contains the a project that uses the new <code>plugins</code> syntax for using plugins.</para>
        </listitem>
        <listitem>
            <para>