e := fmt.Errorf(format, a...)
	ee := Error{}
	ee.msg = e.Error()
	ee.cause = errors.Unwrap(e)
	return ee
}

// Unwrap the internal error.
func (e Error) Unwrap() error { return e.cause }

// Error 'error' compatible method.
func (e Error) Error() string {
	if e.msg == "" {
		return "crypto: cause <nil>"
	}
	return e.msg
}

var (
	// ErrInvalidEncryptionMethod indicates that the specified SSE encryption method

import (
	"fmt"
	"text/template/parse"
)

// Error describes a problem encountered during template Escaping.
type Error struct {
	// ErrorCode describes the kind of error.
	ErrorCode ErrorCode
	// Node is the node that caused the problem, if known.
	// If not nil, it overrides Name and Line.
	Node parse.Node
	// Name is the name of the template in which the error was encountered.
	Name string

            hasError = false;
        } else {
            hasError = true;
            errors.forEach(this.errors::add);
        }
    }

    public int getNumberOfSuggestDocs() {
        return numberOfSuggestDocs;
    }

    public int getNumberOfInputDocs() {
        return numberOfInputDocs;
    }

    public boolean hasError() {
        return hasError;
    }

        try {
            writeOperationVoid(p -> {
                try {
                    p.load(reader);
                } catch (IOException e) {
                    throw new IOError(e);
                }
            });
        } catch (IOError e) {
            throw (IOException) e.getCause();
        }
    }

    @Override
    public synchronized void load(InputStream inStream) throws IOException {

	if (resetSIGIO == NULL) {
		fprintf(stderr, "%s\n", dlerror());
		exit(EXIT_FAILURE);
	}

	if (verbose) {
		fprintf(stderr, "calling ResetSIGIO\n");
	}

	resetSIGIO();

	sawSIGIO = (bool (*)(void))dlsym(handle, "SawSIGIO");
	if (sawSIGIO == NULL) {
		fprintf(stderr, "%s\n", dlerror());
		exit(EXIT_FAILURE);
	}

	if (verbose) {

//go:cgo_import_dynamic _NSGetArgv _NSGetArgv ""
//go:cgo_import_dynamic _NSGetEnviron _NSGetEnviron ""
//go:cgo_import_dynamic _NSGetExecutablePath _NSGetExecutablePath ""
//go:cgo_import_dynamic __bzero __bzero ""
//go:cgo_import_dynamic __error __error ""
//go:cgo_import_dynamic __fork __fork ""
//go:cgo_import_dynamic __mmap __mmap ""
//go:cgo_import_dynamic __munmap __munmap ""
//go:cgo_import_dynamic __stack_chk_fail __stack_chk_fail ""

//go:cgo_import_dynamic _NSGetArgv _NSGetArgv ""
//go:cgo_import_dynamic _NSGetEnviron _NSGetEnviron ""
//go:cgo_import_dynamic _NSGetExecutablePath _NSGetExecutablePath ""
//go:cgo_import_dynamic __error __error ""
//go:cgo_import_dynamic __fork __fork ""
//go:cgo_import_dynamic __mmap __mmap ""
//go:cgo_import_dynamic __munmap __munmap ""
//go:cgo_import_dynamic __stack_chk_fail __stack_chk_fail ""

package runtime

import (
	"internal/abi"
	"internal/bytealg"
)

// The Error interface identifies a run time error.
type Error interface {
	error

	// RuntimeError is a no-op function but
	// serves to distinguish types that are run time
	// errors from ordinary errors: a type is a
	// run time error if it has a RuntimeError method.
	RuntimeError()
}

	os.Exit(code)
}

// CheckErr prints a user friendly error to STDERR and exits with a non-zero
// exit code. Unrecognized errors will be printed with an "error: " prefix.
//
// This method is generic to the command in use and may be used by non-Kubectl
// commands.
func CheckErr(err error) {
	checkErr(err, fatal)
}

// preflightError allows us to know if the error is a preflight error or not

    fun `if a lambda is not allowed, a lambda is reported as an error`() {
        schema.resolve("lambdaNotAllowed(0) { }").isError(ErrorReason.UnresolvedFunctionCallSignature::class)
    }

    private
    fun ResolutionResult.isSuccessful() {
        assertTrue { errors.isEmpty() }
        assertTrue { additions.size == 1 }
    }

    private
    fun ResolutionResult.isError(errorReason: KClass<out ErrorReason>) {