@alloy-js/python 0.1.0-dev.4 → 0.1.0-dev.5

package/src/symbol-creation.ts

@@ -1,16 +1,29 @@
-import { refkey, useContext } from "@alloy-js/core";
+import {
+  OutputScopeOptions,
+  OutputSpace,
+  useBinder,
+  useContext,
+} from "@alloy-js/core";
 import { PythonSourceFileContext } from "./components/SourceFile.js";
 import { PythonElements, usePythonNamePolicy } from "./name-policy.js";
 import {
-  CreatePythonSymbolOptions,
   PythonOutputSymbol,
+  PythonOutputSymbolOptions,
+  usePythonScope,
 } from "./symbols/index.js";
+import { PythonLexicalScope } from "./symbols/python-lexical-scope.js";
 
+interface CreatePythonSymbolOptions extends PythonOutputSymbolOptions {
+  space?: OutputSpace;
+  instance?: boolean;
+}
+/**
+ * Creates a symbol for a python declaration in the current scope.
+ */
 export function createPythonSymbol(
   name: string,
-  options: CreatePythonSymbolOptions,
+  options: CreatePythonSymbolOptions = {},
   kind?: PythonElements,
-  createRefkeyIfNeeded = false,
 ): PythonOutputSymbol {
   let processedName = name;
   const sfContext = useContext(PythonSourceFileContext);
@@ -21,16 +34,42 @@ export function createPythonSymbol(
       processedName = namePolicy.getName(name, kind);
     }
   }
+  const currentScope = usePythonScope();
+  let targetSpace = options.space ?? undefined;
+  if (!options.space && currentScope) {
+    if (currentScope.isMemberScope) {
+      if (options.instance) {
+        targetSpace = currentScope.ownerSymbol!.instanceMembers;
+      } else {
+        targetSpace = currentScope.ownerSymbol!.staticMembers;
+      }
+    } else {
+      if (options.instance) {
+        throw new Error(
+          `Cannot declare instance variable ${name} outside of a member scope`,
+        );
+      }
+      targetSpace = (currentScope as PythonLexicalScope).symbols;
+    }
+  }
+
+  const binder = options.binder ?? currentScope?.binder ?? useBinder();
 
