// Return if the function contains only non-side-effecting ops or TensorArray
  // ops.
  bool HasAtMostTensorArrayEffect(mlir::func::FuncOp func_op) const {
    return set_.count(func_op) > 0;
  }

 private:
  llvm::DenseSet<mlir::func::FuncOp> set_;
};

}  // namespace tfrt_compiler
}  // namespace tensorflow

 * configured in the Settings DSL.
 */
internal
fun projectInterpretationSequenceStep(softwareTypeRegistry: SoftwareTypeRegistry) = SimpleInterpretationSequenceStepWithConversion(
    "project",
    features = setOf(ConventionApplication()),
) {
    projectEvaluationSchema(softwareTypeRegistry)

    softwareTypeRegistry: SoftwareTypeRegistry
): DeclarativeKotlinScriptEvaluator = DefaultDeclarativeKotlinScriptEvaluator(
    schemaBuilder,
    documentChecks = setOf(SettingsBlocksCheck),
    resolutionResultHandlers = setOf(
        ConventionDefinitionCollector(softwareTypeRegistryBasedConventionRegistrar(softwareTypeRegistry)),

	context
}

func (c ContextStub) GetPC() uintptr {
	return c.ip()
}

func NewContextStub() *ContextStub {
	var ctx context
	ctx.set_ip(getcallerpc())
	ctx.set_sp(getcallersp())
	ctx.set_fp(getcallerfp())
	return &ContextStub{ctx}

import java.nio.file.attribute.BasicFileAttributes
import java.util.jar.JarFile
import java.util.jar.JarOutputStream
import java.util.zip.ZipEntry


private
val ignoredPackagePatterns = PackagePatterns(setOf("java"))


object Attributes {
    val artifactType = Attribute.of("artifactType", String::class.java)
    val minified = Attribute.of("minified", Boolean::class.javaObjectType)
}


class JarAnalyzer(

    override fun get(): GradleApiSpecProvider.Spec = KotlinSpec

    private
    object KotlinSpec : GradleApiSpecProvider.SpecAdapter() {
        override fun getExportedPackages() = setOf("kotlin")
    }

func (c *context) set_lr(x uintptr) {}

func (c *context) set_ip(x uintptr) { c.eip = uint32(x) }
func (c *context) set_sp(x uintptr) { c.esp = uint32(x) }

// 386 does not have frame pointer register.
func (c *context) set_fp(x uintptr) {}

func prepareContextForSigResume(c *context) {
	c.edx = c.esp
	c.ecx = c.eip
}

func dumpregs(r *context) {
	print("eax     ", hex(r.eax), "\n")
	print("ebx     ", hex(r.ebx), "\n")

internal
fun conventionsDefinitionInterpretationSequenceStep(softwareTypeRegistry: SoftwareTypeRegistry) = SimpleInterpretationSequenceStep(
    "settingsConventions",
    features = setOf(ConventionDefinition()),
    buildEvaluationAndConversionSchema = { conventionsEvaluationSchema(softwareTypeRegistry) }
)


private

package okhttp3

import java.io.File
import org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor
import org.junit.platform.engine.discovery.DiscoverySelectors

// TODO move to junit5 tags
val avoidedTests =
  setOf(
    "okhttp3.BouncyCastleTest",
    "okhttp3.ConscryptTest",
    "okhttp3.CorrettoTest",
    "okhttp3.OpenJSSETest",
    "okhttp3.internal.platform.Jdk8WithJettyBootPlatformTest",

        get() = withValidityAssertion {
            KaFe10AnnotationList.create(
                fe10Type.annotations,
                analysisContext,
                ignoredAnnotations = setOf(
                    StandardClassIds.Annotations.ExtensionFunctionType,
                    StandardClassIds.Annotations.ContextFunctionTypeParams,
                )
            )
        }