@harmoniclabs/pebble 0.1.10 → 0.3.0

package/dist/ast/nodes/statements/TestStmt.d.ts

@@ -1,10 +1,12 @@
 import { SourceRange } from "../../Source/SourceRange.js";
-import { LitStrExpr } from "../expr/litteral/LitStrExpr.js";
+import { Identifier } from "../common/Identifier.js";
 import { HasSourceRange } from "../HasSourceRange.js";
 import { BlockStmt } from "./BlockStmt.js";
+import { TestParam } from "./TestParam.js";
 export declare class TestStmt implements HasSourceRange {
-    readonly testName: LitStrExpr | undefined;
+    readonly testName: Identifier;
+    readonly params: TestParam[];
     readonly body: BlockStmt;
     readonly range: SourceRange;
-    constructor(testName: LitStrExpr | undefined, body: BlockStmt, range: SourceRange);
+    constructor(testName: Identifier, params: TestParam[], body: BlockStmt, range: SourceRange);
 }

package/dist/ast/nodes/statements/TestStmt.js

@@ -1,9 +1,11 @@
 export class TestStmt {
     testName;
+    params;
     body;
     range;
-    constructor(testName, body, range) {
+    constructor(testName, params, body, range) {
         this.testName = testName;
+        this.params = params;
         this.body = body;
         this.range = range;
     }

package/dist/ast/nodes/statements/UsingStmt.d.ts

@@ -2,11 +2,30 @@ import { SourceRange } from "../../Source/SourceRange.js";
 import { Identifier } from "../common/Identifier.js";
 import { HasSourceRange } from "../HasSourceRange.js";
 import { AstTypeExpr } from "../types/AstTypeExpr.js";
+/**
+ * dotted chain of identifiers used as the RHS of a `using` statement
+ * to refer to a namespace path (e.g. `std.builtins`).
+ */
+export declare class UsingPath implements HasSourceRange {
+    readonly segments: Identifier[];
+    readonly range: SourceRange;
+    constructor(segments: Identifier[], range: SourceRange);
+}
+export type UsingRhs = AstTypeExpr | UsingPath;
+/**
+ * `using { a, b: renamed } = <rhs>;`
+ *
+ * `<rhs>` may be either a struct type expression (existing behavior,
+ * bringing constructors into scope) or a namespace path (new behavior,
+ * destructuring the namespace's exported members into scope).
+ */
 export declare class UsingStmt implements HasSourceRange {
     readonly constructorNames: UsingStmtDeclaredConstructor[];
-    readonly structTypeExpr: AstTypeExpr;
+    readonly rhs: UsingRhs;
     readonly range: SourceRange;
-    constructor(constructorNames: UsingStmtDeclaredConstructor[], structTypeExpr: AstTypeExpr, range: SourceRange);
+    constructor(constructorNames: UsingStmtDeclaredConstructor[], rhs: UsingRhs, range: SourceRange);
+    /** legacy accessor for code paths still expecting `structTypeExpr` */
+    get structTypeExpr(): UsingRhs;
 }
 export declare class UsingStmtDeclaredConstructor implements HasSourceRange {
     readonly constructorName: Identifier;
@@ -14,3 +33,14 @@ export declare class UsingStmtDeclaredConstructor implements HasSourceRange {
     readonly range: SourceRange;
     constructor(constructorName: Identifier, renamedConstructorName: Identifier | undefined, range: SourceRange);
 }
+/**
+ * `using <aliasName> = <rhs>;`
+ *
+ * binds `aliasName` as a local alias for the namespace identified by `rhs`.
+ */
+export declare class UsingAliasStmt implements HasSourceRange {
+    readonly aliasName: Identifier;
+    readonly rhs: UsingPath;
+    readonly range: SourceRange;
+    constructor(aliasName: Identifier, rhs: UsingPath, range: SourceRange);
+}

package/dist/ast/nodes/statements/UsingStmt.js

@@ -1,12 +1,33 @@
+/**
+ * dotted chain of identifiers used as the RHS of a `using` statement
+ * to refer to a namespace path (e.g. `std.builtins`).
+ */
+export class UsingPath {
+    segments;
+    range;
+    constructor(segments, range) {
+        this.segments = segments;
+        this.range = range;
+    }
+}
+/**
+ * `using { a, b: renamed } = <rhs>;`
+ *
+ * `<rhs>` may be either a struct type expression (existing behavior,
+ * bringing constructors into scope) or a namespace path (new behavior,
+ * destructuring the namespace's exported members into scope).
+ */
 export class UsingStmt {
     constructorNames;
-    structTypeExpr;
+    rhs;
     range;
-    constructor(constructorNames, structTypeExpr, range) {
+    constructor(constructorNames, rhs, range) {
         this.constructorNames = constructorNames;
-        this.structTypeExpr = structTypeExpr;
+        this.rhs = rhs;
         this.range = range;
     }
+    /** legacy accessor for code paths still expecting `structTypeExpr` */
+    get structTypeExpr() { return this.rhs; }
 }
 export class UsingStmtDeclaredConstructor {
     constructorName;
@@ -18,3 +39,18 @@ export class UsingStmtDeclaredConstructor {
         this.range = range;
     }
 }
+/**
+ * `using <aliasName> = <rhs>;`
+ *
+ * binds `aliasName` as a local alias for the namespace identified by `rhs`.
+ */
+export class UsingAliasStmt {
+    aliasName;
+    rhs;
+    range;
+    constructor(aliasName, rhs, range) {
+        this.aliasName = aliasName;
+        this.rhs = rhs;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/declarations/NamespaceDecl.d.ts

@@ -0,0 +1,21 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { Identifier } from "../../common/Identifier.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { VarStmt } from "../VarStmt.js";
+import { FuncDecl } from "./FuncDecl.js";
+import { InterfaceDecl } from "./InterfaceDecl.js";
+import { PebbleTypeDecl } from "./PebbleTypeDecl.js";
+export type NamespaceMemberStmt = VarStmt | FuncDecl | PebbleTypeDecl | InterfaceDecl | NamespaceDecl;
+export declare function isNamespaceMemberStmt(thing: any): thing is NamespaceMemberStmt;
+export declare class NamespaceMember implements HasSourceRange {
+    readonly isPrivate: boolean;
+    readonly stmt: NamespaceMemberStmt;
+    readonly range: SourceRange;
+    constructor(isPrivate: boolean, stmt: NamespaceMemberStmt, range: SourceRange);
+}
+export declare class NamespaceDecl implements HasSourceRange {
+    readonly name: Identifier;
+    readonly members: NamespaceMember[];
+    readonly range: SourceRange;
+    constructor(name: Identifier, members: NamespaceMember[], range: SourceRange);
+}

package/dist/ast/nodes/statements/declarations/NamespaceDecl.js

@@ -0,0 +1,31 @@
+import { VarStmt } from "../VarStmt.js";
+import { FuncDecl } from "./FuncDecl.js";
+import { InterfaceDecl } from "./InterfaceDecl.js";
+import { isPebbleTypeDecl } from "./PebbleTypeDecl.js";
+export function isNamespaceMemberStmt(thing) {
+    return (thing instanceof VarStmt
+        || thing instanceof FuncDecl
+        || isPebbleTypeDecl(thing)
+        || thing instanceof InterfaceDecl
+        || thing instanceof NamespaceDecl);
+}
+export class NamespaceMember {
+    isPrivate;
+    stmt;
+    range;
+    constructor(isPrivate, stmt, range) {
+        this.isPrivate = isPrivate;
+        this.stmt = stmt;
+        this.range = range;
+    }
+}
+export class NamespaceDecl {
+    name;
+    members;
+    range;
+    constructor(name, members, range) {
+        this.name = name;
+        this.members = members;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/declarations/StructDecl.d.ts

@@ -4,9 +4,23 @@ import { HasSourceRange } from "../../HasSourceRange.js";
 import { SimpleVarDecl } from "./VarDecl/SimpleVarDecl.js";
 export declare enum StructDeclAstFlags {
     none = 0,
-    untaggedSingleConstructor = 1,
+    /**
+     * Hint that the user used the shortcut single-constructor syntax
+     * (`struct Foo { x: int }` rather than `struct Foo { Foo { x: int } }`).
+     * Whether the resulting Data encoding is tagged (`constrData(0, ...)`)
+     * or untagged (`listData(...)`) is decided by the compiler's
+     * `encodingStrategy` option — `"default"` keeps the tagged form for
+     * backwards compatibility; `"minimal"` opts shortcut forms in to the
+     * untagged form.
+     */
+    shortcutSingleConstructor = 1,
     onlyDataEncoding = 2,
-    onlySopEncoding = 4
+    onlySopEncoding = 4,
+    /**
+     * Explicit `untagged` modifier. Forces the untagged listData encoding
+     * regardless of `encodingStrategy`. Requires a single constructor.
+     */
+    untagged = 8
 }
 export declare class StructDecl implements HasSourceRange {
     readonly name: Identifier;

package/dist/ast/nodes/statements/declarations/StructDecl.js

@@ -1,9 +1,23 @@
 export var StructDeclAstFlags;
 (function (StructDeclAstFlags) {
     StructDeclAstFlags[StructDeclAstFlags["none"] = 0] = "none";
-    StructDeclAstFlags[StructDeclAstFlags["untaggedSingleConstructor"] = 1] = "untaggedSingleConstructor";
+    /**
+     * Hint that the user used the shortcut single-constructor syntax
+     * (`struct Foo { x: int }` rather than `struct Foo { Foo { x: int } }`).
+     * Whether the resulting Data encoding is tagged (`constrData(0, ...)`)
+     * or untagged (`listData(...)`) is decided by the compiler's
+     * `encodingStrategy` option — `"default"` keeps the tagged form for
+     * backwards compatibility; `"minimal"` opts shortcut forms in to the
+     * untagged form.
+     */
+    StructDeclAstFlags[StructDeclAstFlags["shortcutSingleConstructor"] = 1] = "shortcutSingleConstructor";
     StructDeclAstFlags[StructDeclAstFlags["onlyDataEncoding"] = 2] = "onlyDataEncoding";
     StructDeclAstFlags[StructDeclAstFlags["onlySopEncoding"] = 4] = "onlySopEncoding";
+    /**
+     * Explicit `untagged` modifier. Forces the untagged listData encoding
+     * regardless of `encodingStrategy`. Requires a single constructor.
+     */
+    StructDeclAstFlags[StructDeclAstFlags["untagged"] = 8] = "untagged";
 })(StructDeclAstFlags || (StructDeclAstFlags = {}));
 export class StructDecl {
     name;

package/dist/compiler/AstCompiler/AstCompiler.d.ts

@@ -86,11 +86,38 @@ export declare class AstCompiler extends DiagnosticEmitter {
     private _collectInterfaceImplSigs;
     private _collectTopLevelConst;
     private _collectTopLevelFuncDeclSig;
+    /**
+     * Register a generic function template. Compile only the signature in a
+     * scope where each type parameter is bound to a `TirTypeParam`; the body
+     * is deferred until `monomorphizeGeneric` is invoked at a call site.
+     */
+    private _registerGenericTemplate;
+    /**
+     * Resolve a `<T implements I>` constraint clause to a `TypeParamConstraint`.
+     *
+     * - `decl.constraint` must be a bare `AstNamedTypeExpr` (no type args).
+     * - The named interface must be registered in `scope.interfaces`
+     *   (walking up the parent chain via `resolveInterface`).
+     *
+     * The returned object captures the AST method signatures verbatim so the
+     * monomorphizer doesn't have to re-resolve the interface each time.
+     */
+    private _resolveTypeParamConstraint;
+    /**
+     * walks `stmts` for `NamespaceDecl` (optionally wrapped in `ExportStmt`),
+     * compiles each one into a `NamespaceSymbol`, and registers it on
+     * `enclosingScope` (and `enclosingExports` when exported).
+     *
+     * removes processed `NamespaceDecl` statements from `stmts`.
+     */
+    private _collectNamespaceDeclarations;
+    private _compileNamespaceDecl;
     private _collectInterfaceDeclarations;
     registerInternalTypeDecl(decl: StructDecl | TypeAliasDecl): void;
     private _collectTypeDeclarations;
     private _compileStructDecl;
     private _compileTypeAliasDecl;
+    private _compileEnumDecl;
     private _consumeImportsAddSymsInScope;
     private _readFile;
     /** MUST NOT be used as a "seen" log */

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -1,5 +1,6 @@
 import { StructDecl, StructDeclAstFlags } from "../../ast/nodes/statements/declarations/StructDecl.js";
 import { TypeAliasDecl } from "../../ast/nodes/statements/declarations/TypeAliasDecl.js";
+import { EnumDecl } from "../../ast/nodes/statements/declarations/EnumDecl.js";
 import { ExportStarStmt } from "../../ast/nodes/statements/ExportStarStmt.js";
 import { ImportStarStmt } from "../../ast/nodes/statements/ImportStarStmt.js";
 import { ImportStmt } from "../../ast/nodes/statements/ImportStmt.js";
@@ -12,6 +13,7 @@ import { createMemoryCompilerIoApi } from "../io/CompilerIoApi.js";
 import { TypedProgram } from "../tir/program/TypedProgram.js";
 import { TirAliasType } from "../tir/types/TirAliasType.js";
 import { TirDataStructType, TirSoPStructType, TirStructConstr, TirStructField } from "../tir/types/TirStructType.js";
+import { TirEnumType } from "../tir/types/TirEnumType.js";
 import { ExportStmt } from "../../ast/nodes/statements/ExportStmt.js";
 import { ResolveStackNode } from "./utils/deps/ResolveStackNode.js";
 import { AstCompilationCtx } from "./AstCompilationCtx.js";
@@ -29,14 +31,18 @@ import { CommonFlags } from "../../common.js";
 import { SimpleVarDecl } from "../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
 import { Identifier } from "../../ast/nodes/common/Identifier.js";
 import { ArrowKind } from "../../ast/nodes/expr/functions/ArrowKind.js";
-import { _compileFuncExpr } from "./internal/exprs/_compileFuncExpr.js";
+import { _compileFuncExpr, getDataFuncSignature } from "./internal/exprs/_compileFuncExpr.js";
+import { TirTypeParam } from "../tir/types/TirTypeParam.js";
 import { ContractDecl } from "../../ast/nodes/statements/declarations/ContractDecl.js";
 import { _deriveContractBody } from "./internal/_deriveContractBody/_deriveContractBody.js";
 import { DiagnosticCategory } from "../../diagnostics/DiagnosticCategory.js";
 import { VarStmt } from "../../ast/nodes/statements/VarStmt.js";
 import { _compileSimpleVarDecl } from "./internal/statements/_compileVarStmt.js";
+import { _compileTestStmt } from "./internal/statements/_compileTestStmt.js";
 import { SourceTypeMap } from "../SourceTypeMap.js";
 import { isIdentifier } from "../../utils/text.js";
+import { TestStmt } from "../../ast/nodes/statements/TestStmt.js";
+import { NamespaceDecl } from "../../ast/nodes/statements/declarations/NamespaceDecl.js";
 /*
 Handling type expressions that depend on other types
 (such as generics, function return types, and inferred types from complex expressions)
@@ -273,6 +279,9 @@ export class AstCompiler extends DiagnosticEmitter {
         this._consumeImportsAddSymsInScope(stmts, src.absoluteProjPath, importsScope);
         const topLevelScope = importsScope.newChildScope({ isFunctionDeclScope: false });
         const srcExports = this.preludeScope.newChildScope({ isFunctionDeclScope: false });
+        // collect namespace declarations (recursively) so that types/interfaces/signatures
+        // can refer to symbols defined inside namespaces.
+        this._collectNamespaceDeclarations(stmts, src.uid, topLevelScope, srcExports);
         // collect top level **type** (struct and aliases) declarations
         this._collectTypeDeclarations(stmts, src.uid, topLevelScope, srcExports);
         // collect top level **interface** declarations (NOT implementations)
@@ -300,6 +309,17 @@ export class AstCompiler extends DiagnosticEmitter {
                 exportRange = stmt.range;
                 stmt = stmt.stmt;
             }
+            if (stmt instanceof TestStmt) {
+                if (isEntryFile) {
+                    const declContext = AstCompilationCtx.fromScope(this.program, topLevelScope);
+                    _compileTestStmt(declContext, stmt, srcUid, this.cfg.entry);
+                }
+                // tests from non-entry files are dropped on the floor:
+                // they will be collected when their own file is the entry.
+                void stmts.splice(i, 1);
+                i--;
+                continue;
+            }
             if (!(stmt instanceof FuncDecl
                 || stmt instanceof TypeImplementsStmt
                 || stmt instanceof ContractDecl
@@ -428,6 +448,14 @@ export class AstCompiler extends DiagnosticEmitter {
         if (this._isExporting && astFuncName === this.program.contractTirFuncName) {
             this.program.contractTirFuncName = tirFuncName;
         }
+        // Generic function declaration path: do NOT compile the body. Instead,
+        // compile the signature in a scope where each type parameter resolves
+        // to a fresh `TirTypeParam`, then register a `GenericTemplate` on the
+        // program. Call sites instantiate it via `monomorphizeGeneric`.
+        if (astFuncExpr.typeParams.length > 0) {
+            this._registerGenericTemplate(astFuncExpr, astFuncName, tirFuncName, topLevelScope, srcExports, exportRange);
+            return;
+        }
         const declContext = AstCompilationCtx.fromScope(this.program, topLevelScope);
         const funcExpr = _compileFuncExpr(declContext, astFuncExpr, undefined, // sig
         false // isMethod
@@ -456,6 +484,160 @@ export class AstCompiler extends DiagnosticEmitter {
             && this.program.contractTirFuncName === "")
             this.program.contractTirFuncName = tirFuncName;
     }
+    /**
+     * Register a generic function template. Compile only the signature in a
+     * scope where each type parameter is bound to a `TirTypeParam`; the body
+     * is deferred until `monomorphizeGeneric` is invoked at a call site.
+     */
+    _registerGenericTemplate(astFuncExpr, astFuncName, tirFuncName, topLevelScope, srcExports, exportRange) {
+        if (topLevelScope.functions.has(astFuncName))
+            return this.error(DiagnosticCode._0_is_already_defined, astFuncExpr.name.range, astFuncName);
+        // Detect duplicate type-param names on the template
+        const seenParamNames = new Set();
+        const tirTypeParams = [];
+        for (const decl of astFuncExpr.typeParams) {
+            if (seenParamNames.has(decl.name.text)) {
+                return this.error(DiagnosticCode._0_is_already_defined, decl.name.range, decl.name.text);
+            }
+            seenParamNames.add(decl.name.text);
+            tirTypeParams.push(new TirTypeParam(decl.name.text));
+        }
+        // Build a child scope where each type-param name resolves to its
+        // TirTypeParam (via `_compileDataEncodedConcreteType`'s new lookup).
+        const templateScope = topLevelScope.newChildScope({
+            ...topLevelScope.infos,
+            isFunctionDeclScope: false,
+            isMethodScope: false
+        });
+        for (let i = 0; i < astFuncExpr.typeParams.length; i++) {
+            templateScope.defineTypeParam(astFuncExpr.typeParams[i].name.text, tirTypeParams[i]);
+        }
+        // Resolve constraints on each type param (the `implements I` clause).
+        // For each constrained param, record the constraint on the template
+        // so monomorphizeGeneric can inject the matching dictionary at call
+        // sites, and on the template scope so `getPropAccessReturnType` can
+        // resolve method calls on `T`-typed values inside the body.
+        const constraints = new Array(astFuncExpr.typeParams.length).fill(undefined);
+        for (let i = 0; i < astFuncExpr.typeParams.length; i++) {
+            const decl = astFuncExpr.typeParams[i];
+            if (!decl.constraint)
+                continue;
+            const con = this._resolveTypeParamConstraint(templateScope, decl);
+            if (!con)
+                return undefined;
+            constraints[i] = con;
+            templateScope.defineTypeParamConstraint(decl.name.text, con);
+        }
+        // Compile only the signature: yields a TirFuncT that may contain
+        // TirTypeParams in arg/return positions.
+        const templateCtx = AstCompilationCtx.fromScope(this.program, templateScope);
+        const placeholderFuncType = getDataFuncSignature(templateCtx, astFuncExpr.signature);
+        if (!placeholderFuncType)
+            return undefined;
+        // Register the template on the program
+        this.program.genericTemplates.set(astFuncName, {
+            kind: "user",
+            astFuncName,
+            astFuncExpr,
+            typeParams: tirTypeParams,
+            definingScope: topLevelScope,
+            canonicalTirName: tirFuncName,
+            placeholderFuncType,
+            constraints,
+        });
+        // Register the generic placeholder value in the top-level scope so
+        // identifier lookup at call sites finds it. The `genericTemplateName`
+        // field signals to `_compileCallExpr` that this is a template.
+        topLevelScope.functions.set(astFuncName, tirFuncName);
+        topLevelScope.defineValue({
+            name: astFuncName,
+            type: placeholderFuncType,
+            isConstant: true,
+            genericTemplateName: astFuncName,
+        });
+        if (exportRange && srcExports) {
+            if (srcExports.functions.has(astFuncName)
+                || srcExports.variables.has(astFuncName))
+                return this.error(DiagnosticCode._0_is_already_exported, exportRange, astFuncName);
+            srcExports.functions.set(astFuncName, tirFuncName);
+            srcExports.defineValue({
+                name: astFuncName,
+                type: placeholderFuncType,
+                isConstant: true,
+                genericTemplateName: astFuncName,
+            });
+        }
+    }
+    /**
+     * Resolve a `<T implements I>` constraint clause to a `TypeParamConstraint`.
+     *
+     * - `decl.constraint` must be a bare `AstNamedTypeExpr` (no type args).
+     * - The named interface must be registered in `scope.interfaces`
+     *   (walking up the parent chain via `resolveInterface`).
+     *
+     * The returned object captures the AST method signatures verbatim so the
+     * monomorphizer doesn't have to re-resolve the interface each time.
+     */
+    _resolveTypeParamConstraint(scope, decl) {
+        const constraint = decl.constraint;
+        if (!constraint)
+            return undefined;
+        if (!(constraint instanceof AstNamedTypeExpr))
+            return this.error(DiagnosticCode.Type_expected, constraint.range);
+        if (constraint.tyArgs.length > 0)
+            return this.error(DiagnosticCode.Not_implemented_0, constraint.range, "generic interface as a type-parameter constraint");
+        const interfaceName = constraint.name.text;
+        const methods = scope.resolveInterface(interfaceName);
+        if (!methods)
+            return this.error(DiagnosticCode._0_is_not_defined, constraint.name.range, interfaceName);
+        return { interfaceName, methods };
+    }
+    /**
+     * walks `stmts` for `NamespaceDecl` (optionally wrapped in `ExportStmt`),
+     * compiles each one into a `NamespaceSymbol`, and registers it on
+     * `enclosingScope` (and `enclosingExports` when exported).
+     *
+     * removes processed `NamespaceDecl` statements from `stmts`.
+     */
+    _collectNamespaceDeclarations(stmts, srcUid, enclosingScope, enclosingExports) {
+        for (let i = 0; i < stmts.length; i++) {
+            let stmt = stmts[i];
+            let exported = false;
+            if (stmt instanceof ExportStmt) {
+                exported = true;
+                stmt = stmt.stmt;
+            }
+            if (!(stmt instanceof NamespaceDecl))
+                continue;
+            this._compileNamespaceDecl(stmt, srcUid, enclosingScope, enclosingExports, exported);
+            void stmts.splice(i, 1);
+            i--;
+        }
+    }
+    _compileNamespaceDecl(decl, srcUid, enclosingScope, enclosingExports, isExported) {
+        const nsName = decl.name.text;
+        if (enclosingScope.namespaces.has(nsName))
+            return this.error(DiagnosticCode._0_is_already_defined, decl.name.range, nsName);
+        const compilationScope = enclosingScope.newChildScope({ isFunctionDeclScope: false });
+        const publicScope = enclosingScope.newChildScope({ isFunctionDeclScope: false });
+        const nsSrcUid = `${srcUid}::${nsName}`;
+        // build a synthetic top-level statement list from the namespace's members:
+        // wrap public members in ExportStmt so the existing passes route them
+        // to `publicScope` automatically; leave private members bare so they only
+        // live in `compilationScope`.
+        const fakeStmts = decl.members.map((m) => m.isPrivate
+            ? m.stmt
+            : new ExportStmt(m.stmt, m.range));
+        // recurse into nested namespaces first so subsequent passes can
+        // resolve `Inner.Member` references.
+        this._collectNamespaceDeclarations(fakeStmts, nsSrcUid, compilationScope, publicScope);
+        this._collectTypeDeclarations(fakeStmts, nsSrcUid, compilationScope, publicScope);
+        this._collectInterfaceDeclarations(fakeStmts, compilationScope, publicScope);
+        this._collectAllTopLevelSignatures(fakeStmts, nsSrcUid, compilationScope, publicScope, false);
+        enclosingScope.defineNamespace({ name: nsName, publicScope });
+        if (isExported)
+            enclosingExports.defineNamespace({ name: nsName, publicScope });
+    }
     _collectInterfaceDeclarations(stmts, topLevelScope, srcExports) {
         for (let i = 0; i < stmts.length; i++) {
             let stmt = stmts[i];
@@ -495,12 +677,15 @@ export class AstCompiler extends DiagnosticEmitter {
                 stmt = stmt.stmt;
             }
             if (!(stmt instanceof StructDecl
-                || stmt instanceof TypeAliasDecl))
+                || stmt instanceof TypeAliasDecl
+                || stmt instanceof EnumDecl))
                 continue;
-            const isGeneric = stmt.typeParams.length > 0;
+            const isGeneric = stmt instanceof EnumDecl ? false : stmt.typeParams.length > 0;
             const tirTypes = stmt instanceof StructDecl
                 ? this._compileStructDecl(stmt, srcUid, topLevelScope)
-                : this._compileTypeAliasDecl(stmt, srcUid, topLevelScope);
+                : stmt instanceof EnumDecl
+                    ? this._compileEnumDecl(stmt, srcUid, topLevelScope)
+                    : this._compileTypeAliasDecl(stmt, srcUid, topLevelScope);
             if (!tirTypes // undefined
                 || !(tirTypes.sop || tirTypes.data) // or both undefined
             )
@@ -563,6 +748,16 @@ export class AstCompiler extends DiagnosticEmitter {
         // data encoded type
         if (!stmt.hasFlag(StructDeclAstFlags.onlySopEncoding)) {
             let canEncodeToData = true;
+            // Untagged Data encoding (`listData(...)`) instead of
+            // `constrData(0, ...)`. Requires exactly one constructor and is
+            // enabled by either the explicit `untagged` keyword or the
+            // shortcut-form syntax when `encodingStrategy === "minimal"`.
+            const isUntagged = stmt.constrs.length === 1 && (stmt.hasFlag(StructDeclAstFlags.untagged)
+                || (stmt.hasFlag(StructDeclAstFlags.shortcutSingleConstructor)
+                    && this.cfg.encodingStrategy === "minimal"));
+            if (stmt.hasFlag(StructDeclAstFlags.untagged) && stmt.constrs.length !== 1) {
+                this.error(DiagnosticCode.Not_implemented_0, stmt.name.range, "`untagged` struct must have exactly one constructor");
+            }
             const dataType = new TirDataStructType(stmt.name.text, srcUid, stmt.constrs.map(ctor => new TirStructConstr(ctor.name.text, ctor.fields.map(field => {
                 if (!field.type)
                     return compiler.error(DiagnosticCode.Type_expected, field.name.range.atEnd());
@@ -576,7 +771,7 @@ export class AstCompiler extends DiagnosticEmitter {
                 }
                 return new TirStructField(field.name.text, fieldType);
             })
-                .filter(f => f instanceof TirStructField))), methodsNames);
+                .filter(f => f instanceof TirStructField))), methodsNames, isUntagged);
             if (canEncodeToData)
                 data = dataType;
             else if (stmt.hasFlag(StructDeclAstFlags.onlyDataEncoding))
@@ -599,11 +794,49 @@ export class AstCompiler extends DiagnosticEmitter {
         ) : undefined;
         return sop || data ? { sop, data, methodsNames } : undefined;
     }
+    _compileEnumDecl(stmt, srcUid, _topLevelScope) {
+        if (stmt.members.length === 0) {
+            this.error(DiagnosticCode.Enum_must_have_at_least_one_member, stmt.name.range);
+            return undefined;
+        }
+        const seen = new Set();
+        const memberNames = [];
+        for (const m of stmt.members) {
+            if (m.value !== undefined) {
+                this.error(DiagnosticCode.Enum_members_cannot_have_explicit_values, m.range);
+            }
+            if (seen.has(m.name.text)) {
+                this.error(DiagnosticCode.Duplicate_enum_member_0, m.name.range, m.name.text);
+                continue;
+            }
+            seen.add(m.name.text);
+            memberNames.push(m.name.text);
+        }
+        const methodsNames = new Map();
+        const enumType = new TirEnumType(stmt.name.text, srcUid, memberNames, methodsNames);
+        return { sop: enumType, data: enumType, methodsNames };
+    }
     _consumeImportsAddSymsInScope(stmts, srcAbsPath, srcImportsScope) {
         for (let i = 0; i < stmts.length; i++) {
             const stmt = stmts[i];
             if (stmt instanceof ImportStarStmt) {
-                this.error(DiagnosticCode.Not_implemented_0, stmt.range, "import *");
+                const importAbsPath = getAbsolutePath(stmt.fromPath.string, srcAbsPath) ?? "";
+                const importedSymbols = this.program.getExportedSymbols(importAbsPath);
+                if (!importedSymbols) {
+                    this.error(DiagnosticCode.File_0_not_found, stmt.fromPath.range, importAbsPath);
+                    void stmts.splice(i, 1);
+                    i--;
+                    continue;
+                }
+                const aliasName = stmt.anIdentifier.text;
+                const ok = srcImportsScope.defineNamespace({
+                    name: aliasName,
+                    publicScope: importedSymbols
+                });
+                if (!ok)
+                    this.error(DiagnosticCode._0_is_already_defined, stmt.anIdentifier.range, aliasName);
+                void stmts.splice(i, 1);
+                i--;
                 continue;
             }
             if (!(stmt instanceof ImportStmt))
@@ -620,10 +853,12 @@ export class AstCompiler extends DiagnosticEmitter {
                 const isType = importedSymbols.types.has(declName);
                 const isFunction = importedSymbols.functions.has(declName);
                 const isInterface = importedSymbols.interfaces.has(declName);
+                const isNamespace = importedSymbols.namespaces.has(declName);
                 if (!(isValue
                     || isType
                     || isFunction
-                    || isInterface)) {
+                    || isInterface
+                    || isNamespace)) {
                     this.error(DiagnosticCode.Module_0_has_no_exported_member_1, importDecl.identifier.range, stmt.fromPath.string, declName);
                     continue;
                 }
@@ -647,6 +882,8 @@ export class AstCompiler extends DiagnosticEmitter {
                     srcImportsScope.types.set(declName, importedSymbols.types.get(declName));
                 if (isInterface)
                     srcImportsScope.interfaces.set(declName, importedSymbols.interfaces.get(declName));
+                if (isNamespace)
+                    srcImportsScope.defineNamespace(importedSymbols.namespaces.get(declName));
             }
             // remove from array so we don't process it again
             void stmts.splice(i, 1);