-  return new PythonOutputSymbol(processedName, {
-    binder: options.binder,
+  return new PythonOutputSymbol(processedName, targetSpace, {
+    binder: binder,
     aliasTarget: options.aliasTarget,
-    scope: options.scope,
-    refkeys:
-      options.refkeys ??
-      (createRefkeyIfNeeded ? refkey(processedName) : undefined),
-    flags: options.flags,
+    refkeys: options.refkeys,
     metadata: options.metadata,
     module: sfContext?.module,
+    type: options.type,
   });
 }
+
+export function createLexicalScope(
+  name: string,
+  options: OutputScopeOptions = {},
+) {
+  const parent = usePythonScope();
+
+  return new PythonLexicalScope(name, parent, options);
+}

package/src/symbols/index.ts

@@ -1,4 +1,4 @@
-export * from "./custom-output-scope.js";
+export * from "./python-lexical-scope.js";
 export * from "./python-member-scope.js";
 export * from "./python-module-scope.js";
 export * from "./python-output-symbol.js";

package/src/symbols/python-lexical-scope.ts

@@ -0,0 +1,16 @@
+import { OutputScope } from "@alloy-js/core";
+
+export class PythonLexicalScope extends OutputScope {
+  public static readonly declarationSpaces: readonly string[] = ["symbols"];
+
+  get symbols() {
+    return this.spaceFor("symbols")!;
+  }
+
+  // Lexical scopes do not have an owner symbol. This ensures that we get the
+  // correct type when using `usePythonScope` (i.e. we don't get the
+  // OutputScope's `OutputSymbol | undefined` type).
+  get ownerSymbol(): undefined {
+    return undefined;
+  }
+}

package/src/symbols/python-member-scope.ts

@@ -1,12 +1,8 @@
-import { CustomOutputScope } from "./custom-output-scope.js";
+import { OutputScope } from "@alloy-js/core";
 import { PythonOutputSymbol } from "./python-output-symbol.js";
 
-export class PythonMemberScope extends CustomOutputScope {
-  get kind() {
-    return "member" as const;
-  }
-
-  get owner() {
-    return super.owner as PythonOutputSymbol;
+export class PythonMemberScope extends OutputScope {
+  get ownerSymbol() {
+    return super.ownerSymbol as PythonOutputSymbol;
   }
 }

package/src/symbols/python-module-scope.ts

@@ -1,6 +1,5 @@
 import { reactive, shallowReactive } from "@alloy-js/core";
-import { createPythonSymbol } from "../symbol-creation.js";
-import { CustomOutputScope } from "./custom-output-scope.js";
+import { PythonLexicalScope } from "./python-lexical-scope.js";
 import { PythonOutputSymbol } from "./python-output-symbol.js";
 
 export class ImportedSymbol {
@@ -21,23 +20,9 @@ export interface ImportRecordProps {
   symbols: Set<ImportedSymbol>;
 }
 
-export type ImportRecords = Map<PythonModuleScope, ImportRecordProps>;
-
-export const ImportRecords = Map as {
-  new (): ImportRecords;
-  new (
-    entries?:
-      | readonly (readonly [PythonModuleScope, ImportRecordProps])[]
-      | null,
-  ): ImportRecords;
-  prototype: Map<PythonModuleScope, ImportRecordProps>;
-};
-
-export class PythonModuleScope extends CustomOutputScope {
-  get kind() {
-    return "module" as const;
-  }
+export class ImportRecords extends Map<PythonModuleScope, ImportRecordProps> {}
 
+export class PythonModuleScope extends PythonLexicalScope {
   #importedSymbols: Map<PythonOutputSymbol, PythonOutputSymbol> =
     shallowReactive(new Map());
   get importedSymbols() {
@@ -55,29 +40,18 @@ export class PythonModuleScope extends CustomOutputScope {
       return existing;
     }
 
-    if (targetModule.kind !== "module") {
-      throw new Error("Cannot import symbol that isn't in module scope");
-    }
-
     if (!this.importedModules.has(targetModule)) {
       this.importedModules.set(targetModule, {
         symbols: new Set<ImportedSymbol>(),
       });
     }
 
-    const localSymbol = createPythonSymbol(
+    const localSymbol = new PythonOutputSymbol(
       targetSymbol.name,
-      {
-        binder: this.binder,
-        scope: this,
-        aliasTarget: targetSymbol,
-      },
-      undefined,
-      false,
+      this.symbols,
+      { binder: this.binder, aliasTarget: targetSymbol },
     );
 
-    targetSymbol.copyTo(localSymbol);
-
     this.importedSymbols.set(targetSymbol, localSymbol);
     this.importedModules.get(targetModule)!.symbols?.add({
       local: localSymbol,

package/src/symbols/python-output-symbol.ts

@@ -1,12 +1,11 @@
-import { OutputSymbol, OutputSymbolOptions } from "@alloy-js/core";
-import { PythonMemberScope } from "./python-member-scope.js";
+import { OutputSpace, OutputSymbol, OutputSymbolOptions } from "@alloy-js/core";
 
-export interface CreatePythonSymbolOptions extends OutputSymbolOptions {
+export interface PythonOutputSymbolOptions extends OutputSymbolOptions {
   module?: string;
 }
 
 export interface CreatePythonSymbolFunctionOptions
-  extends CreatePythonSymbolOptions {
+  extends PythonOutputSymbolOptions {
   name: string;
 }
 
@@ -14,8 +13,14 @@ export interface CreatePythonSymbolFunctionOptions
  * Represents an 'exported' symbol from a .py file. Class, enum, interface etc.
  */
 export class PythonOutputSymbol extends OutputSymbol {
-  constructor(name: string, options: CreatePythonSymbolOptions) {
-    super(name, options);
+  static readonly memberSpaces = ["static", "instance"] as const;
+
+  constructor(
+    name: string,
+    spaces: OutputSpace[] | OutputSpace | undefined,
+    options: PythonOutputSymbolOptions,
+  ) {
+    super(name, spaces, options);
     this.#module = options.module ?? undefined;
   }
 
@@ -26,11 +31,32 @@ export class PythonOutputSymbol extends OutputSymbol {
     return this.#module;
   }
 
-  set module(value: string | undefined) {
-    this.#module = value;
+  get staticMembers() {
+    return this.memberSpaceFor("static")!;
+  }
+
+  get instanceMembers() {
+    return this.memberSpaceFor("instance")!;
+  }
+
+  get isStaticMemberSymbol() {
+    return !this.isInstanceMemberSymbol;
   }
 
-  get instanceMemberScope() {
-    return super.instanceMemberScope as PythonMemberScope | undefined;
+  get isInstanceMemberSymbol() {
+    return this.spaces.some((s) => s.key === "instance");
+  }
+
+  copy() {
+    const copy = new PythonOutputSymbol(this.name, undefined, {
+      binder: this.binder,
+      aliasTarget: this.aliasTarget,
+      module: this.module,
+      metadata: this.metadata,
+    });
+
+    this.initializeCopy(copy);
+
+    return copy;
   }
 }

package/src/symbols/reference.tsx

@@ -0,0 +1,70 @@
+import {
+  Children,
+  memo,
+  Refkey,
+  resolve,
+  untrack,
+  useContext,
+} from "@alloy-js/core";
+import { MemberExpression } from "../components/MemberExpression.jsx";
+import { PythonSourceFileContext } from "../components/SourceFile.jsx";
+import {
+  PythonModuleScope,
+  PythonOutputScope,
+  PythonOutputSymbol,
+} from "./index.js";
+
+export function ref(
+  refkey: Refkey,
+): () => [Children, PythonOutputSymbol | undefined] {
+  const sourceFile = useContext(PythonSourceFileContext);
+  const resolveResult = resolve<PythonOutputScope, PythonOutputSymbol>(
+    refkey as Refkey,
+  );
+
+  return memo(() => {
+    if (resolveResult.value === undefined) {
+      return ["<Unresolved Symbol>", undefined];
+    }
+
+    const { commonScope, lexicalDeclaration, symbol, pathDown, memberPath } =
+      resolveResult.value;
+
+    // Where the target declaration is relative to the referencing scope.
+    // * module: target symbol is in a different module
+    // * local: target symbol is within the current module
+    const targetLocation =
+      pathDown[0] instanceof PythonModuleScope ? "module" : "local";
+    let localSymbol: PythonOutputSymbol | undefined;
+
+    if (targetLocation === "module") {
+      localSymbol = untrack(() =>
+        sourceFile!.scope.addImport(
+          lexicalDeclaration,
+          pathDown[0] as PythonModuleScope,
+        ),
+      );
+    }
+
+    const parts = [];
+
+    if (commonScope && commonScope.isMemberScope) {
+      // we are referencing a member of a type we are inside
+      if (lexicalDeclaration.isInstanceMemberSymbol) {
+        parts.push(<MemberExpression.Part id="self" />);
+      } else {
+        parts.push(<MemberExpression.Part symbol={commonScope.ownerSymbol} />);
+      }
+      parts.push(<MemberExpression.Part symbol={lexicalDeclaration} />);
+    } else {
+      parts.push(
+        <MemberExpression.Part symbol={localSymbol ?? lexicalDeclaration} />,
+      );
+    }
+    for (const part of memberPath) {
+      parts.push(<MemberExpression.Part symbol={part} />);
+    }
+
+    return [<MemberExpression children={parts} />, localSymbol ?? symbol];
+  });
+}

package/src/symbols/scopes.ts

@@ -1,9 +1,23 @@
 import { useScope } from "@alloy-js/core";
+import { PythonLexicalScope } from "./python-lexical-scope.js";
 import { PythonMemberScope } from "./python-member-scope.js";
 import { PythonModuleScope } from "./python-module-scope.js";
 
-export type PythonOutputScope = PythonModuleScope | PythonMemberScope;
+export type PythonOutputScope =
+  | PythonLexicalScope
+  | PythonModuleScope
+  | PythonMemberScope;
 
 export function usePythonScope() {
   return useScope() as PythonOutputScope;
 }
+
+export function usePythonLexicalScope() {
+  const scope = usePythonScope();
+  if (!(scope instanceof PythonLexicalScope)) {
+    throw new Error(
+      "Expected a PythonLexicalScope, but got " + scope.constructor.name,
+    );
+  }
+  return scope;
+}