@alloy-js/csharp 0.20.0-dev.1 → 0.20.0-dev.10

package/src/components/var/declaration.tsx

@@ -1,6 +1,11 @@
-import { Children, DeclarationProps, Name, Refkey } from "@alloy-js/core";
-import { useCSharpNamePolicy } from "../../name-policy.js";
-import { Declaration } from "../Declaration.jsx";
+import {
+  Children,
+  Declaration,
+  DeclarationProps,
+  Name,
+  Refkey,
+} from "@alloy-js/core";
+import { createVariableSymbol } from "../../symbols/factories.js";
 
 /** Props for {@link VarDeclaration} component */
 export interface VarDeclarationProps
@@ -37,10 +42,11 @@ export interface VarDeclarationProps
  * ```
  */
 export function VarDeclaration(props: VarDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "variable");
-
+  const sym = createVariableSymbol(props.name, {
+    refkeys: props.refkey,
+  });
   return (
-    <Declaration name={name} refkey={props.refkey}>
+    <Declaration symbol={sym}>
       {props.type ?? "var"} <Name /> = {props.children};
     </Declaration>
   );

package/src/contexts/format-options.ts

@@ -0,0 +1,14 @@
+import {
+  CommonFormatOptions,
+  createFormatOptionsContextFor,
+} from "@alloy-js/core";
+
+export interface CSharpFormatOptions extends CommonFormatOptions {}
+
+export const {
+  Provider: CSharpFormatOptions,
+  useFormatOptions: useCsharpFormatOptions,
+} = createFormatOptionsContextFor<CSharpFormatOptions>("csharp", {
+  tabWidth: 4,
+  printWidth: 120,
+});

package/src/contexts/global-namespace.ts

@@ -0,0 +1,29 @@
+import { Binder, useBinder } from "@alloy-js/core";
+import { NamespaceSymbol } from "../symbols/namespace.js";
+
+export function useGlobalNamespace() {
+  const binder = useBinder();
+  return getGlobalNamespace(binder);
+}
+
+const globalNamespaces = new WeakMap<Binder, NamespaceSymbol>();
+const defaultGlobalNamespace = new NamespaceSymbol("global", undefined, {
+  isGlobal: true,
+});
+export function getGlobalNamespace(binder: Binder | undefined) {
+  if (!binder) {
+    return defaultGlobalNamespace;
+  }
+
+  let namespace = globalNamespaces.get(binder);
+
+  if (!namespace) {
+    namespace = new NamespaceSymbol("global", undefined, {
+      binder,
+      isGlobal: true,
+    });
+    globalNamespaces.set(binder, namespace);
+  }
+
+  return namespace;
+}

package/src/contexts/namespace.ts

@@ -0,0 +1,13 @@
+import { ComponentContext, createContext, useContext } from "@alloy-js/core";
+import { NamespaceSymbol } from "../symbols/namespace.js";
+
+export interface NamespaceContext {
+  symbol: NamespaceSymbol;
+}
+
+export const NamespaceContext: ComponentContext<NamespaceContext> =
+  createContext();
+
+export function useNamespaceContext() {
+  return useContext(NamespaceContext);
+}

package/src/index.ts

@@ -1,4 +1,6 @@
 export * from "./components/index.js";
+export * from "./contexts/format-options.js";
 export * from "./modifiers.js";
 export * from "./name-policy.js";
+export * from "./scopes/index.js";
 export * from "./symbols/index.js";

package/src/modifiers.ts

@@ -10,6 +10,20 @@ export interface AccessModifiers {
   readonly file?: boolean;
 }
 
+export interface NonAccessModifiers {
+  readonly override?: boolean;
+  readonly abstract?: boolean;
+  readonly virtual?: boolean;
+  readonly static?: boolean;
+  readonly sealed?: boolean;
+  readonly extern?: boolean;
+  readonly readOnly?: boolean;
+}
+
+export interface DeclarationModifiers
+  extends AccessModifiers,
+    NonAccessModifiers {}
+
 export const getAccessModifier = makeModifiers<AccessModifiers>([
   "public",
   "protected",

package/src/scopes/class.ts

@@ -0,0 +1,12 @@
+import type { OutputSpace } from "@alloy-js/core";
+import { CSharpNamedTypeScope } from "./named-type.js";
+
+export class CSharpClassScope extends CSharpNamedTypeScope {
+  /**
+   * For now, we stuff class parameters into the member scope. This is to ensure
+   * name conflicts are handled correctly.
+   */
+  get parameters(): OutputSpace {
+    return this.members;
+  }
+}

package/src/scopes/contexts.ts

@@ -0,0 +1,45 @@
+import { useScope } from "@alloy-js/core";
+import { CSharpScope } from "./csharp.js";
+import { CSharpLexicalScope } from "./lexical.js";
+import { CSharpMethodScope } from "./method.js";
+import { CSharpNamedTypeScope } from "./named-type.js";
+
+export function useCSharpScope() {
+  const scope = useScope();
+  if (!(scope instanceof CSharpScope)) {
+    throw new Error("Expected a C# scope, got a different kind of scope.");
+  }
+
+  return scope;
+}
+
+export function useNamedTypeScope() {
+  const scope = useCSharpScope();
+  if (!(scope instanceof CSharpNamedTypeScope)) {
+    throw new Error(
+      "Expected a named type scope, got a " + scope.constructor.name,
+    );
+  }
+
+  return scope;
+}
+
+export function useMethodScope() {
+  const scope = useScope();
+  if (!(scope instanceof CSharpMethodScope)) {
+    throw new Error(
+      `Expected a method scope, but got ${scope.constructor.name}.`,
+    );
+  }
+  return scope;
+}
+
+export function useLexicalScope() {
+  const scope = useScope();
+  if (!(scope instanceof CSharpLexicalScope)) {
+    throw new Error(
+      `Expected a lexical scope, but got ${scope.constructor.name}.`,
+    );
+  }
+  return scope;
+}

package/src/scopes/csharp.ts

@@ -0,0 +1,23 @@
+import { OutputScope, OutputScopeOptions } from "@alloy-js/core";
+import type { CSharpSymbol } from "../symbols/csharp.js";
+import { NamespaceSymbol } from "../symbols/namespace.js";
+
+export class CSharpScope extends OutputScope {
+  constructor(
+    name: string,
+    parent: CSharpScope | undefined,
+    options?: OutputScopeOptions,
+  ) {
+    super(name, parent, options);
+    this.#namespaceSymbol = parent?.enclosingNamespace;
+  }
+
+  #namespaceSymbol: NamespaceSymbol | undefined;
+  get enclosingNamespace() {
+    return this.#namespaceSymbol;
+  }
+
+  get ownerSymbol(): CSharpSymbol | undefined {
+    return super.ownerSymbol as CSharpSymbol | undefined;
+  }
+}

package/src/scopes/factories.ts

@@ -0,0 +1,45 @@
+import { OutputScopeOptions } from "@alloy-js/core";
+import { NamedTypeSymbol } from "../symbols/named-type.js";
+import { CSharpClassScope } from "./class.js";
+import { useCSharpScope, useNamedTypeScope } from "./contexts.js";
+import { CSharpMethodScope } from "./method.js";
+import { CSharpNamedTypeScope } from "./named-type.js";
+import { CSharpSourceFileScope } from "./source-file.js";
+
+export function createNamedTypeScope(
+  ownerSymbol: NamedTypeSymbol,
+  options: OutputScopeOptions = {},
+) {
+  const currentScope = useCSharpScope();
+  if (
+    !(currentScope instanceof CSharpNamedTypeScope) &&
+    !(currentScope instanceof CSharpSourceFileScope)
+  ) {
+    throw new Error(
+      "Can't create C# type declaration scope inside of " +
+        currentScope.constructor.name,
+    );
+  }
+
+  return new CSharpNamedTypeScope(ownerSymbol, currentScope, options);
+}
+
+export function createClassScope(
+  ownerSymbol: NamedTypeSymbol,
+  options: OutputScopeOptions = {},
+) {
+  const currentScope = useCSharpScope();
+  if (
+    !(currentScope instanceof CSharpNamedTypeScope) &&
+    !(currentScope instanceof CSharpSourceFileScope)
+  ) {
+    throw new Error(
+      "Can't create C# class scope inside of " + currentScope.constructor.name,
+    );
+  }
+  return new CSharpClassScope(ownerSymbol, currentScope, options);
+}
+export function createMethodScope(options: OutputScopeOptions = {}) {
+  const parentScope = useNamedTypeScope();
+  return new CSharpMethodScope("method scope", parentScope, options);
+}

package/src/scopes/index.ts

@@ -0,0 +1,9 @@
+export * from "./class.js";
+export * from "./contexts.js";
+export * from "./csharp.js";
+export * from "./factories.js";
+export * from "./lexical.js";
+export * from "./method.js";
+export * from "./named-type.js";
+export * from "./namespace.js";
+export * from "./source-file.js";

package/src/scopes/lexical.ts

@@ -0,0 +1,10 @@
+import { type OutputSpace } from "@alloy-js/core";
+import { CSharpScope } from "./csharp.js";
+
+export class CSharpLexicalScope extends CSharpScope {
+  public static readonly declarationSpaces = ["local-variables"];
+
+  get localVariables(): OutputSpace {
+    return this.spaceFor("local-variables")!;
+  }
+}

package/src/scopes/method.ts

@@ -0,0 +1,22 @@
+import type { OutputSpace } from "@alloy-js/core";
+import { CSharpLexicalScope } from "./lexical.js";
+
+export class CSharpMethodScope extends CSharpLexicalScope {
+  public static readonly declarationSpaces = [
+    "local-variables",
+    "parameters",
+    "type-parameters",
+  ];
+
+  get localVariables(): OutputSpace {
+    return this.spaceFor("local-variables")!;
+  }
+
+  get parameters(): OutputSpace {
+    return this.spaceFor("parameters")!;
+  }
+
+  get typeParameters(): OutputSpace {
+    return this.spaceFor("type-parameters")!;
+  }
+}

package/src/scopes/named-type.ts

@@ -0,0 +1,44 @@
+import { type OutputScopeOptions } from "@alloy-js/core";
+import { NamedTypeSymbol } from "../symbols/named-type.js";
+import { CSharpScope } from "./csharp.js";
+import { CSharpSourceFileScope } from "./source-file.js";
+
+/**
+ * This scope contains NamedTypeSymbols for types that are declared in
+ * containers like namespaces. This scope is a member scope which whose
+ * member symbol is a NamedTypeSymbol.
+ */
+export class CSharpNamedTypeScope extends CSharpScope {
+  public static readonly declarationSpaces = [];
+
+  constructor(
+    ownerSymbol: NamedTypeSymbol,
+    parentScope: CSharpNamedTypeScope | CSharpSourceFileScope | undefined,
+    options: OutputScopeOptions = {},
+  ) {
+    super(`${ownerSymbol.name} scope`, parentScope, {
+      ownerSymbol,
+      ...options,
+    });
+  }
+
+  get ownerSymbol(): NamedTypeSymbol {
+    return super.ownerSymbol as NamedTypeSymbol;
+  }
+
+  get enclosingNamespace() {
+    return this.ownerSymbol.enclosingNamespace;
+  }
+
+  get members() {
+    return this.ownerSymbol.members;
+  }
+
+  /**
+   * For now, we stuff type parameters into the member scope. This is to ensure
+   * name conflicts are handled correctly.
+   */
+  get typeParameters() {
+    return this.ownerSymbol.members;
+  }
+}

package/src/scopes/namespace.ts

@@ -0,0 +1,59 @@
+import { OutputScope, useScope } from "@alloy-js/core";
+import type { NamespaceSymbol } from "../symbols/namespace.js";
+import { CSharpNamedTypeScope } from "./named-type.js";
+import { CSharpSourceFileScope } from "./source-file.js";
+
+export class CSharpNamespaceScope extends CSharpNamedTypeScope {
+  constructor(
+    namespaceSymbol: NamespaceSymbol,
+    parentScope?: CSharpNamespaceScope | CSharpSourceFileScope,
+  ) {
+    super(namespaceSymbol, parentScope, {
+      binder: namespaceSymbol.binder,
+    });
+  }
+
+  get ownerSymbol() {
+    return super.ownerSymbol as NamespaceSymbol;
+  }
+}
+
+export function createCSharpNamespaceScope(namespaceSymbol: NamespaceSymbol) {
+  const parentScope = useScope();
+  if (
+    parentScope &&
+    !(
+      parentScope instanceof CSharpNamespaceScope ||
+      parentScope instanceof CSharpSourceFileScope
+    )
+  ) {
+    throw new Error(
+      "Namespaces can only be created within a namespace or source file",
+    );
+  }
+
+  const scope = new CSharpNamespaceScope(namespaceSymbol, parentScope);
+
+  return scope;
+}
+
+export function useEnclosingNamespaceScope(): CSharpNamespaceScope | undefined {
+  const currentScope = useScope();
+  if (!(currentScope instanceof CSharpNamespaceScope)) {
+    return undefined;
+  }
+
+  return currentScope;
+}
+
+export function useNamespace() {
+  let scope: OutputScope | undefined = useScope();
+  while (scope) {
+    if (scope instanceof CSharpNamespaceScope) {
+      return scope;
+    }
+    scope = scope.parent;
+  }
+
+  throw new Error("A namespace is not in scope");
+}

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;
+}