#if ( $locationTracking )
                    ${classLcapName}.${field.name}(parse${field.toClass.name}(parser, strict, source));
        #elseif ( $needXmlContext )
                    ${classLcapName}.${field.name}(parse${field.toClass.name}(parser, strict, context));
        #else
                    ${classLcapName}.${field.name}(parse${field.toClass.name}(parser, strict));
        #end
                    break;

 * the name of the callable is also transformed from "foo" to "getFoo".
 * It is possible to specify the custom name for the extension implementation, if needed.
 */
public @interface WithExtensionReferences {
    Class<?> toClass();
    String methodName() default "";

                AnnotationUtils.findAnnotationMirror(element, WithExtensionReferences.class).ifPresent(annotation ->
                    AnnotationUtils.findAnnotationValue(annotation, "toClass").ifPresent(value -> {
                        TypeMirror typeMirror = (TypeMirror) value.getValue();
                        Type type = TypeUtils.extractType(typeMirror);

     * 代入可能かどうかを返します。
     *
     * @param toClass
     *            代入先のクラス。{@literal null}であってはいけません
     * @param fromClass
     *            代入元のクラス。{@literal null}であってはいけません
     * @return 代入可能かどうか
     * @see Class#isAssignableFrom(Class)
     */
    public static boolean isAssignableFrom(final Class<?> toClass, Class<?> fromClass) {
        assertArgumentNotNull("toClass", toClass);

        diagnostics.diagnostics.each {
            sb.append("In $it\n")
        }

        throw new RuntimeException(sb.toString())
    }

    @CompileStatic
    protected GeneratedClass toClass(String fqn, String script) {
        toApi([(fqn): script]).classes[fqn]
    }

    protected void noSuchMethod(Class c, String name, Class... argTypes) {
        try {

	// Such tags are recorded with the unknown prefix as the name space URL.
	Strict bool

	// When Strict == false, AutoClose indicates a set of elements to
	// consider closed immediately after they are opened, regardless
	// of whether an end element is present.
	AutoClose []string

	// Entity can be used to map non-standard entity names to string replacements.

      #elseif ( $field.to && $field.multiplicity == "1" )
                    ${classLcapName}.${field.name}(parse${field.toClass.name}(parser, strict));
                    break;
      #elseif ( $field.to && $field.multiplicity == "*" && $Helper.isFlatItems( $field ) )
                    ${field.name}.add(parse${field.toClass.name}(parser, strict));
                    break;
      #elseif ( $field.to && $field.multiplicity == "*" )

        val sslSocket =
          route.address.sslSocketFactory.createSocket(
            rawSocket,
            route.address.url.host,
            route.address.url.port,
            // autoClose:
            true,
          ) as SSLSocket

        val tlsEquipPlan = planWithCurrentOrInitialConnectionSpec(connectionSpecs, sslSocket)
        val connectionSpec = connectionSpecs[tlsEquipPlan.connectionSpecIndex]

func BenchmarkHTMLAutoClose(b *testing.B) {
	b.RunParallel(func(p *testing.PB) {
		for p.Next() {
			d := NewDecoder(strings.NewReader(testInputHTMLAutoClose))
			d.Strict = false
			d.AutoClose = HTMLAutoClose
			d.Entity = HTMLEntity
			for {
				_, err := d.Token()
				if err != nil {
					if err == io.EOF {
						break
					}
					b.Fatalf("unexpected error: %v", err)
				}

		{"Attr", Type, 0},
		{"Attr.Name", Field, 0},
		{"Attr.Value", Field, 0},
		{"CharData", Type, 0},
		{"Comment", Type, 0},
		{"CopyToken", Func, 0},
		{"Decoder", Type, 0},
		{"Decoder.AutoClose", Field, 0},
		{"Decoder.CharsetReader", Field, 0},
		{"Decoder.DefaultSpace", Field, 1},
		{"Decoder.Entity", Field, 0},
		{"Decoder.Strict", Field, 0},
		{"Directive", Type, 0},
		{"Encoder", Type, 0},