Inheritance/polymorphism fixes

.github/workflows/ci.yml

@@ -48,10 +48,10 @@ jobs:
       contents: write
       id-token: write
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.11'
 
@@ -99,7 +99,7 @@ jobs:
       contents: write
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
 
       - name: Set up Python
         uses: actions/setup-python@v6
@@ -109,10 +109,10 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          python -m pip install git+https://${{ secrets.GH_TOKEN }}@github.com/squidfunk/mkdocs-material-insiders.git
           python -m pip install mkdocs \
                                 mkdocs-autorefs \
                                 mkdocs-macros-plugin \
+                                mkdocs-material \
                                 mkdocs-material-extensions \
                                 mkdocs-redirects
           sudo apt-get update

CMakeLists.txt

@@ -241,6 +241,8 @@ set(CODON_HPPFILES
   codon/cir/transform/folding/const_prop.h
   codon/cir/transform/folding/folding.h
   codon/cir/transform/folding/rule.h
+  codon/cir/transform/lowering/async_for.h
+  codon/cir/transform/lowering/await.h
   codon/cir/transform/lowering/imperative.h
   codon/cir/transform/lowering/pipeline.h
   codon/cir/transform/manager.h
@@ -347,6 +349,8 @@ set(CODON_CPPFILES
   codon/cir/transform/folding/const_fold.cpp
   codon/cir/transform/folding/const_prop.cpp
   codon/cir/transform/folding/folding.cpp
+  codon/cir/transform/lowering/async_for.cpp
+  codon/cir/transform/lowering/await.cpp
   codon/cir/transform/lowering/imperative.cpp
   codon/cir/transform/lowering/pipeline.cpp
   codon/cir/transform/manager.cpp

codon/cir/analyze/dataflow/capture.cpp

@@ -649,6 +649,11 @@ struct CaptureTracker : public util::Operator {
                   [&](DerivedSet &dset) { dset.result.returnCaptures = true; });
   }
 
+  void handle(AwaitInstr *v) override {
+    forEachDSetOf(v->getValue(),
+                  [&](DerivedSet &dset) { dset.result.returnCaptures = true; });
+  }
+
   void handle(ThrowInstr *v) override {
     forEachDSetOf(v->getValue(), [&](DerivedSet &dset) { dset.setExternCaptured(); });
   }

codon/cir/analyze/dataflow/cfg.cpp

@@ -413,6 +413,11 @@ void CFVisitor::visit(const YieldInstr *v) {
   defaultInsert(v);
 }
 
+void CFVisitor::visit(const AwaitInstr *v) {
+  process(v->getValue());
+  defaultInsert(v);
+}
+
 void CFVisitor::visit(const ThrowInstr *v) {
   if (v->getValue())
     process(v->getValue());

codon/cir/analyze/dataflow/cfg.h

@@ -520,6 +520,7 @@ class CFVisitor : public util::ConstVisitor {
   void visit(const ContinueInstr *v) override;
   void visit(const ReturnInstr *v) override;
   void visit(const YieldInstr *v) override;
+  void visit(const AwaitInstr *v) override;
   void visit(const ThrowInstr *v) override;
   void visit(const FlowInstr *v) override;
   void visit(const dsl::CustomInstr *v) override;

codon/cir/analyze/module/side_effect.cpp

@@ -332,6 +332,10 @@ struct SideEfectAnalyzer : public util::ConstVisitor {
     set(v, max(Status::NO_CAPTURE, process(v->getValue())));
   }
 
+  void visit(const AwaitInstr *v) override {
+    set(v, max(Status::NO_CAPTURE, process(v->getValue())));
+  }
+
   void visit(const ThrowInstr *v) override {
     process(v->getValue());
     set(v, Status::UNKNOWN, Status::NO_CAPTURE);

codon/cir/flow.h

@@ -124,6 +124,8 @@ class ForFlow : public AcceptorExtend<ForFlow, Flow> {
   Var *var;
   /// parallel loop schedule, or null if none
   std::unique_ptr<transform::parallel::OMPSched> schedule;
+  /// true if loop is async
+  bool async;
 
 public:
   static const char NodeId;
@@ -132,11 +134,13 @@ class ForFlow : public AcceptorExtend<ForFlow, Flow> {
   /// @param iter the iterator
   /// @param body the body
   /// @param var the variable
+  /// @param schedule the parallel schedule
+  /// @param async true if loop is async
   /// @param name the flow's name
   ForFlow(Value *iter, Flow *body, Var *var,
           std::unique_ptr<transform::parallel::OMPSched> schedule = {},
-          std::string name = "")
-      : AcceptorExtend(std::move(name)), iter(iter), body(body), var(var),
+          bool async = false, std::string name = "")
+      : AcceptorExtend(std::move(name)), iter(iter), body(body), var(var), async(async),
         schedule(std::move(schedule)) {}
 
   /// @return the iter
@@ -184,6 +188,12 @@ class ForFlow : public AcceptorExtend<ForFlow, Flow> {
     schedule = std::move(s);
   }
 
+  /// @return true if async
+  bool isAsync() const { return async; }
+  /// Sets async status.
+  /// @param a true if async
+  void setAsync(bool a = true) { async = a; }
+
 protected:
   std::vector<Value *> doGetUsedValues() const override;
   int doReplaceUsedValue(id_t id, Value *newValue) override;

codon/cir/func.cpp

@@ -38,7 +38,7 @@ void Func::realize(types::Type *newType, const std::vector<std::string> &names)
 
   auto i = 0;
   for (auto *t : *funcType) {
-    args.push_back(getModule()->Nr<Var>(t, false, false, names[i]));
+    args.push_back(getModule()->Nr<Var>(t, false, false, false, names[i]));
     ++i;
   }
 }

codon/cir/func.h

@@ -16,6 +16,8 @@ class Func : public AcceptorExtend<Func, Var> {
   std::string unmangledName;
   /// whether the function is a generator
   bool generator;
+  /// whether the function is an async function
+  bool async;
   /// Parent type if func is a method, or null if not
   types::Type *parentType;
 
@@ -35,8 +37,8 @@ class Func : public AcceptorExtend<Func, Var> {
   /// Constructs an unrealized CIR function.
   /// @param name the function's name
   explicit Func(std::string name = "")
-      : AcceptorExtend(nullptr, true, false, std::move(name)), generator(false),
-        parentType(nullptr) {}
+      : AcceptorExtend(nullptr, true, false, false, std::move(name)), generator(false),
+        async(false), parentType(nullptr) {}
 
   /// Re-initializes the function with a new type and names.
   /// @param newType the function's new type
@@ -73,6 +75,12 @@ class Func : public AcceptorExtend<Func, Var> {
   /// @param v the new value
   void setGenerator(bool v = true) { generator = v; }
 
+  /// @return true if the function is an async function
+  bool isAsync() const { return async; }
+  /// Sets the function's async flag.
+  /// @param v the new value
+  void setAsync(bool v = true) { async = v; }
+
   /// @return the variable corresponding to the given argument name
   /// @param n the argument name
   Var *getArgVar(const std::string &n);

codon/cir/instr.cpp

@@ -142,6 +142,24 @@ int YieldInInstr::doReplaceUsedType(const std::string &name, types::Type *newTyp
   return 0;
 }
 
+const char AwaitInstr::NodeId = 0;
+
+int AwaitInstr::doReplaceUsedValue(id_t id, Value *newValue) {
+  if (value->getId() == id) {
+    value = newValue;
+    return 1;
+  }
+  return 0;
+}
+
+int AwaitInstr::doReplaceUsedType(const std::string &name, types::Type *newType) {
+  if (type->getName() == name) {
+    type = newType;
+    return 1;
+  }
+  return 0;
+}
+
 const char TernaryInstr::NodeId = 0;
 
 int TernaryInstr::doReplaceUsedValue(id_t id, Value *newValue) {

codon/cir/instr.h

@@ -331,7 +331,7 @@ class YieldInInstr : public AcceptorExtend<YieldInInstr, Instr> {
   /// @param v the new value
   void setSuspending(bool v = true) { suspend = v; }
 
-  /// Sets the type being inspected
+  /// Sets the type.
   /// @param t the new type
   void setType(types::Type *t) { type = t; }
 
@@ -477,6 +477,7 @@ class ReturnInstr : public AcceptorExtend<ReturnInstr, ControlFlowInstr> {
   int doReplaceUsedValue(id_t id, Value *newValue) override;
 };
 
+/// Instr representing a yield statement.
 class YieldInstr : public AcceptorExtend<YieldInstr, Instr> {
 private:
   /// the value
@@ -509,6 +510,50 @@ class YieldInstr : public AcceptorExtend<YieldInstr, Instr> {
   int doReplaceUsedValue(id_t id, Value *newValue) override;
 };
 
+/// Instr representing an await statement.
+class AwaitInstr : public AcceptorExtend<AwaitInstr, Instr> {
+private:
+  /// the value
+  Value *value;
+  /// the type of the result
+  types::Type *type;
+  /// true if argument is a generator (e.g. custom __await__)
+  bool generator;
+
+public:
+  static const char NodeId;
+
+  explicit AwaitInstr(Value *value, types::Type *type, bool generator = false,
+                      std::string name = "")
+      : AcceptorExtend(std::move(name)), value(value), type(type),
+        generator(generator) {}
+
+  /// @return the value
+  Value *getValue() { return value; }
+  /// @return the value
+  const Value *getValue() const { return value; }
+  /// Sets the value.
+  /// @param v the new value
+  void setValue(Value *v) { value = v; }
+
+  /// Sets the type.
+  /// @param t the new type
+  void setType(types::Type *t) { type = t; }
+
+  /// @return whether argument is a generator
+  bool isGenerator() const { return generator; }
+  /// Sets generator status
+  /// @param g the new value
+  void setGenerator(bool g = true) { generator = g; }
+
+protected:
+  types::Type *doGetType() const override { return type; }
+  std::vector<Value *> doGetUsedValues() const override { return {value}; }
+  std::vector<types::Type *> doGetUsedTypes() const override { return {type}; }
+  int doReplaceUsedValue(id_t id, Value *newValue) override;
+  int doReplaceUsedType(const std::string &name, types::Type *newType) override;
+};
+
 class ThrowInstr : public AcceptorExtend<ThrowInstr, Instr> {
 private:
   /// the value