@alloy-js/csharp 0.20.0-dev.3 → 0.20.0-dev.5

package/src/components/struct/declaration.test.tsx

@@ -6,7 +6,6 @@ import { Constructor } from "../constructor/constructor.jsx";
 import { Field } from "../field/field.jsx";
 import { Method } from "../method/method.jsx";
 import { Property } from "../property/property.jsx";
-import { SourceFile } from "../SourceFile.jsx";
 import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
 import { StructDeclaration } from "./declaration.jsx";
 
@@ -78,23 +77,18 @@ describe("with type parameters", () => {
 
     expect(
       <TestNamespace>
-        <SourceFile path="Test.cs">
-          <StructDeclaration public name="Test" typeParameters={typeParameters}>
-            <List>
-              <Property name="PropA" type={typeParameters[0].refkey} get set />
-              <Property name="PropB" type={typeParameters[1].refkey} get set />
-            </List>
-          </StructDeclaration>
-        </SourceFile>
+        <StructDeclaration public name="Test" typeParameters={typeParameters}>
+          <List>
+            <Property name="PropA" type={typeParameters[0].refkey} get set />
+            <Property name="PropB" type={typeParameters[1].refkey} get set />
+          </List>
+        </StructDeclaration>
       </TestNamespace>,
     ).toRenderTo(`
-      namespace TestCode
+      public struct Test<T, U>
       {
-          public struct Test<T, U>
-          {
-              T PropA { get; set; }
-              U PropB { get; set; }
-          }
+          T PropA { get; set; }
+          U PropB { get; set; }
       }
     `);
   });
@@ -119,10 +113,10 @@ describe("with type parameters", () => {
       </TestNamespace>,
     ).toRenderTo(`
       public struct Test<T, U>
-        where T : IFoo
-        where U : IBar
+          where T : IFoo
+          where U : IBar
       {
-        // Body
+          // Body
       }
     `);
   });
@@ -149,7 +143,7 @@ it("define methods", () => {
   ).toRenderTo(`
     struct Test
     {
-      void MethodOne() {}
+        void MethodOne() {}
     }
   `);
 });
@@ -164,7 +158,7 @@ it("define constructor", () => {
   ).toRenderTo(`
     struct Test
     {
-      public Test() {}
+        public Test() {}
     }
   `);
 });
@@ -182,8 +176,8 @@ it("defines fields", () => {
   ).toRenderTo(`
     public struct TestClass
     {
-      public string MemberOne;
-      public int MemberTwo;
+        public string MemberOne;
+        public int MemberTwo;
     }
   `);
 });

package/src/components/struct/declaration.tsx

@@ -7,8 +7,8 @@ import {
   makeModifiers,
 } from "../../modifiers.js";
 import { useCSharpNamePolicy } from "../../name-policy.js";
-import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
-import { CSharpMemberScope } from "../../symbols/scopes.js";
+import { createNamedTypeScope } from "../../scopes/factories.js";
+import { createNamedTypeSymbol } from "../../symbols/factories.js";
 import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { DocWhen } from "../doc/comment.jsx";
 import { Name } from "../Name.jsx";
@@ -100,13 +100,11 @@ export interface StructDeclarationProps
 export function StructDeclaration(props: StructDeclarationProps) {
   const name = useCSharpNamePolicy().getName(props.name!, "struct");
 
-  const thisStructSymbol = new CSharpOutputSymbol(name, {
+  const thisStructSymbol = createNamedTypeSymbol(name, "struct", {
     refkeys: props.refkey,
   });
 
-  const thisStructScope = new CSharpMemberScope("struct-decl", {
-    owner: thisStructSymbol,
-  });
+  const thisStructScope = createNamedTypeScope(thisStructSymbol);
 
   const modifiers = computeModifiersPrefix([
     getAccessModifier(props),

package/src/components/type-parameters/type-parameter.tsx

@@ -1,7 +1,10 @@
-import { Children, MemberDeclaration, refkey, Refkey } from "@alloy-js/core";
-import { useCSharpNamePolicy } from "../../name-policy.js";
-import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
-import { useCSharpScope } from "../../symbols/scopes.js";
+import {
+  Children,
+  MemberDeclaration,
+  MemberName,
+  Refkey,
+} from "@alloy-js/core";
+import { createTypeParameterSymbol } from "../../symbols/factories.js";
 
 /**
  * Information for a TypeScript generic type parameter.
@@ -24,12 +27,12 @@ export interface TypeParameterProps {
 }
 
 export function TypeParameter(props: TypeParameterProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "type-parameter");
-  const scope = useCSharpScope();
-  const symbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(props.name),
+  const symbol = createTypeParameterSymbol(props.name, {
+    refkeys: props.refkey,
   });
-
-  return <MemberDeclaration symbol={symbol}>{name}</MemberDeclaration>;
+  return (
+    <MemberDeclaration symbol={symbol}>
+      <MemberName />
+    </MemberDeclaration>
+  );
 }

package/src/components/type-parameters/type-parameters.test.tsx

@@ -15,16 +15,16 @@ it("render very long", () => {
     <TestNamespace>
       <TypeParameters
         parameters={[
-          "SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesA",
-          "SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesB",
+          "SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesLongLongLongLongLongA",
+          "SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesLongLongLongLongLongB",
         ]}
       />
     </TestNamespace>,
   ).toRenderTo(
     `
     <
-      SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesA,
-      SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesB>
+        SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesLongLongLongLongLongA,
+        SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesLongLongLongLongLongB>
     `,
   );
 });

package/src/components/var/declaration.test.tsx

@@ -1,7 +1,6 @@
 import { List, refkey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
-import { SourceFile } from "../SourceFile.jsx";
 import { VarDeclaration } from "./declaration.jsx";
 
 it("declares var without type", () => {
@@ -40,20 +39,15 @@ it("links refkey", () => {
   const key = refkey();
   expect(
     <TestNamespace>
-      <SourceFile path="test.cs">
-        <List>
-          <VarDeclaration name="testVar" refkey={key}>
-            42
-          </VarDeclaration>
-          <VarDeclaration name="testVar2">{key}</VarDeclaration>
-        </List>
-      </SourceFile>
+      <List>
+        <VarDeclaration name="testVar" refkey={key}>
+          42
+        </VarDeclaration>
+        <VarDeclaration name="testVar2">{key}</VarDeclaration>
+      </List>
     </TestNamespace>,
   ).toRenderTo(`
-      namespace TestCode
-      {
-          var testVar = 42;
-          var testVar2 = testVar;
-      }
+      var testVar = 42;
+      var testVar2 = testVar;
   `);
 });

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/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,5 @@
 export * from "./components/index.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,18 @@
+import { OutputScope, OutputScopeOptions } from "@alloy-js/core";
+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;
+  }
+}

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