?: getTypeAliasByClassId(classId)
                ?: error("Class-like symbol is not found by '$classId'")

            val samConstructor = symbol.getSamConstructor() ?: error("SAM constructor is not found for symbol '$symbol'")
            return listOf(samConstructor)
        }
    }

    companion object {
        val identifiers = arrayOf(
            "package:",
            "callable:",

        this.stats = stats;
        this.strategy = strategy;
        this.logger = logger;
    }

    @Override
    public DaemonExpirationResult checkExpiration() {
        // We cannot check this in the constructor since system properties are copied to the daemon after initialization.
        if (!Boolean.parseBoolean(System.getProperty(ENABLE_PERFORMANCE_MONITORING, "true"))) {
            return DaemonExpirationResult.NOT_TRIGGERED;

          LiftQuantizableSpotsAsFunctionsPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
      LiftQuantizableSpotsAsFunctionsPass)

  LiftQuantizableSpotsAsFunctionsPass() = default;

  // Constructor with explicit user-provided `QuantizationSpecs`.
  explicit LiftQuantizableSpotsAsFunctionsPass(
      QuantizationSpecs quantization_specs)
      : quantization_specs_(std::move(quantization_specs)) {}

 private:

}

func selfConnect(fd *netFD, err error) bool {
	// If the connect failed, we clearly didn't connect to ourselves.
	if err != nil {
		return false
	}

	// The socket constructor can return an fd with raddr nil under certain
	// unknown conditions. The errors in the calls there to Getpeername
	// are discarded, but we can't catch the problem there because those

  private val runningAsyncCalls = ArrayDeque<AsyncCall>()

  /** Running synchronous calls. Includes canceled calls that haven't finished yet. */
  private val runningSyncCalls = ArrayDeque<RealCall>()

  constructor(executorService: ExecutorService) : this() {
    this.executorServiceOrNull = executorService
  }

  internal fun enqueue(call: AsyncCall) {
    this.withLock {
      readyAsyncCalls.add(call)

- expose a property named "`name`" as the unique, and constant, name for the object. The `domainObjectContainer(Class)`
variant of the method creates new instances by calling the constructor of the class that takes a string argument, which is the desired name of the object.

  if (failed(pm_.run(user_module))) {
    return errors::Internal("Failed to run the decompose passes.");
  }
  return absl::OkStatus();
}

// Constructor of the decompose context.
TFRDecomposeContext::TFRDecomposeContext(mlir::ModuleOp tfr_module)
    : tfr_module_(tfr_module), pm_(tfr_module_.getContext()) {
  mlir::OpPassManager& func_pm = pm_.nest<mlir::func::FuncOp>();