Can oxc_semantic create bindings for class / interface / etc. members?

[simonbuchan]

It seems like it does allocate scopes for interface and class at least, but I don't see any actual members, e.g. the source:

interface x {
    value: number;
}

let x: x["value"] = 42;

class Foo {
  #x = 42;
  y = 420;

  bar() {
    console.log(this.#x);
  }
}

function greet(name: string) {
    console.log(`Hello, ${name}, my favorite number is ${x}!`);
}

Will output (trimmed):

Program {
  scope 0 {
    TSInterfaceDeclaration {
      BindingIdentifier(x) {
      }
      scope 1 {
        TSPropertySignature {
          PropertyKey(value) {
            IdentifierName(value) {
            }
          }
          TSTypeAnnotation {
            TSNumberKeyword {
            }
          }
        }
      }
    }
    VariableDeclaration {
      VariableDeclarator(x) {
        BindingIdentifier(x) {
        }
        TSTypeAnnotation {
          <snip>
        }
        NumericLiteral(42) {
        }
      }
    }
    Class(Foo) {
      BindingIdentifier(Foo) {
      }
      scope 2 {
        ClassBody {
          PropertyDefinition {
            PropertyKey(x) {
              PrivateIdentifier(x) {
              }
            }
            NumericLiteral(42) {
            }
          }
          PropertyDefinition {
            PropertyKey(y) {
              IdentifierName(y) {
              }
            }
            NumericLiteral(420) {
            }
          }
          MethodDefinition {
            PropertyKey(bar) {
              IdentifierName(bar) {
              }
            }
            Function(<anonymous>) {
              scope 3 {
                FormalParameters {
                }
                FunctionBody { <snip> }
              }
            }
          }
        }
      }
    }
    Function(greet) {
      scope 4 {
        BindingIdentifier(greet) {
        }
        FormalParameters { <snip> }
        FunctionBody { <snip> }
      }
    }
  }
}

Using

    #[derive(Default)]
    struct DebugVisit { indent: usize };

    impl<'a> Visit<'a> for DebugVisit {
        fn enter_node(&mut self, kind: AstKind<'a>) {
            let name = kind.debug_name();
            println!("{:indent$}{name} {{", "", indent = self.indent);
            self.indent += 2;
        }

        fn leave_node(&mut self, _kind: AstKind<'a>) {
            self.indent -= 2;
            println!("{:indent$}}}", "", indent = self.indent);
        }

        fn enter_scope(&mut self, _flags: ScopeFlags, scope_id: &Cell<Option<ScopeId>>) {
            let id = Idx::index(scope_id.get().unwrap());
            println!("{:indent$}scope {id} {{", "", indent = self.indent);
            self.indent += 2;
        }

        fn leave_scope(&mut self) {
            self.indent -= 2;
            println!("{:indent$}}}", "", indent = self.indent);
        }
    }

So it's definitely allocating scopes in the right place, but trying to dump the bindings doesn't actually list anything for them:

ScopeId(0) ScopeFlags(StrictMode | Top) : None
  greet: SymbolId(2)
  x: SymbolId(0)
  Foo: SymbolId(1)
ScopeId(1) ScopeFlags(StrictMode) : Some(ScopeId(0))
ScopeId(2) ScopeFlags(StrictMode) : Some(ScopeId(0))
ScopeId(3) ScopeFlags(StrictMode | Function) : Some(ScopeId(2))
ScopeId(4) ScopeFlags(StrictMode | Function) : Some(ScopeId(0))
  name: SymbolId(3)

Using:

    for scope_id in semantic.scoping().scope_descendants_from_root() {
        let parent = semantic.scoping().scope_parent_id(scope_id);
        let flags = semantic.scoping().scope_flags(scope_id);
        println!("{scope_id:?} {flags:?} : {parent:?}");
        for (name, &symbol_id) in semantic.scoping().get_bindings(scope_id) {
            println!("  {name}: {symbol_id:?}");
        }
    }

Am I missing some other pass / flag?