assertStableResult(
                    testServices = testServices,
                    firstDiagnostic = firstCandidate.diagnostic,
                    secondDiagnostic = (secondCandidate as KaInapplicableCallCandidateInfo).diagnostic,
                )
            }
        }
    }
}

            }
            writer.write("\\"; }");
            writer.write("}");
        } finally {
            writer.close();
        }
    } catch (IOException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "Failed to generate source file " + className, element);
    }
"""
        def resourceCode = writeResources ? """
    try {

            val diagnostic = calleeReference.diagnostic
            val ktDiagnostic = calleeReference.createKtDiagnostic(psi)

            if (diagnostic is ConeHiddenCandidateError)
                return KaErrorCallInfo(emptyList(), ktDiagnostic, token)

            val candidateCalls = mutableListOf<KaCall>()
            if (diagnostic is ConeDiagnosticWithCandidates) {

// Package defers defines an Analyzer that checks for common mistakes in defer
// statements.
//
// # Analyzer defers
//
// defers: report common mistakes in defer statements
//
// The defers analyzer reports a diagnostic when a defer statement would
// result in a non-deferred call to time.Since, as experience has shown
// that this is nearly always a mistake.
//
// For example:
//
//	start := time.Now()
//	...

abstract class AbstractNestedBeanLanguageInterOpIntegrationTest extends AbstractLanguageInterOpIntegrationTest {
    abstract void pluginDefinesTask()

    def "attaches diagnostic information to property"() {
        pluginDefinesTask()

        buildFile << """
            apply plugin: SomePlugin

            println "flag = " + tasks.someTask.params.flag
        """

        when:

gccgoGetCpuidCount(uint32_t leaf, uint32_t subleaf,
                   uint32_t *eax, uint32_t *ebx,
                   uint32_t *ecx, uint32_t *edx)
{
	return __get_cpuid_count(leaf, subleaf, eax, ebx, ecx, edx);
}

#pragma GCC diagnostic ignored "-Wunknown-pragmas"
#pragma GCC push_options
#pragma GCC target("xsave")
#pragma clang attribute push (__attribute__((target("xsave"))), apply_to=function)

            fileLoc.getFilename().str());
      } else {
        // If this is a non-FileLineColLoc, go ahead and include it.
        return true;
      }
    };
  }

  setHandler([this](Diagnostic& diag) { return this->handler(&diag); });
}

Status StatusScopedDiagnosticHandler::ConsumeStatus() {
  return BaseScopedDiagnosticHandler::ConsumeStatus();
}

	"golang.org/x/tools/go/ast/inspector"
	"golang.org/x/tools/internal/aliases"
	"golang.org/x/tools/internal/typeparams"
)

const Doc = `check for unkeyed composite literals

This analyzer reports a diagnostic for composite literals of struct
types imported from another package that do not use the field-keyed
syntax. Such literals are fragile because the addition of a new field

	return modes.Encode.Marshal(src)
}

func Unmarshal(src []byte, dst interface{}) error {
	return modes.Decode.Unmarshal(src, dst)
}

func Diagnose(src []byte) (string, error) {
	return modes.Diagnostic.Diagnose(src)

    String resourceName = typeElement.getSimpleName().toString() + ".txt";
    FileObject resourceFile;
    Writer writer;
    try {
        $outputs
    } catch (Exception e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "Failed to generate resource file " + resourceName + ": " + e.getMessage());
    }
}
"""
    }