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

package/dist/src/symbols/factories.d.ts

@@ -0,0 +1,25 @@
+import { Namekey, OutputSymbolOptions } from "@alloy-js/core";
+import { CSharpMethodScope } from "../scopes/method.js";
+import { CSharpNamedTypeScope } from "../scopes/named-type.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 declare function createParameterSymbol(originalName: string | Namekey, options?: CSharpSymbolOptions): CSharpSymbol;
+export interface CreateTypeParameterSymbolOptions extends CSharpSymbolOptions {
+    scope?: CSharpMethodScope | CSharpNamedTypeScope;
+}
+export declare function createTypeParameterSymbol(originalName: string | Namekey, options?: CreateTypeParameterSymbolOptions): CSharpSymbol;
+export declare function createFieldSymbol(originalName: string | Namekey, options?: CSharpSymbolOptions): CSharpSymbol;
+export declare function createNamedTypeSymbol(name: string | Namekey, kind: NamedTypeTypeKind, options?: OutputSymbolOptions): NamedTypeSymbol;
+export declare function createNamespaceSymbol(name: string): NamespaceSymbol;
+export interface CreateMethodSymbolOptions extends CSharpSymbolOptions {
+    methodKind?: MethodKinds;
+}
+export declare function createMethodSymbol(originalName: string | Namekey, options?: CreateMethodSymbolOptions): MethodSymbol;
+export declare function createPropertySymbol(name: string | Namekey, options: CSharpSymbolOptions): CSharpSymbol;
+export declare function createVariableSymbol(originalName: string | Namekey, options?: CSharpSymbolOptions): CSharpSymbol;
+//# sourceMappingURL=factories.d.ts.map

package/dist/src/symbols/factories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories.d.ts","sourceRoot":"","sources":["../../../src/symbols/factories.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EAEP,mBAAmB,EAEpB,MAAM,gBAAgB,CAAC;AAOxB,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAM/D,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,GAAG,OAAO,EAC9B,OAAO,GAAE,mBAAwB,gBAgBlC;AAED,MAAM,WAAW,gCAAiC,SAAQ,mBAAmB;IAC3E,KAAK,CAAC,EAAE,iBAAiB,GAAG,oBAAoB,CAAC;CAClD;AACD,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,MAAM,GAAG,OAAO,EAC9B,OAAO,GAAE,gCAAqC,gBAiB/C;AAED,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,GAAG,OAAO,EAC9B,OAAO,GAAE,mBAAwB,gBA0BlC;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,GAAG,OAAO,EACtB,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,mBAAmB,mBAI9B;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,mBAOjD;AAED,MAAM,WAAW,yBAA0B,SAAQ,mBAAmB;IACpE,UAAU,CAAC,EAAE,WAAW,CAAC;CAC1B;AAED,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,MAAM,GAAG,OAAO,EAC9B,OAAO,GAAE,yBAA8B,gBAoBxC;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,GAAG,OAAO,EACtB,OAAO,EAAE,mBAAmB,gBAQ7B;AAED,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,GAAG,OAAO,EAC9B,OAAO,GAAE,mBAAwB,gBA2BlC"}

package/dist/src/symbols/factories.js

