preserveAnnotations: Boolean,
    ): PsiType? {
        val kotlinType = (type as KaFe10Type).fe10Type

        with(typeMapper.typeContext) {
            if (kotlinType.contains { it.isError() }) {
                return null
            }
        }

        if (!analysisSession.useSiteModule.platform.has<JvmPlatform>()) return null

        val typeElement = asPsiTypeElement(

                || typeContext.hasNothingInNonContravariantPosition(type)
                || type.arguments.isEmpty()
                || typeDeclaration == null
                || ErrorUtils.isError(typeDeclaration)

        if (skipArguments) {
            writeAsmType(asmType)
            return
        }

        val nestedType = getNestedType(type)
        if (nestedType.nested.isEmpty()) {

            LiteralValueResolved -> incorrect signature
            LiteralValueResolved -> 1
            PropertyNotAssigned(UnresolvedBase)
            LiteralValueResolved -> 123
            ErrorResolution(IsError)
            ElementNotResolved(UnresolvedSignature)
            LiteralValueResolved -> test2
            PropertyNotAssigned(ValueTypeMismatch)
            LiteralValueResolved -> type mismatch

def is_generated_file(data, regexs):
    return regexs["generated"].search(data)


def file_passes(filename, refs, regexs):
    try:
        with open(filename) as stream:
            data = stream.read()
    except OSError as exc:
        print(f"Unable to open {filename}: {exc}", file=verbose_out)
        return False

    # determine if the file is automatically generated
    generated = is_generated_file(data, regexs)

                        assert !project.configurations.default.resolvedConfiguration.hasError()
                    }
                }
                task assertCanResolveRecursiveCopy {
                    doLast {
                        assert !project.configurations.default.copyRecursive().resolvedConfiguration.hasError()
                    }
                }
            }
            project('b') {

// as errors from genuine panics (which we don't want to return as errors)
type osError struct {
	err error
}

func (b *Writer) write0(buf []byte) {
	n, err := b.output.Write(buf)
	if n != len(buf) && err == nil {
		err = io.ErrShortWrite
	}
	if err != nil {
		panic(osError{err})
	}
}

func (b *Writer) writeN(src []byte, n int) {
	for n > len(src) {
		b.write0(src)

			container.Lifecycle.PostStart.HTTPGet.Port = tt.Port
			pod.Spec.Containers = []v1.Container{container}
			_, err := handlerRunner.Run(ctx, containerID, &pod, &container, container.Lifecycle.PostStart)

			if hasError := (err != nil); hasError != tt.ExpectError {
				t.Errorf("unexpected error: %v", err)
			}

			if fakeHTTPDoer.url != tt.Expected {
				t.Errorf("unexpected url: %s", fakeHTTPDoer.url)
			}
		})
	}
}

            }

            task validate {
                doLast {
                    def compileClasspath = configurations.compileClasspath.resolvedConfiguration
                    assert compileClasspath.hasError()
                    println "evaluating:"
                    compileClasspath.${expression}
                }
            }
        """

        m1.allowAll()
        m2.allowAll()

                        .mustNot(QueryBuilders.matchPhraseQuery(FieldNames.KINDS, SuggestItem.Kind.USER.toString())));
        if (deleteResponse.hasError()) {
            throw new SuggestIndexException(deleteResponse.getErrors().get(0));
        }

        final List<SuggestItem> updateItems = new ArrayList<>();

	< internal/msan
	< internal/asan
	< internal/weak
	< sync
	< internal/bisect
	< internal/godebug
	< internal/reflectlite
	< errors
	< internal/oserror;

	cmp, internal/race, math/bits
	< iter
	< maps, slices;

	internal/oserror, maps, slices
	< RUNTIME;

	RUNTIME
	< sort
	< container/heap;

	RUNTIME
	< io;

	RUNTIME
	< arena;

	syscall !< io;