List<SynonymItem> itemList = new ArrayList<>();
        itemList.add(new SynonymItem(1, new String[] { "a1" }, new String[] { "A1" }));
        itemList.add(new SynonymItem(2, new String[] { "b1", "b2" }, new String[] { "B1" }));
        itemList.add(new SynonymItem(3, new String[] { "c1" }, new String[] { "C1", "C2" }));
        itemList.add(new SynonymItem(4, new String[] { "x1", "X1" }, new String[] { "x1", "X1" }));

require example.com/b v0.2.0

replace (
	example.com/b v0.1.0 => ./b1
	example.com/b v0.2.0 => ./b2
	example.com/c v0.1.0 => ./c
	example.com/d v0.1.0 => ./d
	example.com/d v0.2.0 => ./d
)
-- a.go --
package a

import _ "example.com/b"

-- b1/go.mod --
module example.com/b

go 1.15

require example.com/c v0.1.0
-- b1/b.go --
package b

import _ "example.com/c"

-- b2/go.mod --

 * that follows.
 *
 * b1
 * --
 *
 * This is either a mapping decision or the length of the mapped output, according to this table:
 *
 * ```
 *  0..63 : Length of the UTF-16 sequence that this range maps to. The offset is b2b3.
 * 64..79 : Offset by a fixed negative offset. The bottom 4 bits of b1 are the top 4 bits of the offset.

        final byte b0 = DECODE_TABLE[inData.charAt(inIndex)];
        final byte b1 = DECODE_TABLE[inData.charAt(inIndex + 1)];
        final byte b2 = DECODE_TABLE[inData.charAt(inIndex + 2)];
        final byte b3 = DECODE_TABLE[inData.charAt(inIndex + 3)];
        outData[outIndex] = (byte) (b0 << 2 & 0xfc | b1 >> 4 & 0x3);
        outData[outIndex + 1] = (byte) (b1 << 4 & 0xf0 | b2 >> 2 & 0xf);

        given:
        file("a").with {
            createFile("a")
        }
        file("b").with {
            createFile("b")
            createDir("b1").createFile("b1")
        }

        def resolver = TestFiles.resolver(testDirectory)
        def fileCollectionFactory = TestFiles.fileCollectionFactory(testDirectory)

	if err != nil {
		panic(err)
	}
	// (defer statement belongs here)
}
-- vetall/p_test.go --
package p
-- vetcycle/p.go --
package p

type (
	_  interface{ m(B1) }
	A1 interface{ a(D1) }
	B1 interface{ A1 }
	C1 interface {
		B1 /* ERROR issue #18395 */
	}
	D1 interface{ C1 }
)

var _ A1 = C1 /* ERROR cannot use C1 */ (nil)
-- vetfail/p1/p1.go --
// +build !foo-bar

package p1

)

-- a1/go.mod --
module example.com/a

go 1.16

require example.com/b v0.1.0
-- a1/a.go --
package a

import _ "example.com/b"

-- b1/go.mod --
module example.com/b

go 1.16

require example.com/c v0.1.0
-- b1/b.go --
package b

import _ "example.com/c"

-- b2/go.mod --
module example.com/b

go 1.16

require (
	example.com/c v0.2.0

func (W1) n() {}

// alias receiver types (invalid due to builtin underlying type)
type (
	B0 = B1
	B1 = B2
	B2 = int
)

func (B0 /* ERRORx "cannot define new methods on non-local type (int|B)" */ ) m() {}
func (B1 /* ERRORx "cannot define new methods on non-local type (int|B)" */ ) n() {}

// cycles
type (
	C2 /* ERROR "invalid recursive type" */ = C2

000000d0  ec b1 19 dd 68 b5 bd c4  bb ba 63 9a e4 c9 24 af  |....h.....c...$.|
000000e0  88 13 65 11 bf ea d9 07  e9 46 fd 5b 60 ce 57 46  |..e......F.[`.WF|
000000f0  8b a9 bd c6 58 1a 3b bd  5e fb 0f 46 ec fc 8b 2c  |....X.;.^..F...,|
00000100  ea a7 19 06 6a e5 6f 10  7a 27 04 6b aa a4 2c f4  |....j.o.z'.k..,.|
00000110  ef 3b e8 8a 51 88 fd e0  ae 33 b1 4c b3 04 5e 91  |.;..Q....3.L..^.|

00000010  6c 1f de 6b 2d 67 9e 1b  13 13 ad 67 d8 0f b2 b1  |l..k-g.....g....|
00000020  95 17 e7 0b e1 ba 6f 93  20 43 aa c7 a4 02 8e 38  |......o. C.....8|
00000030  01 6b 53 55 33 6e 82 ea  70 d7 e2 a6 bd be 57 2d  |.kSU3n..p.....W-|
00000040  85 1c 4a 28 30 42 34 e6  f9 38 9c 59 ed 1c fc ff  |..J(0B4..8.Y....|
00000050  19 0f 1d 71 f1 4b 2a 7a  b1 c6 d9 11 a5 5e ca 1c  |...q.K*z.....^..|