@@ -0,0 +1,86 @@
+import { useBinder } from "@alloy-js/core";
+import { getGlobalNamespace } from "../contexts/global-namespace.js";
+import { useCSharpNamePolicy } from "../name-policy.js";
+import { CSharpClassScope } from "../scopes/class.js";
+import { useCSharpScope, useNamedTypeScope } from "../scopes/contexts.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 } from "./csharp.js";
+import { MethodSymbol } from "./method.js";
+import { NamedTypeSymbol } from "./named-type.js";
+import { NamespaceSymbol } from "./namespace.js";
+
+/**
+ * Create a symbol for a parameter in the current method scope.
+ */
+export function createParameterSymbol(originalName, options = {}) {
+  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 function createTypeParameterSymbol(originalName, options = {}) {
+  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, options = {}) {
+  let nameElement = "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, kind, options) {
+  const scope = useNamedTypeScope();
+  return new NamedTypeSymbol(name, scope.ownerSymbol.members, kind, options);
+}
+export function createNamespaceSymbol(name) {
+  const scope = useEnclosingNamespaceScope();
+  const nsSymbol = scope?.ownerSymbol ?? getGlobalNamespace(useBinder());
+  if (nsSymbol.members.symbolNames.has(name)) {
+    return nsSymbol.members.symbolNames.get(name);
+  }
+  return new NamespaceSymbol(name, nsSymbol);
+}
+export function createMethodSymbol(originalName, options = {}) {
+  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, options) {
+  const scope = useNamedTypeScope();
+  return new CSharpSymbol(name, scope.members, withNamePolicy(options, "class-property"));
+}
+export function createVariableSymbol(originalName, options = {}) {
+  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;
+    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(options, elementType) {
+  return {
+    ...options,
+    namePolicy: options.namePolicy ?? useCSharpNamePolicy().for(elementType)
+  };
+}

package/dist/src/symbols/index.d.ts

@@ -1,4 +1,7 @@
-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";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/symbols/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/symbols/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/symbols/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC"}

package/dist/src/symbols/index.js

@@ -1,3 +1,6 @@
-export * from "./csharp-output-symbol.js";
-export * from "./reference.js";
-export * from "./scopes.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";

package/dist/src/symbols/method.d.ts

@@ -0,0 +1,13 @@
+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 declare class MethodSymbol extends CSharpSymbol {
+    #private;
+    readonly symbolKind = "method";
+    get methodKind(): MethodKinds;
+    constructor(name: string | Namekey, spaces: OutputSpace | undefined, kind: MethodKinds, options?: CSharpSymbolOptions);
+}
+//# sourceMappingURL=method.d.ts.map

package/dist/src/symbols/method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method.d.ts","sourceRoot":"","sources":["../../../src/symbols/method.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEhE,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,aAAa,CAAC;AAErD;;GAEG;AACH,qBAAa,YAAa,SAAQ,YAAY;;IAC5C,SAAgB,UAAU,YAAY;IAGtC,IAAI,UAAU,gBAEb;gBAGC,IAAI,EAAE,MAAM,GAAG,OAAO,EACtB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,IAAI,EAAE,WAAW,EACjB,OAAO,GAAE,mBAAwB;CAKpC"}

package/dist/src/symbols/method.js

@@ -0,0 +1,15 @@
+import { CSharpSymbol } from "./csharp.js";
+/**
+ * A symbol for a method or constructor of a class, interface, or struct.
+ */
+export class MethodSymbol extends CSharpSymbol {
+  symbolKind = "method";
+  #methodKind;
+  get methodKind() {
+    return this.#methodKind;
+  }
+  constructor(name, spaces, kind, options = {}) {
+    super(name, spaces, options);
+    this.#methodKind = kind;
+  }
+}

package/dist/src/symbols/named-type.d.ts

@@ -0,0 +1,19 @@
+import { Namekey, OutputSpace, OutputSymbolOptions } from "@alloy-js/core";
+import { CSharpSymbol } from "./csharp.js";
+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 declare class NamedTypeSymbol extends CSharpSymbol {
+    #private;
+    readonly symbolKind: NamedTypeSymbolKind;
+    static readonly memberSpaces: string[];
+    constructor(name: string | Namekey, spaces: OutputSpace[] | OutputSpace | undefined, kind: NamedTypeTypeKind, options?: OutputSymbolOptions);
+    get typeKind(): NamedTypeTypeKind;
+    copy(): NamedTypeSymbol;
+    get members(): import("@alloy-js/core").OutputMemberSpace;
+}
+//# sourceMappingURL=named-type.d.ts.map

package/dist/src/symbols/named-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"named-type.d.ts","sourceRoot":"","sources":["../../../src/symbols/named-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,MAAM,MAAM,iBAAiB,GACzB,OAAO,GACP,WAAW,GACX,MAAM,GACN,WAAW,GACX,QAAQ,GACR,QAAQ,CAAC;AACb,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG,WAAW,CAAC;AAE7D;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,YAAY;;IAC/C,SAAgB,UAAU,EAAE,mBAAmB,CAAgB;IAC/D,gBAAuB,YAAY,WAAe;gBAGhD,IAAI,EAAE,MAAM,GAAG,OAAO,EACtB,MAAM,EAAE,WAAW,EAAE,GAAG,WAAW,GAAG,SAAS,EAC/C,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,mBAAmB;IAO/B,IAAI,QAAQ,sBAEX;IAED,IAAI;IAYJ,IAAI,OAAO,+CAEV;CACF"}

package/dist/src/symbols/named-type.js

@@ -0,0 +1,30 @@
+import { CSharpSymbol } from "./csharp.js";
+
+// represents a symbol from a .cs file. Class, enum, interface etc.
+
+/**
+ * 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 {
+  symbolKind = "named-type";
+  static memberSpaces = ["members"];
+  constructor(name, spaces, kind, options) {
+    super(name, spaces, options);
+    this.#typeKind = kind;
+  }
+  #typeKind;
+  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");
+  }
+}

package/dist/src/symbols/namespace.d.ts

@@ -0,0 +1,22 @@
+import { OutputSymbolOptions } from "@alloy-js/core";
+import { NamedTypeSymbol } from "./named-type.js";
+export interface NamespaceSymbolOptions extends OutputSymbolOptions {
+    isGlobal?: boolean;
+}
+/**
+ * A symbol for a namespace in C#.
+ */
+export declare class NamespaceSymbol extends NamedTypeSymbol {
+    #private;
+    readonly symbolKind = "namespace";
+    constructor(name: string, parentNamespace?: NamespaceSymbol, options?: NamespaceSymbolOptions);
+    /**
+     * Whether this symbol is the global namespace symbol.
+     */
+    get isGlobal(): boolean;
+    getFullyQualifiedName(options?: {
+        omitGlobal?: boolean;
+    }): string;
+    copy(): NamespaceSymbol;
+}
+//# sourceMappingURL=namespace.d.ts.map

package/dist/src/symbols/namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../../../src/symbols/namespace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD,MAAM,WAAW,sBAAuB,SAAQ,mBAAmB;IACjE,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,eAAe;;IAClD,SAAgB,UAAU,eAAe;gBAEvC,IAAI,EAAE,MAAM,EACZ,eAAe,CAAC,EAAE,eAAe,EACjC,OAAO,CAAC,EAAE,sBAAsB;IAUlC;;OAEG;IACH,IAAI,QAAQ,YAEX;IAED,qBAAqB,CAAC,OAAO,GAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,MAAM;IAoBrE,IAAI;CASL"}

package/dist/src/symbols/namespace.js

@@ -0,0 +1,44 @@
+import { NamedTypeSymbol } from "./named-type.js";
+/**
+ * A symbol for a namespace in C#.
+ */
+export class NamespaceSymbol extends NamedTypeSymbol {
+  symbolKind = "namespace";
+  constructor(name, parentNamespace, options) {
+    const space = parentNamespace?.members;
+    super(name, space, "namespace", options);
+    this.#isGlobal = !!options?.isGlobal;
+  }
+  #isGlobal;
+  /**
+   * Whether this symbol is the global namespace symbol.
+   */
+  get isGlobal() {
+    return this.#isGlobal;
+  }
+  getFullyQualifiedName(options = {}) {
+    const parts = [];
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let current = this;
+    while (current && !current.isGlobal) {
+      parts.unshift(current.name);
+      current = current.ownerSymbol;
+    }
+    const idPart = parts.join(".");
+    if (options.omitGlobal) {
+      return idPart;
+    } else {
+      return `global::${idPart}`;
+    }
+  }
+  copy() {
+    const options = this.getCopyOptions();
+    const copy = new NamespaceSymbol(this.name, undefined, {
+      ...options,
+      isGlobal: this.#isGlobal
+    });
+    this.initializeCopy(copy);
+    return copy;
+  }
+}

package/dist/src/symbols/reference.d.ts

@@ -1,3 +1,3 @@
-import * as core from "@alloy-js/core";
-export declare function ref(refkey: core.Refkey): () => string;
+import { OutputSymbol, Refkey } from "@alloy-js/core";
+export declare function ref(refkey: Refkey): () => [string, OutputSymbol | undefined];
 //# sourceMappingURL=reference.d.ts.map

package/dist/src/symbols/reference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../src/symbols/reference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AAoBvC,wBAAgB,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,GAAG,MAAM,MAAM,CA4CrD"}
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../src/symbols/reference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,YAAY,EAAE,MAAM,EAAW,MAAM,gBAAgB,CAAC;AAWrE,wBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,CAAC,CAkD5E"}

package/dist/src/symbols/reference.js

@@ -1,54 +1,47 @@
-import * as core from "@alloy-js/core";
-import { useNamespace } from "../components/Namespace.js";
-import { useSourceFile } from "../components/SourceFile.js";
-
-// when resolving references across source files, the last element
-// in pathDown will be the containing source file. we only need this
-// here so we can find and remove this scope as it's not useful
-// when building the reference
-
+import { memo, resolve } from "@alloy-js/core";
+import { CSharpNamespaceScope } from "../scopes/namespace.js";
+import { useSourceFileScope } from "../scopes/source-file.js";
 // converts a refkey to its fully qualified name
 // e.g. if refkey is for bar in enum type foo, and
 // foo is in the same namespace as the refkey, then
 // the result would be foo.bar.
 export function ref(refkey) {
-  const targetNamespaceCtx = useNamespace();
-  const resolveResult = core.resolve(refkey);
-  return core.memo(() => {
+  const refSfScope = useSourceFileScope();
+  const resolveResult = resolve(refkey);
+  return memo(() => {
     if (resolveResult.value === undefined) {
-      return "<Unresolved Symbol>";
+      return ["<Unresolved Symbol>", undefined];
     }
-
-    // targetDeclaration is the symbol with the refkey
-    // pathDown is an array of scopes to that symbol and can be empty.
-    // the entries are top-down, so namespace, source-file, member
-    //  - referencing a type within the same namespace will have an empty path
-    //  - referencing a member (e.g. enum value) within the same namespace will
-    //    have a single path entry that contains the owning type
-    //  - referencing a type within the same namespace but in a different source
-    //    file will have at least a source-file entry
-    //  - referencing a symbol outside the current namespace will have at least
-    //    two entries, namespace, source-file
+    const result = resolveResult.value;
     const {
-      targetDeclaration,
-      pathDown
-    } = resolveResult.value;
-    const sourceNamespace = pathDown.find(v => {
-      return v.kind === "namespace";
-    });
-    if (sourceNamespace && sourceNamespace.name !== targetNamespaceCtx.name) {
-      // the source symbol is in a different namespace that the target refkey.
-      // add the applicable using statement to the target's source file.
-      const targetSrc = useSourceFile();
-      targetSrc.addUsing(sourceNamespace.name);
+      commonScope,
+      pathDown,
+      memberPath
+    } = result;
+    let {
+      lexicalDeclaration
+    } = result;
+    const parts = [];
+    if (!commonScope) {
+      // this shouldn't be possible in csharp.
+      return ["<Unresolved Symbol>", undefined];
     }
-
-    // we only need to build the fully-qualified name for members
-    // TODO: possibly a subset of members
-    const syms = pathDown.filter(v => {
-      return v.kind === "member";
-    }).map(s => s.owner);
-    syms.push(targetDeclaration);
-    return syms.map(sym => sym.name).join(".");
+    if (commonScope instanceof CSharpNamespaceScope && commonScope.ownerSymbol.isGlobal && lexicalDeclaration.symbolKind === "namespace" && memberPath.length > 0) {
+      // we need to using the namespace
+      let nsToUse;
+      while (lexicalDeclaration.symbolKind === "namespace" && memberPath.length > 0) {
+        nsToUse = lexicalDeclaration;
+        lexicalDeclaration = memberPath.shift();
+      }
+      refSfScope.addUsing(nsToUse);
+    }
+    for (const nsScope of pathDown) {
+      parts.push(nsScope.ownerSymbol.name);
+    }
+    parts.push(lexicalDeclaration.name);
+    for (const member of memberPath) {
+      parts.push(member.name);
+    }
+    return [parts.join("."), result.symbol];
   });
 }

package/dist/test/project-directory.test.js

@@ -53,17 +53,15 @@ it("defines a project directory file with multiple source files", () => {
   const srcDir = projDir.contents[1];
   expect(srcDir.contents[0].path).equals("~/projects/TestProject/src/Test1.cs");
   expect(srcDir.contents[0].contents).toBe(coretest.d`
-    namespace TestCode
-    {
-        public class TestClass1;
-    }
+    namespace TestCode;
+    
+    public class TestClass1;
   `);
   expect(srcDir.contents[1].path).equals("~/projects/TestProject/src/Test2.cs");
   expect(srcDir.contents[1].contents).toBe(coretest.d`
-    namespace TestCode
-    {
-        public class TestClass2;
-    }
+    namespace TestCode;
+    
+    public class TestClass2;
   `);
 });
 it("defines a project directory file with multiple source files and a custom TFM", () => {
@@ -117,16 +115,14 @@ it("defines a project directory file with multiple source files and a custom TFM
   const srcDir = projDir.contents[1];
   expect(srcDir.contents[0].path).equals("~/projects/TestProject/src/Test1.cs");
   expect(srcDir.contents[0].contents).toBe(coretest.d`
-    namespace TestCode
-    {
-        public class TestClass1;
-    }
+    namespace TestCode;
+    
+    public class TestClass1;
   `);
   expect(srcDir.contents[1].path).equals("~/projects/TestProject/src/Test2.cs");
   expect(srcDir.contents[1].contents).toBe(coretest.d`
-    namespace TestCode
-    {
-        public class TestClass2;
-    }
+    namespace TestCode;
+    
+    public class TestClass2;
   `);
 });

package/dist/test/sourcefile.test.js

@@ -1,7 +1,7 @@
 import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
 import * as core from "@alloy-js/core";
 import * as coretest from "@alloy-js/core/testing";
-import { expect, it } from "vitest";
+import { it } from "vitest";
 import * as csharp from "../src/index.js";
 import { assertFileContents } from "./utils.js";
 it("defines multiple source files with unique content", () => {
@@ -33,26 +33,14 @@ it("defines multiple source files with unique content", () => {
   }));
   assertFileContents(res, {
     "Test1.cs": coretest.d`
-      namespace TestCode
-      {
-          public class TestClass1;
-      }
+      namespace TestCode;
+
+      public class TestClass1;
     `,
     "Test2.cs": coretest.d`
-      namespace TestCode
-      {
-          public class TestClass2;
-      }
+      namespace TestCode;
+
+      public class TestClass2;
     `
   });
-});
-it("throws when declaring a source file outside a namespace", () => {
-  const decl = _$createComponent(core.Output, {
-    get children() {
-      return _$createComponent(csharp.SourceFile, {
-        path: "Test.cs"
-      });
-    }
-  });
-  expect(() => core.render(decl)).toThrow("SourceFile must be declared inside a namespace");
 });

package/dist/test/using.test.js

@@ -21,7 +21,9 @@ it("uses a single namespace", () => {
   expect(findFile(res, "Test1.cs").contents).toBe(coretest.d`
     using Foo;
 
-    namespace TestCode {}
+    namespace TestCode;
+    
+
   `);
 });
 it("uses multiple namespaces", () => {
@@ -42,7 +44,9 @@ it("uses multiple namespaces", () => {
     using Bar.Baz;
     using Foo;
 
-    namespace TestCode {}
+    namespace TestCode;
+
+
   `);
 });
 it("adds using statement across namespaces", () => {
@@ -114,29 +118,27 @@ it("adds using statement across namespaces", () => {
   }));
   assertFileContents(res, {
     "Models.cs": coretest.d`
-      namespace Models
+      namespace Models;
+
+      public class Input;
+      public class Output;
+      public enum TestEnum
       {
-          public class Input;
-          public class Output;
-          public enum TestEnum
-          {
-              One,
-              Two
-          }
+          One,
+          Two
       }
     `,
     "Client.cs": coretest.d`
       using Models;
       using System;
 
-      namespace Client
+      namespace Client;
+      
+      public class Client
       {
-          public class Client
-          {
-              public Output MethodOne(Input bodyParam) {}
-          }
-          TestEnum.Two;
+          public Output MethodOne(Input bodyParam) {}
       }
+      TestEnum.Two;
     `
   });
 });

package/dist/test/utils.js

@@ -9,8 +9,8 @@ export function TestNamespace(props) {
       return csharp.createCSharpNamePolicy();
     },
     get children() {
-      return _$createComponent(csharp.Namespace, {
-        name: "TestCode",
+      return _$createComponent(csharp.SourceFile, {
+        path: "Test.cs",
         get children() {
           return props.children;
         }