@alloy-js/csharp 0.16.0 → 0.17.0

package/src/components/Declaration.tsx

@@ -1,5 +1,5 @@
 import * as core from "@alloy-js/core";
-import { createCSharpSymbol } from "../symbols/csharp-output-symbol.js";
+import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
 
 // properties for creating a declaration
 export interface DeclarationProps {
@@ -10,6 +10,9 @@ export interface DeclarationProps {
 
 // declares a symbol in the program (class, enum, interface etc)
 export function Declaration(props: DeclarationProps) {
-  const sym = createCSharpSymbol(props);
+  const sym = new CSharpOutputSymbol(props.name, {
+    refkeys: props.refkey,
+  });
+
   return <core.Declaration symbol={sym}>{props.children}</core.Declaration>;
 }

package/src/components/Enum.tsx

@@ -2,7 +2,7 @@ import * as core from "@alloy-js/core";
 import { AccessModifier, getAccessModifier } from "../modifiers.js";
 import { useCSharpNamePolicy } from "../name-policy.js";
 import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
-import { createCSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
+import { CSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
 import { Name } from "./Name.jsx";
 
 // properties for creating an enum
@@ -18,34 +18,32 @@ export function Enum(props: EnumProps) {
   const name = useCSharpNamePolicy().getName(props.name!, "enum");
   const scope = useCSharpScope();
 
-  const thisEnumSymbol = scope.binder.createSymbol<CSharpOutputSymbol>({
-    name: name,
+  const thisEnumSymbol = new CSharpOutputSymbol(name, {
     scope,
-    refkey: props.refkey ?? core.refkey(props.name),
+    refkeys: props.refkey ?? core.refkey(props.name),
   });
 
   // this creates a new scope for the enum definition.
   // members will automatically "inherit" this scope so
   // that refkeys to them will produce the fully-qualified
   // name e.g. Foo.Bar.
-  const thisEnumScope = createCSharpMemberScope(
-    scope.binder,
-    scope,
-    thisEnumSymbol,
-    "enum-decl",
-  );
+  const thisEnumScope = new CSharpMemberScope("enum-decl", {
+    parent: scope,
+    owner: thisEnumSymbol,
+  });
 
-  return (
-    <core.Declaration symbol={thisEnumSymbol}>
-      {getAccessModifier(props.accessModifier)}enum <Name />
-      {!props.children && ";"}
-      {props.children && (
-        <core.Scope value={thisEnumScope}>
-          <core.Block newline>{props.children}</core.Block>
-        </core.Scope>
-      )}
-    </core.Declaration>
-  );
+  if (thisEnumScope.owner)
+    return (
+      <core.Declaration symbol={thisEnumSymbol}>
+        {getAccessModifier(props.accessModifier)}enum <Name />
+        {!props.children && ";"}
+        {props.children && (
+          <core.Scope value={thisEnumScope}>
+            <core.Block newline>{props.children}</core.Block>
+          </core.Scope>
+        )}
+      </core.Declaration>
+    );
 }
 
 // properties for creating a C# enum member
@@ -64,10 +62,9 @@ export function EnumMember(props: EnumMemberProps) {
   }
 
   const name = useCSharpNamePolicy().getName(props.name, "enum-member");
-  const thisEnumValueSymbol = scope.binder.createSymbol<CSharpOutputSymbol>({
-    name: name,
+  const thisEnumValueSymbol = new CSharpOutputSymbol(name, {
     scope,
-    refkey: props.refkey ?? core.refkey(props.name),
+    refkeys: props.refkey ?? core.refkey(props.name),
   });
 
   return (

package/src/components/Namespace.tsx

@@ -1,5 +1,5 @@
 import * as core from "@alloy-js/core";
-import { createCSharpNamespaceScope } from "../symbols/scopes.js";
+import { CSharpNamespaceScope } from "../symbols/scopes.js";
 
 // contains the info for the current namespace
 export interface NamespaceContext {
@@ -21,11 +21,7 @@ export interface NamespaceProps {
 
 // a C# namespace. contains one or more source files
 export function Namespace(props: NamespaceProps) {
-  const scope = createCSharpNamespaceScope(
-    core.useBinder(),
-    core.useScope(),
-    props.name,
-  );
+  const scope = new CSharpNamespaceScope(props.name);
 
   const namespaceCtx: NamespaceContext = {
     name: props.name,

package/src/components/Parameters.tsx

@@ -24,10 +24,9 @@ export function Parameter(props: ParameterProps) {
     );
   }
 
-  const memberSymbol = scope.binder.createSymbol<CSharpOutputSymbol>({
-    name: name,
+  const memberSymbol = new CSharpOutputSymbol(name, {
     scope,
-    refkey: props.refkey ?? core.refkey(props.name),
+    refkeys: props.refkey ?? core.refkey(props.name),
   });
 
   return (

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