@alloy-js/csharp 0.20.0-dev.2 → 0.20.0-dev.4

package/src/scopes/source-file.ts

@@ -0,0 +1,67 @@
+import {
+  OutputScope,
+  OutputScopeOptions,
+  shallowReactive,
+  track,
+  TrackOpTypes,
+  trigger,
+  TriggerOpTypes,
+  useScope,
+} from "@alloy-js/core";
+import { NamespaceSymbol } from "../symbols/namespace.js";
+import { CSharpLexicalScope } from "./lexical.js";
+import { CSharpNamespaceScope } from "./namespace.js";
+
+export class CSharpSourceFileScope extends CSharpLexicalScope {
+  #usings = shallowReactive<Set<NamespaceSymbol>>(new Set());
+
+  constructor(
+    name: string,
+    parent?: CSharpNamespaceScope,
+    options?: OutputScopeOptions,
+  ) {
+    super(name, parent, options);
+  }
+  get usings() {
+    return this.#usings;
+  }
+
+  get parent() {
+    return super.parent! as CSharpNamespaceScope;
+  }
+
+  set parent(v: CSharpNamespaceScope) {
+    super.parent = v;
+  }
+
+  addUsing(using: NamespaceSymbol) {
+    this.#usings.add(using);
+  }
+
+  #hasBlockNamespace: boolean = false;
+  get hasBlockNamespace() {
+    track(this, TrackOpTypes.GET, "hasBlockNamespace");
+    return this.#hasBlockNamespace;
+  }
+
+  set hasBlockNamespace(value: boolean) {
+    const old = this.#hasBlockNamespace;
+    if (this.#hasBlockNamespace === value) {
+      return;
+    }
+    this.#hasBlockNamespace = value;
+    trigger(this, TriggerOpTypes.SET, "hasBlockNamespace", value, old);
+  }
+}
+
+export function useSourceFileScope() {
+  let scope: OutputScope | undefined = useScope();
+  while (scope) {
+    if (scope instanceof CSharpSourceFileScope) {
+      return scope;
+    }
+    scope = scope.parent;
+  }
+
+  return undefined;
+}

package/src/symbols/csharp.ts

