@harmoniclabs/pebble 0.1.10 → 0.3.0

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLessThanEqualExpr.js

@@ -2,6 +2,7 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirLessThanEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { int_t, bytes_t } from "../../../../tir/program/stdScope/stdScope.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileLessThanEqualExpr(ctx, expr, typeHint) {
@@ -11,7 +12,7 @@ export function _compileLessThanEqualExpr(ctx, expr, typeHint) {
     if (!canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    let leftType = left.type;
+    let leftType = normalizeEnumToInt(left.type, int_t);
     while (leftType instanceof TirAliasType)
         leftType = leftType.aliased;
     const right = _compileExpr(ctx, expr.right, leftType);

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLessThanExpr.js

@@ -2,6 +2,7 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirLessThanExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileLessThanExpr(ctx, expr, typeHint) {
     const int_t = ctx.program.stdTypes.int;
@@ -12,7 +13,7 @@ export function _compileLessThanExpr(ctx, expr, typeHint) {
     if (!canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    let leftType = left.type;
+    let leftType = normalizeEnumToInt(left.type, int_t);
     while (leftType instanceof TirAliasType)
         leftType = leftType.aliased;
     const right = _compileExpr(ctx, expr.right, leftType);

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileMultExpr.js

@@ -1,20 +1,38 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirMultExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirValueT } from "../../../../tir/types/TirNativeType/native/value.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../../tir/types/utils/getUnaliased.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileMultExpr(ctx, expr, _typeHint) {
     const int_t = ctx.program.stdTypes.int;
-    const left = _compileExpr(ctx, expr.left, int_t);
-    if (!left)
+    // Probe both sides without hints so we can disambiguate
+    // (int * Value) / (Value * int) / (int * int).
+    const leftProbe = _compileExpr(ctx, expr.left, undefined);
+    if (!leftProbe)
         return undefined;
-    if (!canAssignTo(left.type, int_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    const right = _compileExpr(ctx, expr.right, int_t);
+    const leftTy = getUnaliased(leftProbe.type);
+    if (leftTy instanceof TirValueT) {
+        const right = _compileExpr(ctx, expr.right, int_t);
+        if (!right)
+            return undefined;
+        if (!canAssignTo(right.type, int_t))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
+        return new TirMultExpr(leftProbe, right, expr.range);
+    }
+    if (!canAssignTo(leftProbe.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, leftProbe.type.toString(), int_t.toString());
+    // left is int — right may be int (regular product) or Value (scaleValue).
+    const right = _compileExpr(ctx, expr.right, undefined);
     if (!right)
         return undefined;
+    const rightTy = getUnaliased(right.type);
+    if (rightTy instanceof TirValueT) {
+        return new TirMultExpr(leftProbe, right, expr.range);
+    }
     if (!canAssignTo(right.type, int_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
-    return new TirMultExpr(left, right, 
+    return new TirMultExpr(leftProbe, right, 
     // implicit int type,
     expr.range);
 }

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileNotEqualExpr.js

@@ -1,12 +1,13 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirNotEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileNotEqualExpr(ctx, expr, typeHint) {
     const left = _compileExpr(ctx, expr.left, typeHint);
     if (!left)
         return undefined;
-    const leftType = left.type;
+    const leftType = normalizeEnumToInt(left.type, ctx.program.stdTypes.int);
     const right = _compileExpr(ctx, expr.right, leftType);
     if (!right)
         return undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileSubExpr.js

@@ -1,20 +1,31 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirSubExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirValueT } from "../../../../tir/types/TirNativeType/native/value.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../../tir/types/utils/getUnaliased.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileSubExpr(ctx, expr, _typeHint) {
     const int_t = ctx.program.stdTypes.int;
-    const left = _compileExpr(ctx, expr.left, int_t);
-    if (!left)
+    const leftProbe = _compileExpr(ctx, expr.left, undefined);
+    if (!leftProbe)
         return undefined;
-    if (!canAssignTo(left.type, int_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
+    const leftTy = getUnaliased(leftProbe.type);
+    if (leftTy instanceof TirValueT) {
+        const right = _compileExpr(ctx, expr.right, leftProbe.type);
+        if (!right)
+            return undefined;
+        if (!(getUnaliased(right.type) instanceof TirValueT))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), "Value");
+        return new TirSubExpr(leftProbe, right, expr.range);
+    }
+    if (!canAssignTo(leftProbe.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, leftProbe.type.toString(), int_t.toString());
     const right = _compileExpr(ctx, expr.right, int_t);
     if (!right)
         return undefined;
     if (!canAssignTo(right.type, int_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
-    return new TirSubExpr(left, right, 
+    return new TirSubExpr(leftProbe, right, 
     // implicit int type,
     expr.range);
 }

package/dist/compiler/AstCompiler/internal/statements/_compileMatchStmt.js

@@ -11,6 +11,7 @@ import { TirDataT } from "../../../tir/types/TirNativeType/native/data.js";
 import { TirDataOptT } from "../../../tir/types/TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../../../tir/types/TirNativeType/native/Optional/sop.js";
 import { isTirStructType, TirDataStructType, TirSoPStructType } from "../../../tir/types/TirStructType.js";
+import { TirEnumType } from "../../../tir/types/TirEnumType.js";
 import { getDeconstructableType } from "../../../tir/types/utils/getDeconstructableType.js";
 import { wrapManyStatements } from "../../utils/wrapManyStatementsOrReturnSame.js";
 import { _compileExpr } from "../exprs/_compileExpr.js";
@@ -32,11 +33,13 @@ export function _compileMatchStmt(ctx, stmt) {
     if (!deconstructableType)
         return ctx.error(DiagnosticCode.A_value_of_type_0_cannot_be_deconstructed, stmt.matchExpr.range, matchExprType.toString());
     // TODO: add support for all deconstructable types
-    if (!isTirStructType(deconstructableType)) {
-        return ctx.error(DiagnosticCode.Not_implemented_0, stmt.matchExpr.range, "only structs supported for now, sorry!");
+    if (!isTirStructType(deconstructableType) && !(deconstructableType instanceof TirEnumType)) {
+        return ctx.error(DiagnosticCode.Not_implemented_0, stmt.matchExpr.range, "only structs and enums supported for now, sorry!");
     }
-    const ctors = deconstructableType.constructors;
-    const ctorNames = ctors.map(c => c.name);
+    const ctorNames = deconstructableType instanceof TirEnumType
+        ? deconstructableType.members.slice()
+        : deconstructableType.constructors.map(c => c.name);
+    const totalCtors = ctorNames.length;
     const missingCtors = ctorNames.slice();
     if (stmt.cases.length === 0)
         return ctx.error(DiagnosticCode.A_match_statement_must_have_at_least_one_case, stmt.range);
@@ -70,7 +73,7 @@ export function _compileMatchStmt(ctx, stmt) {
             return undefined;
         wildcardCase = new TirMatchStmtWildcardCase(branchBody, matchCase.range);
     }
-    if (!wildcardCase && cases.length < ctors.length) {
+    if (!wildcardCase && cases.length < totalCtors) {
         return ctx.error(DiagnosticCode.Match_cases_are_not_exhaustive, stmt.range);
     }
     return [new TirMatchStmt(matchExpr, cases, wildcardCase, stmt.range)];
@@ -82,23 +85,21 @@ export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, co
     //*/
     const pattern = matchCase.pattern;
     if (pattern instanceof SimpleVarDecl) {
-        /*
-        if( pattern.name.text === "_" ) {
+        // bare-name pattern: only valid for enum scrutinees (`when Apple: ...`)
+        if (deconstructableType instanceof TirEnumType) {
+            const memberName = pattern.name.text;
+            const memberIdx = deconstructableType.indexOf(memberName);
+            if (memberIdx < 0)
+                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, deconstructableType.toString(), memberName);
+            if (constrNamesAlreadySpecified.includes(memberName))
+                return ctx.error(DiagnosticCode.Constructor_0_was_already_specified, pattern.name.range, memberName);
+            constrNamesAlreadySpecified.push(memberName);
             const branchCtx = ctx.newBranchChildScope();
-            const branchBody = wrapManyStatements(
-                _compileStatement(
-                    branchCtx,
-                    matchCase.body
-                ),
-                matchCase.body.range
-            );
-            if( !branchBody ) return undefined;
-            return new TirMatchStmtWildcardCase(
-                branchBody,
-                matchCase.range
-            );
+            const branchBody = wrapManyStatements(_compileStatement(branchCtx, matchCase.body), matchCase.body.range);
+            if (!branchBody)
+                return undefined;
+            return new TirMatchStmtCase(new TirNamedDeconstructVarDecl(memberName, new Map(), undefined, deconstructableType, undefined, true, pattern.name.range, pattern.name.range), branchBody, matchCase.range);
         }
-        //*/
         return ctx.error(DiagnosticCode.The_argument_of_a_match_statement_branch_must_be_deconstructed, matchCase.pattern.range);
     }
     else if (pattern instanceof NamedDeconstructVarDecl) {
@@ -107,6 +108,18 @@ export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, co
         if (constrNamesAlreadySpecified.includes(deconstructedCtorName))
             return ctx.error(DiagnosticCode.Constructor_0_was_already_specified, deconstructedCtorIdentifier.range, deconstructedCtorName);
         constrNamesAlreadySpecified.push(deconstructedCtorName);
+        if (deconstructableType instanceof TirEnumType) {
+            const memberIdx = deconstructableType.indexOf(deconstructedCtorName);
+            if (memberIdx < 0)
+                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, deconstructableType.toString(), deconstructedCtorName);
+            if (pattern.fields.size > 0 || pattern.rest)
+                return ctx.error(DiagnosticCode.Enum_member_pattern_cannot_have_fields, pattern.range);
+            const branchCtx = ctx.newBranchChildScope();
+            const branchBody = wrapManyStatements(_compileStatement(branchCtx, matchCase.body), matchCase.body.range);
+            if (!branchBody)
+                return undefined;
+            return new TirMatchStmtCase(new TirNamedDeconstructVarDecl(deconstructedCtorName, new Map(), undefined, deconstructableType, undefined, true, pattern.range, pattern.name.range), branchBody, matchCase.range);
+        }
         if (deconstructableType instanceof TirSoPStructType
             || deconstructableType instanceof TirDataStructType) {
             const localIdx = deconstructableType.constructors.findIndex(c => c.name === deconstructedCtorName);

package/dist/compiler/AstCompiler/internal/statements/_compileStatement.js

@@ -12,7 +12,7 @@ import { ForStmt } from "../../../../ast/nodes/statements/ForStmt.js";
 import { IfStmt } from "../../../../ast/nodes/statements/IfStmt.js";
 import { MatchStmt } from "../../../../ast/nodes/statements/MatchStmt.js";
 import { ReturnStmt } from "../../../../ast/nodes/statements/ReturnStmt.js";
-import { UsingStmt } from "../../../../ast/nodes/statements/UsingStmt.js";
+import { UsingAliasStmt, UsingStmt } from "../../../../ast/nodes/statements/UsingStmt.js";
 import { VarStmt } from "../../../../ast/nodes/statements/VarStmt.js";
 import { WhileStmt } from "../../../../ast/nodes/statements/WhileStmt.js";
 import { _compileAssertStmt } from "./_compileAssertStmt.js";
@@ -28,6 +28,7 @@ import { _compileIfStmt } from "./_compileIfStmt.js";
 import { _compileMatchStmt } from "./_compileMatchStmt.js";
 import { _compileReturnStmt } from "./_compileReturnStmt.js";
 import { _compileUsingStmt } from "./_compileUsingStmt.js";
+import { _compileUsingAliasStmt } from "./_compileUsingAliasStmt.js";
 import { _compileVarStmt } from "./_compileVarStmt.js";
 import { _compileWhileStmt } from "./_compileWhileStmt.js";
 /**
@@ -74,6 +75,8 @@ export function _compileStatement(ctx, stmt) {
     // if( stmt instanceof ExprStmt ) return _compileExprStmt( ctx, stmt );
     if (stmt instanceof UsingStmt)
         return _compileUsingStmt(ctx, stmt);
+    if (stmt instanceof UsingAliasStmt)
+        return _compileUsingAliasStmt(ctx, stmt);
     const tsEnsureExhautstiveCheck = stmt;
     console.error(stmt);
     throw new Error("unreachable::AstCompiler::_compileStatement");

package/dist/compiler/AstCompiler/internal/statements/_compileTestStmt.d.ts

@@ -1 +1,15 @@
-export {};
+import { TestStmt } from "../../../../ast/nodes/statements/TestStmt.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+/**
+ * Compiles a `test name( params? ) { body }` declaration.
+ *
+ * Synthesises a `function <tirFuncName>( params ): void { body }` and
+ * runs it through `_compileFuncExpr` so type-checking, scoping and
+ * later TIR-to-UPLC compilation work exactly like a user-defined function.
+ *
+ * Registers the resulting `TirFuncExpr` in `program.functions` and pushes
+ * a `TirTestStmt` referencing it onto `program.tests`.
+ *
+ * @returns `true` on success (test registered), `false` on failure (diagnostic emitted).
+ */
+export declare function _compileTestStmt(ctx: AstCompilationCtx, stmt: TestStmt, srcUid: string, sourceFile: string): boolean;

package/dist/compiler/AstCompiler/internal/statements/_compileTestStmt.js

@@ -1,32 +1,72 @@
-export {};
-/*
-export function _compileTestStmt(
-    ctx: AstCompilationCtx,
-    stmt: TestStmt
-): [ TirTestStmt ] | undefined
-{
-    if( ctx.functionCtx ) return ctx.error(
-        DiagnosticCode.A_test_statement_can_only_be_used_outside_a_function,
-        stmt.range
+import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
+import { FuncExpr } from "../../../../ast/nodes/expr/functions/FuncExpr.js";
+import { ArrowKind } from "../../../../ast/nodes/expr/functions/ArrowKind.js";
+import { AstFuncType, AstVoidType } from "../../../../ast/nodes/types/AstNativeTypeExpr.js";
+import { CommonFlags } from "../../../../common.js";
+import { SimpleVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
+import { PEBBLE_INTERNAL_IDENTIFIER_PREFIX } from "../../../internalVar.js";
+import { TirTestStmt } from "../../../tir/statements/TirTestStmt.js";
+import { _compileFuncExpr } from "../exprs/_compileFuncExpr.js";
+import { TirIntT } from "../../../tir/types/TirNativeType/native/int.js";
+import { TirBoolT } from "../../../tir/types/TirNativeType/native/bool.js";
+import { getUnaliased } from "../../../tir/types/utils/getUnaliased.js";
+/**
+ * Compiles a `test name( params? ) { body }` declaration.
+ *
+ * Synthesises a `function <tirFuncName>( params ): void { body }` and
+ * runs it through `_compileFuncExpr` so type-checking, scoping and
+ * later TIR-to-UPLC compilation work exactly like a user-defined function.
+ *
+ * Registers the resulting `TirFuncExpr` in `program.functions` and pushes
+ * a `TirTestStmt` referencing it onto `program.tests`.
+ *
+ * @returns `true` on success (test registered), `false` on failure (diagnostic emitted).
+ */
+export function _compileTestStmt(ctx, stmt, srcUid, sourceFile) {
+    const program = ctx.program;
+    const astName = stmt.testName.text;
+    const tirFuncName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "test_" + astName + "_" + srcUid;
+    // Lower each TestParam to a SimpleVarDecl for the synthesized FuncExpr.
+    // `viaExpr` is consumed later (fuzzer resolution); the wrapper function
+    // itself takes the same params a regular `function name( ... )` would.
+    const lowerParams = stmt.params.map(p => new SimpleVarDecl(p.name, p.type, undefined, // initExpr
+    CommonFlags.Const, p.range));
+    const sig = new AstFuncType(lowerParams, new AstVoidType(stmt.testName.range), stmt.range);
+    const astFuncExpr = new FuncExpr(new Identifier(tirFuncName, stmt.testName.range), CommonFlags.None, [], // typeParams
+    sig, stmt.body, ArrowKind.None, stmt.range);
+    const tirFuncExpr = _compileFuncExpr(ctx, astFuncExpr, undefined, // expectedFuncType
+    false // isMethod
     );
-
-    let tirBody = wrapManyStatements(
-        _compileStatement(
-            ctx.newBranchChildScope(),
-            stmt.body
-        ),
-        stmt.body.range
-    );
-    if( !tirBody ) return undefined;
-    if(!( tirBody instanceof TirBlockStmt))
-    {
-        tirBody = new TirBlockStmt( [ tirBody ], stmt.body.range );
-    }
-
-    return [ new TirTestStmt(
-        stmt.testName?.string,
-        tirBody as TirBlockStmt,
-        stmt.range
-    ) ];
+    if (!tirFuncExpr)
+        return false;
+    program.functions.set(tirFuncName, tirFuncExpr);
+    // Resolve per-parameter fuzzer info. This walks both the source-level
+    // `TestParam` array (which carries any `via` expressions) and the
+    // resolved TIR param types (taken from the compiled function).
+    const fuzzerInfos = stmt.params.map((astParam, idx) => {
+        // Phase 1: `via` is parsed but execution of user-defined fuzzers
+        // is not wired up. Type-checking the expression is also deferred
+        // until the stdlib `std.test.fuzz` namespace ships.
+        if (astParam.viaExpr) {
+            return { kind: "via_not_implemented" };
+        }
+        const tirParamType = tirFuncExpr.params[idx]?.type;
+        if (!tirParamType) {
+            return {
+                kind: "unsupported",
+                reason: `parameter '${astParam.name.text}' has no resolved type`
+            };
+        }
+        const unaliased = getUnaliased(tirParamType);
+        if (unaliased instanceof TirIntT)
+            return { kind: "primitive", primitive: "int" };
+        if (unaliased instanceof TirBoolT)
+            return { kind: "primitive", primitive: "bool" };
+        return {
+            kind: "unsupported",
+            reason: `parameter '${astParam.name.text}' of type '${tirParamType.toString()}' has no default fuzzer; specify one with 'via <expr>' (note: user-defined fuzzers via 'via' are not yet executable)`
+        };
+    });
+    program.tests.push(new TirTestStmt(astName, tirFuncName, sourceFile, stmt.range, fuzzerInfos));
+    return true;
 }
-//*/ 

package/dist/compiler/AstCompiler/internal/statements/_compileUsingAliasStmt.d.ts

@@ -0,0 +1,11 @@
+import { UsingAliasStmt } from "../../../../ast/nodes/statements/UsingStmt.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+/**
+ * `using <alias> = <NamespacePath>;`
+ *
+ * binds `<alias>` in the current scope as a namespace alias for the
+ * namespace at `<NamespacePath>`.
+ *
+ * compile-time only — no IR is emitted.
+ */
+export declare function _compileUsingAliasStmt(ctx: AstCompilationCtx, stmt: UsingAliasStmt): [] | undefined;

package/dist/compiler/AstCompiler/internal/statements/_compileUsingAliasStmt.js

@@ -0,0 +1,26 @@
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { resolveNamespacePath } from "../../utils/resolveNamespacePath.js";
+/**
+ * `using <alias> = <NamespacePath>;`
+ *
+ * binds `<alias>` in the current scope as a namespace alias for the
+ * namespace at `<NamespacePath>`.
+ *
+ * compile-time only — no IR is emitted.
+ */
+export function _compileUsingAliasStmt(ctx, stmt) {
+    const resolved = resolveNamespacePath(ctx, stmt.rhs);
+    if (!resolved) {
+        ctx.error(DiagnosticCode._0_is_not_a_namespace, stmt.rhs.range, stmt.rhs.segments[0].text);
+        return undefined;
+    }
+    const ok = ctx.scope.defineNamespace({
+        name: stmt.aliasName.text,
+        publicScope: resolved.namespace.publicScope
+    });
+    if (!ok) {
+        ctx.error(DiagnosticCode.Constructor_name_0_is_already_declared_in_this_scope, stmt.aliasName.range, stmt.aliasName.text);
+        return undefined;
+    }
+    return [];
+}

package/dist/compiler/AstCompiler/internal/statements/_compileUsingStmt.d.ts

@@ -1,11 +1,16 @@
 import { UsingStmt } from "../../../../ast/nodes/statements/UsingStmt.js";
 import { AstCompilationCtx } from "../../AstCompilationCtx.js";
 /**
- * `using` only introduces symbols in scope
+ * `using` only introduces symbols in scope.
  *
- * we don't represent `using` statements in the TIR
+ * we don't represent `using` statements in the TIR.
  *
- * @returns {[]} an empty array if successful compilation
+ * the RHS can be either:
+ *  - a struct type expression (legacy behavior, brings constructors into scope)
+ *  - a namespace path (new behavior, destructures the namespace's exported
+ *    members into the current scope)
+ *
+ * @returns {[]} an empty array if compilation succeeded
  * @returns {undefined} `undefined` if compilation failed
-**/
+ */
 export declare function _compileUsingStmt(ctx: AstCompilationCtx, stmt: UsingStmt): [] | undefined;

package/dist/compiler/AstCompiler/internal/statements/_compileUsingStmt.js

@@ -1,27 +1,55 @@
+import { UsingPath } from "../../../../ast/nodes/statements/UsingStmt.js";
 import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
 import { getStructType } from "../../../tir/types/utils/canAssignTo.js";
+import { bindNamespaceMember, resolveNamespacePath } from "../../utils/resolveNamespacePath.js";
 import { _compileDataEncodedConcreteType } from "../types/_compileDataEncodedConcreteType.js";
 import { _compileSopEncodedConcreteType } from "../types/_compileSopEncodedConcreteType.js";
+import { AstNamedTypeExpr } from "../../../../ast/nodes/types/AstNamedTypeExpr.js";
 /**
- * `using` only introduces symbols in scope
+ * `using` only introduces symbols in scope.
  *
- * we don't represent `using` statements in the TIR
+ * we don't represent `using` statements in the TIR.
  *
- * @returns {[]} an empty array if successful compilation
+ * the RHS can be either:
+ *  - a struct type expression (legacy behavior, brings constructors into scope)
+ *  - a namespace path (new behavior, destructures the namespace's exported
+ *    members into the current scope)
+ *
+ * @returns {[]} an empty array if compilation succeeded
  * @returns {undefined} `undefined` if compilation failed
-**/
+ */
 export function _compileUsingStmt(ctx, stmt) {
-    stmt.constructorNames;
-    stmt.structTypeExpr;
-    stmt.range;
-    const structOrAliasType = (_compileSopEncodedConcreteType(ctx, stmt.structTypeExpr)
-        ?? _compileDataEncodedConcreteType(ctx, stmt.structTypeExpr));
+    const rhs = stmt.rhs;
+    if (rhs instanceof UsingPath) {
+        // namespace path. if the head is a namespace, destructure
+        // its public members; otherwise fall through to the struct path
+        // (this supports the single-identifier case where a name could
+        //  be either a struct or a namespace).
+        const ns = resolveNamespacePath(ctx, rhs);
+        if (ns) {
+            return _compileUsingNamespaceDestructure(ctx, stmt, ns.namespace);
+        }
+        // single-segment fallback: treat as a struct type ref
+        if (rhs.segments.length === 1) {
+            const ident = rhs.segments[0];
+            const fakeTypeExpr = new AstNamedTypeExpr(ident, [], ident.range);
+            return _compileUsingStructDestructure(ctx, stmt, fakeTypeExpr);
+        }
+        ctx.error(DiagnosticCode._0_is_not_a_namespace, rhs.range, rhs.segments[0].text);
+        return undefined;
+    }
+    // RHS is an AstTypeExpr (existing struct-destructure code path)
+    return _compileUsingStructDestructure(ctx, stmt, rhs);
+}
+function _compileUsingStructDestructure(ctx, stmt, rhs) {
+    const structOrAliasType = (_compileSopEncodedConcreteType(ctx, rhs)
+        ?? _compileDataEncodedConcreteType(ctx, rhs));
     if (!structOrAliasType)
         return undefined;
     // un-alias
     const structType = getStructType(structOrAliasType);
     if (!structType || !structType.isConcrete())
-        return ctx.error(DiagnosticCode.Type_0_does_not_have_constructors, stmt.structTypeExpr.range, structOrAliasType.toString());
+        return ctx.error(DiagnosticCode.Type_0_does_not_have_constructors, rhs.range, structOrAliasType.toString());
     const defCtorNames = structType.constructors.map(c => c.name);
     const sameStmtCtorNames = [];
     for (const stmtCtor of stmt.constructorNames) {
@@ -39,3 +67,16 @@ export function _compileUsingStmt(ctx, stmt) {
     }
     return [];
 }
+function _compileUsingNamespaceDestructure(ctx, stmt, ns) {
+    const seen = new Set();
+    for (const decl of stmt.constructorNames) {
+        const name = decl.constructorName;
+        if (seen.has(name.text))
+            return ctx.error(DiagnosticCode.Constructor_0_was_already_specified, name.range, name.text);
+        seen.add(name.text);
+        const ok = bindNamespaceMember(ctx, ns, name, decl.renamedConstructorName, ctx.scope);
+        if (!ok)
+            return undefined;
+    }
+    return [];
+}

package/dist/compiler/AstCompiler/internal/types/_compileDataEncodedConcreteType.js

@@ -46,11 +46,30 @@ export function _compileDataEncodedConcreteType(ctx, typeExpr, optionalsAsSop =
         return undefined; // no data encoding for function types
     if (typeExpr instanceof AstNamedTypeExpr) // struct, aliases and respective params
      {
+        // generic type parameters take precedence: `T` in a generic function
+        // body resolves directly to its TirTypeParam, leaving substitution
+        // to `monomorphizeGeneric` at call time.
+        const typeParam = ctx.scope.resolveTypeParam(typeExpr.name.text);
+        if (typeParam)
+            return typeParam;
         const possibleTirNames = ctx.scope.resolveType(typeExpr.name.text);
         if (!possibleTirNames)
             return ctx.error(DiagnosticCode._0_is_not_defined, typeExpr.name.range, typeExpr.name.text);
-        if (possibleTirNames.isGeneric)
-            throw new Error("not implemented: _compileDataEncodedConcreteType for generic types");
+        if (possibleTirNames.isGeneric) {
+            // Generic named type with explicit type-args, e.g. `List<int>` —
+            // compile each arg and apply the generic.
+            if (typeExpr.tyArgs.length === 0)
+                return ctx.error(DiagnosticCode._0_is_not_defined, typeExpr.name.range, typeExpr.name.text);
+            const compiledArgs = [];
+            for (const aExpr of typeExpr.tyArgs) {
+                const a = _compileDataEncodedConcreteType(ctx, aExpr, optionalsAsSop);
+                if (!a)
+                    return undefined;
+                compiledArgs.push(a);
+            }
+            const applied = ctx.program.getAppliedGeneric(possibleTirNames.dataTirName ?? possibleTirNames.sopTirName, compiledArgs);
+            return applied;
+        }
         if (typeof possibleTirNames.dataTirName !== "string")
             return undefined;
         return ctx.program.types.get(possibleTirNames.dataTirName);

package/dist/compiler/AstCompiler/internal/types/_compileSopEncodedConcreteType.js

@@ -44,11 +44,26 @@ export function _compileSopEncodedConcreteType(ctx, typeExpr) {
         return undefined; // no data encoding for function types
     if (typeExpr instanceof AstNamedTypeExpr) // struct, aliases and respective params
      {
+        // generic type parameters take precedence over named-type lookup
+        const typeParam = ctx.scope.resolveTypeParam(typeExpr.name.text);
+        if (typeParam)
+            return typeParam;
         const possibleTirNames = ctx.scope.resolveType(typeExpr.name.text);
         if (!possibleTirNames)
             return ctx.error(DiagnosticCode._0_is_not_defined, typeExpr.name.range, typeExpr.name.text);
-        if (possibleTirNames.isGeneric)
-            throw new Error("not implemented: _compileSopEncodedConcreteType for generic types");
+        if (possibleTirNames.isGeneric) {
+            if (typeExpr.tyArgs.length === 0)
+                return ctx.error(DiagnosticCode._0_is_not_defined, typeExpr.name.range, typeExpr.name.text);
+            const compiledArgs = [];
+            for (const aExpr of typeExpr.tyArgs) {
+                const a = _compileSopEncodedConcreteType(ctx, aExpr);
+                if (!a)
+                    return undefined;
+                compiledArgs.push(a);
+            }
+            const applied = ctx.program.getAppliedGeneric(possibleTirNames.sopTirName, compiledArgs);
+            return applied;
+        }
         if (typeof possibleTirNames.dataTirName !== "string")
             return undefined;
         return ctx.program.types.get(possibleTirNames.dataTirName);