@alloy-js/csharp 0.16.0 → 0.18.0-dev.10

package/src/name-policy.ts

@@ -12,6 +12,7 @@ export type CSharpElements =
   | "class-member-private"
   | "class-member-public"
   | "class-method"
+  | "class-property"
   | "parameter"
   | "type-parameter";
 
@@ -26,6 +27,7 @@ export function createCSharpNamePolicy(): core.NamePolicy<CSharpElements> {
       case "class-member-public":
       case "class-method":
       case "type-parameter":
+      case "class-property":
         return changecase.pascalCase(name);
       case "constant":
         return changecase.constantCase(name);

package/src/symbols/csharp-output-symbol.ts

@@ -1,27 +1,22 @@
 import * as core from "@alloy-js/core";
-import { DeclarationProps } from "../components/Declaration.jsx";
 import { useNamespace } from "../components/Namespace.jsx";
 import { CSharpOutputScope } from "./scopes.js";
 
 // represents a symbol from a .cs file. Class, enum, interface etc.
-export interface CSharpOutputSymbol extends core.OutputSymbol {
-  scope: CSharpOutputScope;
-}
-
-// creates a new C# symbol
-export function createCSharpSymbol(props: DeclarationProps) {
-  const scope = core.useScope() as CSharpOutputScope;
 
-  const namespaceCtx = useNamespace();
-  if (!namespaceCtx) {
-    throw new Error("symbol must be declared inside a namespace");
+export class CSharpOutputSymbol extends core.OutputSymbol {
+  get scope() {
+    return super.scope as CSharpOutputScope;
+  }
+  set scope(value: CSharpOutputScope) {
+    super.scope = value;
   }
 
-  const sym = scope.binder.createSymbol<CSharpOutputSymbol>({
-    name: props.name!,
-    scope,
-    refkey: props.refkey ?? core.refkey(props.name),
-  });
-
-  return sym;
+  constructor(name: string, options?: core.OutputSymbolOptions) {
+    const namespaceCtx = useNamespace();
+    if (!namespaceCtx) {
+      throw new Error("symbol must be declared inside a namespace");
+    }
+    super(name, options);
+  }
 }

package/src/symbols/reference.ts

@@ -57,7 +57,7 @@ export function ref(refkey: core.Refkey): () => string {
       .filter((v) => {
         return v.kind === "member";
       })
-      .map((s) => s.owner);
+      .map((s) => s.owner!);
     syms.push(targetDeclaration);
 
     return syms.map((sym) => sym.name).join(".");

package/src/symbols/scopes.ts

@@ -2,21 +2,10 @@ import * as core from "@alloy-js/core";
 import { CSharpOutputSymbol } from "./csharp-output-symbol.js";
 
 // indicates that the scope for a symbols is at the namespace level
-export interface CSharpNamespaceScope extends core.OutputScope {
-  kind: "namespace";
-}
-
-// creates a new namespace scope
-export function createCSharpNamespaceScope(
-  binder: core.Binder,
-  parent: core.OutputScope | undefined,
-  name: string,
-): CSharpNamespaceScope {
-  return binder.createScope<CSharpNamespaceScope>({
-    kind: "namespace",
-    name,
-    parent,
-  });
+export class CSharpNamespaceScope extends core.OutputScope {
+  get kind() {
+    return "namespace";
+  }
 }
 
 // the kind of member scope. i.e. are we in an enum, class, etc
@@ -29,26 +18,18 @@ export type CSharpMemberScopeName =
 // indicates that the scope for a symbol resides within a type
 // e.g. for an enum value, class field etc, these would have
 // member scope where the owner is the containing type.
-export interface CSharpMemberScope extends core.OutputScope {
-  kind: "member";
-  name: CSharpMemberScopeName;
-  owner: CSharpOutputSymbol;
-}
+export class CSharpMemberScope extends core.OutputScope {
+  get kind() {
+    return "member";
+  }
+
+  get name() {
+    return super.name as CSharpMemberScopeName;
+  }
 
-// creates a new member scope.
-// parent is the owning symbol.
-export function createCSharpMemberScope(
-  binder: core.Binder,
-  parent: core.OutputScope,
-  owner: CSharpOutputSymbol,
-  name: CSharpMemberScopeName,
-): CSharpMemberScope {
-  return binder.createScope<CSharpMemberScope>({
-    kind: "member",
-    name: name,
-    owner,
-    parent,
-  });
+  get owner() {
+    return super.owner as CSharpOutputSymbol;
+  }
 }
 
 // contains the possible scopes where a declaration can reside