@@ -0,0 +1,307 @@
+import {
+  Namekey,
+  OutputDeclarationSpace,
+  OutputMemberSpace,
+  OutputSpace,
+  OutputSymbol,
+  OutputSymbolOptions,
+  track,
+  TrackOpTypes,
+  trigger,
+  TriggerOpTypes,
+  watch,
+} from "@alloy-js/core";
+import { AccessModifiers, NonAccessModifiers } from "../modifiers.js";
+import type { CSharpScope } from "../scopes/csharp.js";
+import { NamespaceSymbol } from "./namespace.js";
+
+export type DeclaredAccessibility =
+  | "private"
+  | "protected"
+  | "internal"
+  | "public";
+
+export interface CSharpSymbolOptions extends OutputSymbolOptions {
+  /**
+   * The accessibility of the symbol.
+   */
+  accessibility?: DeclaredAccessibility;
+  isOverride?: boolean;
+  isAbstract?: boolean;
+  isVirtual?: boolean;
+  isStatic?: boolean;
+  isSealed?: boolean;
+  isExtern?: boolean;
+  isReadOnly?: boolean;
+}
+
+export type CSharpSymbolKinds =
+  | "symbol"
+  | "named-type"
+  | "method"
+  | "field"
+  | "property"
+  | "namespace"
+  | "event";
+/**
+ * This is the base type for all symbols in C#.
+ *
+ * Many subtypes of this symbol exist for specific purposes. However, this symbol
+ * may be used in cases where a more specific symbol is not required.
+ *
+ * @remarks
+ *
+ * This is roughly equivalent to the Roslyn ISymbol interface:
+ * https://learn.microsoft.com/en-us/dotnet/api/microsoft.codeanalysis.isymbol?view=roslyn-dotnet-4.13.0
+ */
+export class CSharpSymbol extends OutputSymbol {
+  public readonly symbolKind: CSharpSymbolKinds = "symbol";
+
+  constructor(
+    name: string | Namekey,
+    spaces: OutputSpace[] | OutputSpace | undefined,
+    options: CSharpSymbolOptions = {},
+  ) {
+    super(name, spaces, options);
+
+    this.#accessibility = options.accessibility;
+    this.#isAbstract = options.isAbstract ?? false;
+    this.#isVirtual = options.isVirtual ?? false;
+    this.#isStatic = options.isStatic ?? false;
+    this.#isOverride = options.isOverride ?? false;
+    this.#isSealed = options.isSealed ?? false;
+    this.#isExtern = options.isExtern ?? false;
+    this.#isReadOnly = options.isReadOnly ?? false;
+  }
+
+  get enclosingNamespace(): NamespaceSymbol | undefined {
+    if (this.spaces.length === 0) {
+      return undefined;
+    }
+
+    // todo: probably need to validate that a symbol can't belong to spaces in
+    // multiple namespaces.
+    const firstSpace = this.spaces[0];
+
+    if (firstSpace instanceof OutputMemberSpace) {
+      // this symbol is a member of something, so get the enclosing namespace from
+      // the symbol.
+
+      if (firstSpace.symbol.constructor.name === "NamespaceSymbol") {
+        // this is a namespace symbol, so return the namespace symbol itself.
+        // can't use instanceof here due to circular reference issues.
+        return firstSpace.symbol as NamespaceSymbol;
+      }
+
+      return (firstSpace.symbol as CSharpSymbol).enclosingNamespace;
+    } else if (firstSpace instanceof OutputDeclarationSpace) {
+      // this symbol is in a lexical scope, so get the namespace symbol from the
+      // scope.
+      return (firstSpace.scope as CSharpScope).enclosingNamespace;
+    }
+    throw new Error("No place to get namespace symbol from");
+
+    return undefined;
+  }
+
+  #accessibility: DeclaredAccessibility | undefined;
+  get accessibility() {
+    track(this, TrackOpTypes.GET, "accessibility");
+    return this.#accessibility;
+  }
+
+  set accessibility(value: DeclaredAccessibility | undefined) {
+    const old = this.#accessibility;
+    if (old === value) {
+      return;
+    }
+
+    this.#accessibility = value;
+
+    trigger(this, TriggerOpTypes.SET, "accessibility", value, old);
+  }
+
+  copy() {
+    const options = this.getCopyOptions();
+    const copy = new CSharpSymbol(this.name, undefined, {
+      ...options,
+      accessibility: this.#accessibility,
+      isStatic: this.#isStatic,
+      isVirtual: this.#isVirtual,
+      isAbstract: this.#isAbstract,
+      isOverride: this.#isOverride,
+      isSealed: this.#isSealed,
+      isExtern: this.#isExtern,
+      isReadOnly: this.#isReadOnly,
+    });
+    this.initializeCopy(copy);
+
+    watch(
+      () => this.accessibility,
+      (newAccessibility) => {
+        copy.accessibility = newAccessibility;
+      },
+    );
+
+    return copy;
+  }
+
+  /**
+   * Whether this symbol is static.
+   */
+  get isStatic(): boolean {
+    track(this, TrackOpTypes.GET, "isStatic");
+    return this.#isStatic;
+  }
+
+  set isStatic(value: boolean) {
+    const old = this.#isStatic;
+    if (old === value) {
+      return;
+    }
+
+    this.#isStatic = value;
+
+    trigger(this, TriggerOpTypes.SET, "isStatic", value, old);
+  }
+  #isStatic: boolean = false;
+
+  /**
+   * Whether this symbol is virtual.
+   */
+  get isVirtual(): boolean {
+    track(this, TrackOpTypes.GET, "isVirtual");
+    return this.#isVirtual;
+  }
+  set isVirtual(value: boolean) {
+    const old = this.#isVirtual;
+    if (old === value) {
+      return;
+    }
+
+    this.#isVirtual = value;
+
+    trigger(this, TriggerOpTypes.SET, "isVirtual", value, old);
+  }
+
+  #isVirtual: boolean = false;
+
+  /**
+   * Whether this symbol is abstract.
+   */
+  get isAbstract(): boolean {
+    track(this, TrackOpTypes.GET, "isAbstract");
+    return this.#isAbstract;
+  }
+  set isAbstract(value: boolean) {
+    const old = this.#isAbstract;
+    if (old === value) {
+      return;
+    }
+
+    this.#isAbstract = value;
+
+    trigger(this, TriggerOpTypes.SET, "isAbstract", value, old);
+  }
+  #isAbstract: boolean = false;
+
+  /**
+   * Whether this symbol is override.
+   */
+  get isOverride(): boolean {
+    track(this, TrackOpTypes.GET, "isOverride");
+    return this.#isOverride;
+  }
+  set isOverride(value: boolean) {
+    const old = this.#isOverride;
+    if (old === value) {
+      return;
+    }
+
+    this.#isOverride = value;
+
+    trigger(this, TriggerOpTypes.SET, "isOverride", value, old);
+  }
+  #isOverride: boolean = false;
+
+  /**
+   * Whether this symbol is sealed.
+   */
+  get isSealed(): boolean {
+    track(this, TrackOpTypes.GET, "isSealed");
+    return this.#isSealed;
+  }
+  set isSealed(value: boolean) {
+    const old = this.#isSealed;
+    if (old === value) {
+      return;
+    }
+
+    this.#isSealed = value;
+
+    trigger(this, TriggerOpTypes.SET, "isSealed", value, old);
+  }
+  #isSealed: boolean = false;
+
+  /**
+   * Whether this symbol is extern.
+   */
+  get isExtern(): boolean {
+    track(this, TrackOpTypes.GET, "isExtern");
+    return this.#isExtern;
+  }
+  set isExtern(value: boolean) {
+    const old = this.#isExtern;
+    if (old === value) {
+      return;
+    }
+
+    this.#isExtern = value;
+
+    trigger(this, TriggerOpTypes.SET, "isExtern", value, old);
+  }
+  #isExtern: boolean = false;
+
+  /**
+   * Whether this symbol is readonly.
+   */
+  get isReadOnly(): boolean {
+    track(this, TrackOpTypes.GET, "isReadOnly");
+    return this.#isReadOnly;
+  }
+  set isReadOnly(value: boolean) {
+    const old = this.#isReadOnly;
+    if (old === value) {
+      return;
+    }
+
+    this.#isReadOnly = value;
+
+    trigger(this, TriggerOpTypes.SET, "isReadOnly", value, old);
+  }
+  #isReadOnly: boolean = false;
+}
+
+export function accessibilityFromProps(props: AccessModifiers) {
+  for (const key of ["public", "internal", "protected", "private"] as const) {
+    if (props[key]) {
+      return key;
+    }
+  }
+
+  return "private";
+}
+
+export function nonAccessibilityFromProps(
+  props: NonAccessModifiers,
+): CSharpSymbolOptions {
+  return {
+    isOverride: props.override ?? false,
+    isAbstract: props.abstract ?? false,
+    isVirtual: props.virtual ?? false,
+    isStatic: props.static ?? false,
+    isSealed: props.sealed ?? false,
+    isExtern: props.extern ?? false,
+    isReadOnly: props.readOnly ?? false,
+  };
+}

