val declarationName = declaration.nameAsName ?: continue
                if (!nameFilter(declarationName)) continue
                with(analysisSession) {
                    yield(declaration.getSymbol() as S)
                }
            }
        }
    }

    override fun getConstructors(): Sequence<KaConstructorSymbol> = withValidityAssertion {
        emptySequence()
    }

from fastapi.testclient import TestClient


@pytest.fixture(name="app", scope="module")
def get_app():
    with pytest.warns(DeprecationWarning):
        from docs_src.events.tutorial002 import app
    yield app


def test_events(app: FastAPI):
    with TestClient(app) as client:
        response = client.get("/items/")
        assert response.status_code == 200, response.text

  ^bb0(%arg0: tensor<!tf_type.variant<tensor<f32>>>, %arg1: tensor<i32>):
    // CHECK:   %[[PRED:.*]] = "tf._SomeOp"()
    // CHECK:   "tf.Yield"(%[[PRED]])
    %pred = "tf._SomeOp"() : () -> tensor<i1>
    "tf.Yield"(%pred) : (tensor<i1>) -> ()
  },  {
  // CHECK: ^bb0(%[[CARG0:.*]]: tensor<10xf32>, %[[CARG1:.*]]: tensor<i32>, %[[CARG2:.*]]: tensor<1xi32>):

    }
    val result = plans[nextPlanIndex++]
    events += "take plan ${result.id}"

    if (result.yieldBeforePlanReturns) {
      taskFaker.yield()
    }

    val planningThrowable = result.planningThrowable
    if (planningThrowable != null) throw planningThrowable

    return result
  }

  if (!result.use_empty()) return false;

  Block& body_block = while_op.getBody().front();
  Block& cond_block = while_op.getCond().front();
  Operation* body_yield_op = body_block.getTerminator();

  // The body yield operand, body block argument, condition block argument, and
  // result all correspond to each other (see definition of `WhileRegionOp`).
  int idx = result.getResultNumber();

    %3 = "tf.NotEqual"(%1, %2) : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "tf.Yield"(%3) : (tensor<i1>) -> ()
  },  {
  ^bb0(%arg3: tensor<i32>, %arg4: tensor<*xf32>):
    %cst = arith.constant dense<1> : tensor<i32>
    %1 = "tf.Sub"(%arg3, %cst) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "tf.Yield"(%1, %arg4) : (tensor<i32>, tensor<*xf32>) -> ()

)
TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)


Base.metadata.create_all(bind=engine)


def override_get_db():
    try:
        db = TestingSessionLocal()
        yield db
    finally:
        db.close()


app.dependency_overrides[get_db] = override_get_db

client = TestClient(app)


def test_create_user():
    response = client.post(
        "/users/",

    // match the "func.return" within the function.
    //
    // So this would transform
    // func.func @f(...) -> ... {
    //     yield %x : foo
    // }
    // ...
    // func.call @f(...) -> bar
    //
    // to
    //
    // func.func @f(...) -> ... {
    //     yield %x : foo
    // }
    // ...
    // func.call f(...) -> foo
    auto symbol_uses = f.getSymbolUses(f->getParentOp());

//
// For greater control over the traversal of each subtree, use [Inspect].
func Preorder(root Node) iter.Seq[Node] {
	return func(yield func(Node) bool) {
		ok := true
		Inspect(root, func(n Node) bool {
			if n != nil {
				// yield must not be called once ok is false.
				ok = ok && yield(n)
			}
			return ok
		})
	}

    我们将`SessionLocal()`请求的创建和处理放在一个`try`块中。

    然后我们在finally块中关闭它。

    通过这种方式，我们确保数据库会话在请求后始终关闭。即使在处理请求时出现异常。

    但是您不能从退出代码中引发另一个异常（在yield之后）。可以查阅 [Dependencies with yield and HTTPException](https://fastapi.tiangolo.com/zh/tutorial/dependencies/dependencies-with-yield/#dependencies-with-yield-and-httpexception)

*然后，当在路径操作函数*中使用依赖项时，我们使用`Session`，直接从 SQLAlchemy 导入的类型声明它。

*这将为我们在路径操作函数*中提供更好的编辑器支持，因为编辑器将知道`db`参数的类型`Session`：