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

package/src/components/CallSignature.tsx

@@ -4,6 +4,7 @@ import {
   createSymbolSlot,
   For,
   Show,
+  SymbolSlot,
   useContext,
 } from "@alloy-js/core";
 import { ParameterDescriptor } from "../parameter-descriptor.js";
@@ -87,15 +88,12 @@ export function CallSignatureParameters(props: CallSignatureParametersProps) {
 }
 
 function parameter(param: DeclaredParameterDescriptor) {
-  const SymbolSlot = createSymbolSlot();
-
-  SymbolSlot.instantiateInto(param.symbol);
-
+  const TypeSlot = param.TypeSlot!; // TypeSlot will always be present when param.type is true.
   return (
     <group>
       {param.symbol.name}
       <Show when={!!param.type}>
-        : <SymbolSlot>{param.type}</SymbolSlot>
+        : <TypeSlot>{param.type}</TypeSlot>
       </Show>
       <Show when={!!param.optional}>
         <Show when={!param.type}>=</Show>
@@ -120,44 +118,38 @@ function parameter(param: DeclaredParameterDescriptor) {
 interface DeclaredParameterDescriptor
   extends Omit<ParameterDescriptor, "name"> {
   symbol: PythonOutputSymbol;
+  TypeSlot?: SymbolSlot;
 }
 
 function normalizeAndDeclareParameters(
   parameters: ParameterDescriptor[] | string[],
 ): DeclaredParameterDescriptor[] {
-  const sfContext = useContext(PythonSourceFileContext);
-  const module = sfContext?.module;
   if (parameters.length === 0) {
     return [];
   }
   if (typeof parameters[0] === "string") {
     return (parameters as string[]).map((paramName) => {
-      const symbol = createPythonSymbol(
-        paramName,
-        {
-          module: module,
-        },
-        "parameter",
-        false,
-      );
+      const symbol = createPythonSymbol(paramName, {}, "parameter");
 
       return { refkeys: symbol.refkeys, symbol };
     });
   } else {
     return (parameters as ParameterDescriptor[]).map((param) => {
+      const TypeSlot = createSymbolSlot();
+
       const symbol = createPythonSymbol(
         param.name,
         {
           refkeys: param.refkey,
-          module: module,
+          type: TypeSlot.firstSymbol,
         },
         "parameter",
-        false,
       );
 
       return {
         ...param,
         symbol,
+        TypeSlot,
       };
     });
   }

package/src/components/ClassDeclaration.tsx

@@ -1,19 +1,7 @@
-import {
-  Children,
-  List,
-  Name,
-  OutputSymbolFlags,
-  Scope,
-  Show,
-  childrenArray,
-  takeSymbols,
-} from "@alloy-js/core";
+import { Children, List, Name, Show, childrenArray } from "@alloy-js/core";
 import { createPythonSymbol } from "../symbol-creation.js";
-import {
-  BaseDeclarationProps,
-  Declaration,
-  DeclarationProps,
-} from "./Declaration.js";
+import { BaseDeclarationProps, Declaration } from "./Declaration.js";
+import { MemberScope } from "./MemberScope.jsx";
 import { PythonBlock } from "./PythonBlock.jsx";
 
 export interface ClassDeclarationProps extends BaseDeclarationProps {
@@ -61,38 +49,23 @@ export function ClassDeclaration(props: ClassDeclarationProps) {
     props.name!,
     {
       refkeys: props.refkey,
-      flags:
-        (props.flags ?? OutputSymbolFlags.None) |
-        OutputSymbolFlags.MemberContainer,
     },
     "class",
-    true,
   );
 
-  takeSymbols((memberSymbol) => {
-    // Transform emitted symbols into instance/class members
-    memberSymbol.flags |= OutputSymbolFlags.InstanceMember;
-  });
-
-  // Propagate the name after the name policy was applied
-  const updatedProps: DeclarationProps = {
-    ...props,
-    name: sym.name,
-    nameKind: "class",
-  };
   const hasChildren =
     childrenArray(() => props.children).filter((c) => Boolean(c)).length > 0;
 
   return (
     <Declaration symbol={sym}>
       class <Name />
-      <Scope name={updatedProps.name} kind="class">
+      <MemberScope ownerSymbol={sym}>
         {basesPart}
         <PythonBlock opener=":">
           <Show when={Boolean(props.doc)}>{props.doc}</Show>
           {hasChildren ? props.children : "pass"}
         </PythonBlock>
-      </Scope>
+      </MemberScope>
     </Declaration>
   );
 }

package/src/components/ClassInstantiation.tsx

@@ -1,7 +1,6 @@
 import {
   emitSymbol,
-  instantiateTakenMembersTo as instantiateTakenSymbolsTo,
-  OutputSymbolFlags,
+  instantiateTakenMembersTo,
   useContext,
 } from "@alloy-js/core";
 import { createPythonSymbol } from "../symbol-creation.js";
@@ -35,16 +34,11 @@ export interface ClassInstantiationProps extends FunctionCallExpressionProps {}
 export function ClassInstantiation(props: ClassInstantiationProps) {
   const sfContext = useContext(PythonSourceFileContext);
   const module = sfContext?.module;
-  const sym = createPythonSymbol(
-    "",
-    {
-      flags: OutputSymbolFlags.Transient,
-      module: module,
-    },
-    undefined,
-    false,
-  );
-  instantiateTakenSymbolsTo(sym);
+  const sym = createPythonSymbol("", {
+    transient: true,
+    module: module,
+  });
+  instantiateTakenMembersTo(sym, "static", "instance");
   emitSymbol(sym);
   return (
     <>

package/src/components/Declaration.tsx

@@ -1,8 +1,6 @@
 import {
   Children,
   Declaration as CoreDeclaration,
-  MemberScope,
-  OutputSymbolFlags,
   Refkey,
 } from "@alloy-js/core";
 import { PythonElements } from "../name-policy.js";
@@ -21,11 +19,6 @@ export interface BaseDeclarationProps {
    */
   refkey?: Refkey | Refkey[];
 
-  /**
-   * Flags for the symbol created by this component.
-   */
-  flags?: OutputSymbolFlags;
-
   children?: Children;
 
   /**
@@ -70,22 +63,10 @@ export function Declaration(props: DeclarationProps) {
       props.name!,
       {
         refkeys: props.refkey,
-        flags: props.flags,
       },
       props.nameKind!,
-      true,
     );
   }
 
-  function withMemberScope(children: Children) {
-    return <MemberScope owner={sym}>{children}</MemberScope>;
-  }
-
-  let children: Children = () => props.children;
-
-  if (sym.flags & OutputSymbolFlags.MemberContainer) {
-    children = withMemberScope(children);
-  }
-
-  return <CoreDeclaration symbol={sym}>{children}</CoreDeclaration>;
+  return <CoreDeclaration symbol={sym}>{props.children}</CoreDeclaration>;
 }

package/src/components/EnumDeclaration.tsx

@@ -2,19 +2,15 @@ import {
   Children,
   Declaration as CoreDeclaration,
   For,
-  MemberScope,
-  OutputSymbolFlags,
-  Scope,
   Show,
-  useBinder,
 } from "@alloy-js/core";
 import { enumModule } from "../builtins/python.js";
 import { createPythonSymbol } from "../symbol-creation.js";
-import { usePythonScope } from "../symbols/scopes.js";
 import { BaseDeclarationProps } from "./Declaration.js";
 import { EnumMember } from "./EnumMember.js";
-import { PythonBlock } from "./PythonBlock.jsx";
 import { SimpleCommentBlock } from "./index.js";
+import { MemberScope } from "./MemberScope.jsx";
+import { PythonBlock } from "./PythonBlock.jsx";
 
 export interface EnumProps extends BaseDeclarationProps {
   /**
@@ -115,18 +111,12 @@ export function EnumDeclaration(props: EnumProps) {
  * ```
  */
 export function FunctionalEnumDeclaration(props: EnumProps) {
-  const binder = useBinder();
-  const scope = usePythonScope();
   const sym = createPythonSymbol(
     props.name,
     {
-      binder: binder,
-      scope: scope,
       refkeys: props.refkey,
-      flags: OutputSymbolFlags.StaticMemberContainer,
     },
     "enum",
-    false,
   );
   const members = props.members ?? [];
   let opener, ender;
@@ -152,12 +142,7 @@ export function FunctionalEnumDeclaration(props: EnumProps) {
     <>
       <CoreDeclaration symbol={sym}>
         {sym.name} = {enumModule["."].Enum}('{sym.name}',{" "}
-        <MemberScope owner={sym}>
-          <Scope name={props.name} kind="enum">
-            {memberExpr}
-          </Scope>
-        </MemberScope>
-        )
+        <MemberScope ownerSymbol={sym}>{memberExpr}</MemberScope>)
       </CoreDeclaration>
     </>
   );
@@ -234,18 +219,12 @@ export function FunctionalEnumDeclaration(props: EnumProps) {
  */
 export function ClassEnumDeclaration(props: EnumProps) {
   const baseType = props.baseType || "Enum";
-  const binder = useBinder();
-  const scope = usePythonScope();
   const sym = createPythonSymbol(
     props.name,
     {
-      binder: binder,
-      scope: scope,
       refkeys: props.refkey,
-      flags: OutputSymbolFlags.StaticMemberContainer,
     },
     "enum",
-    false,
   );
   let memberList: Array<{
     name: string;
@@ -268,23 +247,21 @@ export function ClassEnumDeclaration(props: EnumProps) {
         <hbr />
       </Show>
       class {sym.name}({enumModule["."][baseType]})
-      <MemberScope owner={sym}>
-        <Scope name={sym.name} kind="enum">
-          <PythonBlock opener=":">
-            <For each={memberList} hardline>
-              {(member) => (
-                <EnumMember
-                  name={member.name}
-                  value={member.value}
-                  jsValue={member.jsValue}
-                  auto={member.auto}
-                  doc={member.doc}
-                />
-              )}
-            </For>
-            {props.children}
-          </PythonBlock>
-        </Scope>
+      <MemberScope ownerSymbol={sym}>
+        <PythonBlock opener=":">
+          <For each={memberList} hardline>
+            {(member) => (
+              <EnumMember
+                name={member.name}
+                value={member.value}
+                jsValue={member.jsValue}
+                auto={member.auto}
+                doc={member.doc}
+              />
+            )}
+          </For>
+          {props.children}
+        </PythonBlock>
       </MemberScope>
     </CoreDeclaration>
   );

package/src/components/EnumMember.tsx

@@ -1,4 +1,4 @@
-import { Children, OutputSymbolFlags, Refkey, Show } from "@alloy-js/core";
+import { Children, Refkey, Show } from "@alloy-js/core";
 import { enumModule } from "../builtins/python.js";
 import { createPythonSymbol } from "../symbol-creation.js";
 import { PythonOutputSymbol } from "../symbols/index.js";
@@ -62,10 +62,8 @@ export function EnumMember(props: EnumMemberProps) {
     props.name,
     {
       refkeys: props.refkey,
-      flags: OutputSymbolFlags.StaticMember,
     },
     "enum-member",
-    true,
   );
   const valueCode =
     props.jsValue !== undefined ? <Atom jsValue={props.jsValue} /> : value;

package/src/components/FunctionDeclaration.tsx

@@ -1,19 +1,10 @@
-import {
-  emitSymbol,
-  Name,
-  OutputScope,
-  OutputSymbolFlags,
-  Scope,
-  Show,
-  useMemberScope,
-  useScope,
-} from "@alloy-js/core";
+import { emitSymbol, Name, Show } from "@alloy-js/core";
 import { createPythonSymbol } from "../symbol-creation.js";
 import { getCallSignatureProps } from "../utils.js";
 import { CallSignature, CallSignatureProps } from "./CallSignature.jsx";
 import { BaseDeclarationProps, Declaration } from "./Declaration.js";
 import { PythonBlock } from "./PythonBlock.jsx";
-import { NoNamePolicy } from "./index.js";
+import { LexicalScope, NoNamePolicy } from "./index.js";
 
 export interface FunctionDeclarationProps
   extends BaseDeclarationProps,
@@ -42,23 +33,13 @@ export interface FunctionDeclarationProps
 export function FunctionDeclaration(props: FunctionDeclarationProps) {
   const asyncKwd = props.async ? "async " : "";
   const callSignatureProps = getCallSignatureProps(props, {});
-  const memberScope = useMemberScope();
-  let scope: OutputScope | undefined = undefined;
-  if (memberScope !== undefined) {
-    scope = memberScope.instanceMembers!;
-  } else {
-    scope = useScope();
-  }
-
   const sym = createPythonSymbol(
     props.name,
     {
-      scope: scope,
+      instance: props.instanceFunction,
       refkeys: props.refkey,
-      flags: props.flags ?? OutputSymbolFlags.None,
     },
     "function",
-    false,
   );
   emitSymbol(sym);
 
@@ -66,7 +47,7 @@ export function FunctionDeclaration(props: FunctionDeclarationProps) {
     <>
       <Declaration {...props} nameKind="function" symbol={sym}>
         {asyncKwd}def <Name />
-        <Scope name={sym.name} kind="function">
+        <LexicalScope name={sym.name}>
           <CallSignature
             {...callSignatureProps}
             returnType={props.returnType}
@@ -75,7 +56,7 @@ export function FunctionDeclaration(props: FunctionDeclarationProps) {
             <Show when={Boolean(props.doc)}>{props.doc}</Show>
             {props.children ?? "pass"}
           </PythonBlock>
-        </Scope>
+        </LexicalScope>
       </Declaration>
     </>
   );

package/src/components/LexicalScope.tsx

@@ -0,0 +1,24 @@
+import { Scope, ScopePropsWithInfo, ScopePropsWithValue } from "@alloy-js/core";
+import { createLexicalScope } from "../symbol-creation.js";
+import { PythonLexicalScope } from "../symbols/python-lexical-scope.js";
+
+export interface LexicalScopePropsWithScopeValue extends ScopePropsWithValue {}
+export interface LeixcalScopePropsWithScopeInfo extends ScopePropsWithInfo {}
+
+export type LexicalScopeProps =
+  | LexicalScopePropsWithScopeValue
+  | LeixcalScopePropsWithScopeInfo;
+
+export function LexicalScope(props: LexicalScopeProps) {
+  let scope;
+  if ("value" in props) {
+    if (!(props.value instanceof PythonLexicalScope)) {
+      throw new Error("LexicalScope value must be a TSLexicalScope instance");
+    }
+    scope = props.value;
+  } else {
+    scope = createLexicalScope(props.name ?? "Lexical scope", props);
+  }
+
+  return <Scope value={scope}>{props.children}</Scope>;
+}

package/src/components/MemberScope.tsx

@@ -0,0 +1,18 @@
+import { Children, MemberScope as CoreMemberScope } from "@alloy-js/core";
+import { PythonMemberScope } from "../symbols/python-member-scope.js";
+import { PythonOutputSymbol } from "../symbols/python-output-symbol.js";
+import { usePythonScope } from "../symbols/scopes.js";
+export interface MemberScopeProps {
+  children: Children;
+  ownerSymbol: PythonOutputSymbol;
+}
+
+export function MemberScope(props: MemberScopeProps) {
+  const memberScope = new PythonMemberScope("member-scope", usePythonScope(), {
+    ownerSymbol: props.ownerSymbol,
+  });
+
+  return (
+    <CoreMemberScope value={memberScope}>{props.children}</CoreMemberScope>
+  );
+}

package/src/components/SourceFile.tsx

@@ -70,7 +70,7 @@ export function SourceFile(props: SourceFileProps) {
   const path: string = join(currentDir, props.path)
     .replace(/\.py$/, "")
     .replace(/\//g, ".");
-  const scope = new PythonModuleScope(path);
+  const scope = new PythonModuleScope(path, undefined);
   const sfContext: PythonSourceFileContext = {
     scope: scope,
     module: path,
@@ -84,7 +84,7 @@ export function SourceFile(props: SourceFileProps) {
         <hbr />
       </Show>
       <PythonSourceFileContext.Provider value={sfContext}>
-        <Scope value={scope} kind="source-file">
+        <Scope value={scope}>
           <List doubleHardline>{props.children}</List>
         </Scope>
       </PythonSourceFileContext.Provider>

package/src/components/VariableDeclaration.tsx

@@ -2,15 +2,10 @@ import {
   Children,
   Declaration as CoreDeclaration,
   Name,
-  OutputScope,
-  OutputSymbolFlags,
   Show,
   createSymbolSlot,
-  effect,
   emitSymbol,
   memo,
-  useMemberScope,
-  useScope,
 } from "@alloy-js/core";
 import { createPythonSymbol } from "../symbol-creation.js";
 import { Atom } from "./Atom.jsx";
@@ -77,27 +72,23 @@ export interface VariableDeclarationProps extends BaseDeclarationProps {
  * ```
  */
 export function VariableDeclaration(props: VariableDeclarationProps) {
-  const instanceVariable = props.instanceVariable ?? false;
   const TypeSymbolSlot = createSymbolSlot();
   const ValueTypeSymbolSlot = createSymbolSlot();
-  const memberScope = useMemberScope();
-  let scope: OutputScope | undefined = undefined;
-  // Only consider the member scope if this is an instance variable
-  if (memberScope !== undefined && instanceVariable) {
-    scope = memberScope.instanceMembers!;
-  } else {
-    scope = useScope();
-  }
 
   const sym = createPythonSymbol(
     props.name,
     {
-      scope: scope,
+      instance: props.instanceVariable,
       refkeys: props.refkey,
+      type: props.type ? TypeSymbolSlot.firstSymbol : undefined,
     },
     "variable",
-    true,
   );
+
+  if (!props.type) {
+    ValueTypeSymbolSlot.moveMembersTo(sym);
+  }
+
   emitSymbol(sym);
   // Handle optional type annotation
   const type = memo(() => {
@@ -109,25 +100,6 @@ export function VariableDeclaration(props: VariableDeclarationProps) {
     );
   });
 
-  effect(() => {
-    if (TypeSymbolSlot.ref.value) {
-      const takenSymbols = TypeSymbolSlot.ref.value;
-      for (const symbol of takenSymbols) {
-        // If the symbol is a type, instantiate it
-        symbol.instantiateTo(sym);
-      }
-    } else if (ValueTypeSymbolSlot.ref.value) {
-      const takenSymbols = ValueTypeSymbolSlot.ref.value;
-      for (const symbol of takenSymbols) {
-        // ignore non-transient symbols (likely not the result of an
-        // expression).
-        if (symbol.flags & OutputSymbolFlags.Transient) {
-          symbol.moveTo(sym);
-        }
-      }
-    }
-  });
-
   // If we receive a symbol, resolve it to a name
   const value =
     typeof props.initializer === "object" ?

package/src/components/index.ts

@@ -8,7 +8,9 @@ export * from "./EnumMember.js";
 export * from "./FunctionCallExpression.js";
 export * from "./FunctionDeclaration.js";
 export * from "./ImportStatement.js";
+export * from "./LexicalScope.js";
 export * from "./MemberExpression.js";
+export * from "./MemberScope.jsx";
 export * from "./NoNamePolicy.js";
 export * from "./PyDoc.js";
 export * from "./PythonBlock.js";

package/src/create-module.ts

@@ -36,8 +36,7 @@ function createSymbols(
     // Otherwise, we append the path to the module name
     const fullModuleScopeName = props.name + (path === "." ? "" : `.${path}`);
     const keys = refkeys[path];
-    const moduleScope = new PythonModuleScope(fullModuleScopeName, {
-      parent: undefined,
+    const moduleScope = new PythonModuleScope(fullModuleScopeName, undefined, {
       binder: binder,
     });
 
@@ -45,17 +44,12 @@ function createSymbols(
     for (const exportedName of symbols ?? []) {
       const key = keys[exportedName];
 
-      const _ = createPythonSymbol(
-        exportedName,
-        {
-          binder: binder,
-          scope: moduleScope,
-          refkeys: key,
-          module: moduleScope.name,
-        },
-        undefined,
-        false,
-      );
+      const _ = createPythonSymbol(exportedName, {
+        space: moduleScope.symbols,
+        binder: binder,
+        refkeys: key,
+        module: moduleScope.name,
+      });
     }
   }
 }

package/src/name-conflict-resolver.ts

@@ -0,0 +1,21 @@
+import { PythonOutputSymbol } from "./symbols/python-output-symbol.js";
+
+export function pythonNameConflictResolver(
+  _: string,
+  symbols: PythonOutputSymbol[],
+) {
+  for (let i = 1; i < symbols.length; i++) {
+    // Rename all but the first symbol to have a suffix of _2, _3, plus the scope name if available.
+    const symbol = symbols[i] as unknown as {
+      originalName: string;
+      name: string;
+      module?: string;
+    };
+    symbol.name =
+      symbol.originalName +
+      "_" +
+      (i + 1) +
+      "_" +
+      (symbols[i].aliasTarget?.scope?.name ?? symbol.module ?? "");
+  }
+}