package/src/symbols/factories.ts

@@ -0,0 +1,199 @@
+import {
+  Namekey,
+  NamePolicyGetter,
+  OutputSymbolOptions,
+  useBinder,
+} from "@alloy-js/core";
+import { getGlobalNamespace } from "../contexts/global-namespace.js";
+import { CSharpElements, useCSharpNamePolicy } from "../name-policy.js";
+import { CSharpClassScope } from "../scopes/class.js";
+import { useCSharpScope, useNamedTypeScope } from "../scopes/contexts.js";
+import { CSharpScope } from "../scopes/csharp.js";
+import { CSharpLexicalScope } from "../scopes/lexical.js";
+import { CSharpMethodScope } from "../scopes/method.js";
+import { CSharpNamedTypeScope } from "../scopes/named-type.js";
+import {
+  CSharpNamespaceScope,
+  useEnclosingNamespaceScope,
+} from "../scopes/namespace.js";
+import { CSharpSourceFileScope } from "../scopes/source-file.js";
+import { CSharpSymbol, CSharpSymbolOptions } from "./csharp.js";
+import { MethodKinds, MethodSymbol } from "./method.js";
+import { NamedTypeSymbol, NamedTypeTypeKind } from "./named-type.js";
+import { NamespaceSymbol } from "./namespace.js";
+
+/**
+ * Create a symbol for a parameter in the current method scope.
+ */
+export function createParameterSymbol(
+  originalName: string | Namekey,
+  options: CSharpSymbolOptions = {},
+) {
+  const scope = useCSharpScope();
+  if (
+    !(scope instanceof CSharpMethodScope) &&
+    !(scope instanceof CSharpClassScope)
+  ) {
+    throw new Error(
+      `Can't create parameter symbol outside of a method or class scope.`,
+    );
+  }
+  return new CSharpSymbol(
+    originalName,
+    scope.parameters,
+    withNamePolicy(options, "parameter"),
+  );
+}
+
+export interface CreateTypeParameterSymbolOptions extends CSharpSymbolOptions {
+  scope?: CSharpMethodScope | CSharpNamedTypeScope;
+}
+export function createTypeParameterSymbol(
+  originalName: string | Namekey,
+  options: CreateTypeParameterSymbolOptions = {},
+) {
+  const scope = options.scope ?? useCSharpScope();
+  if (
+    !(scope instanceof CSharpMethodScope) &&
+    !(scope instanceof CSharpNamedTypeScope)
+  ) {
+    throw new Error(
+      "Can't create a type parameter symbol outside of a method or named type scope.",
+    );
+  }
+
+  return new CSharpSymbol(
+    originalName,
+    scope.typeParameters,
+    withNamePolicy(options, "type-parameter"),
+  );
+}
+
+export function createFieldSymbol(
+  originalName: string | Namekey,
+  options: CSharpSymbolOptions = {},
+) {
+  let nameElement: CSharpElements = "class-member-private";
+
+  if (
+    options.accessibility === "public" ||
+    options.accessibility === "internal" ||
+    options.accessibility === "protected"
+  ) {
+    nameElement = "class-member-public";
+  }
+
+  const scope = useNamedTypeScope();
+
+  if (
+    scope.ownerSymbol.typeKind !== "class" &&
+    scope.ownerSymbol.typeKind !== "struct"
+  ) {
+    throw new Error(`Can't define a field outside of a class or struct.`);
+  }
+
+  return new CSharpSymbol(
+    originalName,
+    scope.members,
+    withNamePolicy(options, nameElement),
+  );
+}
+
+export function createNamedTypeSymbol(
+  name: string | Namekey,
+  kind: NamedTypeTypeKind,
+  options?: OutputSymbolOptions,
+) {
+  const scope = useNamedTypeScope();
+  return new NamedTypeSymbol(name, scope.ownerSymbol.members, kind, options);
+}
+
+export function createNamespaceSymbol(name: string) {
+  const scope = useEnclosingNamespaceScope();
+  const nsSymbol = scope?.ownerSymbol ?? getGlobalNamespace(useBinder());
+  if (nsSymbol.members.symbolNames.has(name)) {
+    return nsSymbol.members.symbolNames.get(name)! as NamespaceSymbol;
+  }
+  return new NamespaceSymbol(name, nsSymbol);
+}
+
+export interface CreateMethodSymbolOptions extends CSharpSymbolOptions {
+  methodKind?: MethodKinds;
+}
+
+export function createMethodSymbol(
+  originalName: string | Namekey,
+  options: CreateMethodSymbolOptions = {},
+) {
+  const scope = useNamedTypeScope();
+
+  if (
+    scope.ownerSymbol.typeKind !== "class" &&
+    scope.ownerSymbol.typeKind !== "interface" &&
+    scope.ownerSymbol.typeKind !== "struct"
+  ) {
+    throw new Error(
+      `Can't define a method outside of a class, interface, or struct.`,
+    );
+  }
+
+  return new MethodSymbol(
+    originalName,
+    scope.members,
+    options.methodKind ?? "ordinary",
+    withNamePolicy(options, "class-method"),
+  );
+}
+
+export function createPropertySymbol(
+  name: string | Namekey,
+  options: CSharpSymbolOptions,
+) {
+  const scope = useNamedTypeScope();
+  return new CSharpSymbol(
+    name,
+    scope.members,
+    withNamePolicy(options, "class-property"),
+  );
+}
+
+export function createVariableSymbol(
+  originalName: string | Namekey,
+  options: CSharpSymbolOptions = {},
+) {
+  let scope = useCSharpScope();
+  if (
+    scope instanceof CSharpNamespaceScope &&
+    scope.ownerSymbol === getGlobalNamespace(scope.ownerSymbol.binder)
+  ) {
+    // allow top-level variables in the global namespace, which are local to the source file.
+    scope = scope.parent as CSharpScope;
+
+    if (!(scope instanceof CSharpSourceFileScope)) {
+      throw new Error(
+        "Variable declarations must be in the global namespace or within a lexical scope.",
+      );
+    }
+  }
+
+  if (!(scope instanceof CSharpLexicalScope)) {
+    throw new Error(
+      `Can't create variable symbol outside of a lexical scope, got a ${scope.constructor.name}.`,
+    );
+  }
+  return new CSharpSymbol(
+    originalName,
+    scope.localVariables,
+    withNamePolicy(options, "variable"),
+  );
+}
+
+function withNamePolicy<T extends { namePolicy?: NamePolicyGetter }>(
+  options: T,
+  elementType: CSharpElements,
+) {
+  return {
+    ...options,
+    namePolicy: options.namePolicy ?? useCSharpNamePolicy().for(elementType),
+  };
+}

package/src/symbols/index.ts

@@ -1,3 +1,6 @@
-export * from "./csharp-output-symbol.js";
+export * from "./csharp.js";
+export * from "./factories.js";
+export * from "./method.js";
+export * from "./named-type.js";
+export * from "./namespace.js";
 export * from "./reference.js";
-export * from "./scopes.js";

package/src/symbols/method.ts

@@ -0,0 +1,26 @@
+import { Namekey, OutputSpace } from "@alloy-js/core";
+import { CSharpSymbol, CSharpSymbolOptions } from "./csharp.js";
+
+export type MethodKinds = "ordinary" | "constructor";
+
+/**
+ * A symbol for a method or constructor of a class, interface, or struct.
+ */
+export class MethodSymbol extends CSharpSymbol {
+  public readonly symbolKind = "method";
+
+  #methodKind: MethodKinds;
+  get methodKind() {
+    return this.#methodKind;
+  }
+
+  constructor(
+    name: string | Namekey,
+    spaces: OutputSpace | undefined,
+    kind: MethodKinds,
+    options: CSharpSymbolOptions = {},
+  ) {
+    super(name, spaces, options);
+    this.#methodKind = kind;
+  }
+}

package/src/symbols/named-type.ts

@@ -0,0 +1,54 @@
+import { Namekey, OutputSpace, OutputSymbolOptions } from "@alloy-js/core";
+import { CSharpSymbol } from "./csharp.js";
+
+// represents a symbol from a .cs file. Class, enum, interface etc.
+
+export type NamedTypeTypeKind =
+  | "class"
+  | "interface"
+  | "enum"
+  | "namespace"
+  | "struct"
+  | "record";
+export type NamedTypeSymbolKind = "named-type" | "namespace";
+
+/**
+ * A symbol for a named type in C# such as a class, interface, enum, and so
+ * forth. Named types are generally defined in a namespace, and can have members
+ * of their own.
+ */
+export class NamedTypeSymbol extends CSharpSymbol {
+  public readonly symbolKind: NamedTypeSymbolKind = "named-type";
+  public static readonly memberSpaces = ["members"];
+
+  constructor(
+    name: string | Namekey,
+    spaces: OutputSpace[] | OutputSpace | undefined,
+    kind: NamedTypeTypeKind,
+    options?: OutputSymbolOptions,
+  ) {
+    super(name, spaces, options);
+    this.#typeKind = kind;
+  }
+
+  #typeKind: NamedTypeTypeKind;
+  get typeKind() {
+    return this.#typeKind;
+  }
+
+  copy() {
+    const options = this.getCopyOptions();
+    const copy = new NamedTypeSymbol(
+      this.name,
+      undefined,
+      this.#typeKind,
+      options,
+    );
+    this.initializeCopy(copy);
+    return copy;
+  }
+
+  get members() {
+    return this.memberSpaceFor("members")!;
+  }
+}