@harmoniclabs/pebble 0.2.0 → 0.3.0

package/dist/compiler/tir/types/utils/normalizeEnumToInt.js

@@ -0,0 +1,17 @@
+import { TirAliasType } from "../TirAliasType.js";
+import { TirEnumType } from "../TirEnumType.js";
+/**
+ * If `t` is an enum type (or alias of one), returns the shared `int` type
+ * (since enums lower to plain ints at runtime). Otherwise returns `t`.
+ *
+ * Use this to relax type checks for binary operators that treat enums as
+ * integers (arithmetic, comparison, equality).
+ */
+export function normalizeEnumToInt(t, int_t) {
+    let probe = t;
+    while (probe instanceof TirAliasType)
+        probe = probe.aliased;
+    if (probe instanceof TirEnumType)
+        return int_t;
+    return t;
+}

package/dist/compiler/tir/types/utils/substituteTypeParams.js

@@ -1,4 +1,5 @@
 import { TirAliasType } from "../TirAliasType.js";
+import { TirArrayT } from "../TirNativeType/native/array.js";
 import { TirFuncT } from "../TirNativeType/native/function.js";
 import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../TirNativeType/native/linearMapEntry.js";
@@ -23,6 +24,10 @@ export function substituteTypeParams(t, subst) {
         const sub = substituteTypeParams(t.typeArg, subst);
         return sub === t.typeArg ? t : new TirListT(sub);
     }
+    if (t instanceof TirArrayT) {
+        const sub = substituteTypeParams(t.typeArg, subst);
+        return sub === t.typeArg ? t : new TirArrayT(sub);
+    }
     if (t instanceof TirFuncT) {
         let changed = false;
         const newArgs = t.argTypes.map(a => {

package/dist/diagnostics/diagnosticMessages.generated.d.ts

@@ -283,6 +283,11 @@ export declare enum DiagnosticCode {
     _private_modifier_is_only_allowed_on_declarations_inside_a_namespace = 30003,
     Namespaces_cannot_be_declared_here = 30004,
     _0_is_not_a_namespace = 30005,
+    Enum_members_cannot_have_explicit_values = 30100,
+    Duplicate_enum_member_0 = 30101,
+    Enum_must_have_at_least_one_member = 30102,
+    Property_0_is_not_a_member_of_enum_1 = 30103,
+    Enum_member_pattern_cannot_have_fields = 30104,
     Dev_was_too_lazy_to_add_a_prooper_error_message_Something_went_wrong = 42069
 }
 /** Translates a diagnostic code to its respective string. */

package/dist/diagnostics/diagnosticMessages.generated.js

@@ -285,6 +285,11 @@ export var DiagnosticCode;
     DiagnosticCode[DiagnosticCode["_private_modifier_is_only_allowed_on_declarations_inside_a_namespace"] = 30003] = "_private_modifier_is_only_allowed_on_declarations_inside_a_namespace";
     DiagnosticCode[DiagnosticCode["Namespaces_cannot_be_declared_here"] = 30004] = "Namespaces_cannot_be_declared_here";
     DiagnosticCode[DiagnosticCode["_0_is_not_a_namespace"] = 30005] = "_0_is_not_a_namespace";
+    DiagnosticCode[DiagnosticCode["Enum_members_cannot_have_explicit_values"] = 30100] = "Enum_members_cannot_have_explicit_values";
+    DiagnosticCode[DiagnosticCode["Duplicate_enum_member_0"] = 30101] = "Duplicate_enum_member_0";
+    DiagnosticCode[DiagnosticCode["Enum_must_have_at_least_one_member"] = 30102] = "Enum_must_have_at_least_one_member";
+    DiagnosticCode[DiagnosticCode["Property_0_is_not_a_member_of_enum_1"] = 30103] = "Property_0_is_not_a_member_of_enum_1";
+    DiagnosticCode[DiagnosticCode["Enum_member_pattern_cannot_have_fields"] = 30104] = "Enum_member_pattern_cannot_have_fields";
     DiagnosticCode[DiagnosticCode["Dev_was_too_lazy_to_add_a_prooper_error_message_Something_went_wrong"] = 42069] = "Dev_was_too_lazy_to_add_a_prooper_error_message_Something_went_wrong";
 })(DiagnosticCode || (DiagnosticCode = {}));
 /** Translates a diagnostic code to its respective string. */
@@ -573,6 +578,11 @@ export function diagnosticCodeToString(code) {
         case 30003: return "'private' modifier is only allowed on declarations inside a namespace.";
         case 30004: return "Namespaces cannot be declared here.";
         case 30005: return "'{0}' is not a namespace.";
+        case 30100: return "Enum members cannot have explicit values.";
+        case 30101: return "Duplicate enum member '{0}'.";
+        case 30102: return "Enum must have at least one member.";
+        case 30103: return "Property '{0}' is not a member of enum '{1}'.";
+        case 30104: return "Enum member pattern cannot have fields.";
         case 42069: return "Dev was too lazy to add a prooper error message. Something went wrong";
         default: return "";
     }

package/dist/parser/Parser.js

@@ -178,13 +178,19 @@ export class Parser extends DiagnosticEmitter {
             case Token.Data: {
                 // `next()` skips `data` keyword
                 tn.next();
+                let extraFlags = StructDeclAstFlags.onlyDataEncoding;
+                // accept `data untagged struct ...`
+                if (tn.peek() === Token.Untagged) {
+                    tn.next();
+                    extraFlags |= StructDeclAstFlags.untagged;
+                }
                 // positions on (expected) `struct` keyword
                 if (tn.peek() !== Token.Struct) {
                     console.error(Token[tn.peek()]);
                     return this.error(DiagnosticCode._0_expected, tn.range(), "struct");
                 }
                 tn.next(); // skip `struct`
-                statement = this.parseStruct(StructDeclAstFlags.onlyDataEncoding, flags, startPos);
+                statement = this.parseStruct(extraFlags, flags, startPos);
                 break;
             }
             case Token.Runtime: {
@@ -203,6 +209,22 @@ export class Parser extends DiagnosticEmitter {
                 statement = this.parseStruct(StructDeclAstFlags.none, flags, startPos);
                 break;
             }
+            case Token.Untagged: {
+                // `untagged` keyword forces listData encoding (single ctor).
+                // Accept: `untagged struct ...` or `untagged data struct ...`.
+                tn.next(); // skip `untagged`
+                let extraFlags = StructDeclAstFlags.untagged;
+                if (tn.peek() === Token.Data) {
+                    tn.next(); // skip `data`
+                    extraFlags |= StructDeclAstFlags.onlyDataEncoding;
+                }
+                if (tn.peek() !== Token.Struct) {
+                    return this.error(DiagnosticCode._0_expected, tn.range(), "struct");
+                }
+                tn.next(); // skip `struct`
+                statement = this.parseStruct(extraFlags, flags, startPos);
+                break;
+            }
             case Token.Interface: {
                 tn.next();
                 statement = this.parseInterface(flags, startPos);
@@ -884,7 +906,7 @@ export class Parser extends DiagnosticEmitter {
             [
                 new StructConstrDecl(new Identifier(name.text, name.range), [], // fields
                 range)
-            ], structDeclFlags | StructDeclAstFlags.untaggedSingleConstructor, range.clone());
+            ], structDeclFlags | StructDeclAstFlags.shortcutSingleConstructor, range.clone());
         }
         let constrIdentifier = undefined;
         // in case of single constr shortcut
@@ -905,7 +927,7 @@ export class Parser extends DiagnosticEmitter {
             tn.skip(Token.Semicolon); // if any
             return new StructDecl(name, typeParams, [
                 new StructConstrDecl(new Identifier(name.text, name.range), fields, tn.range(startPos, tn.pos))
-            ], structDeclFlags | StructDeclAstFlags.untaggedSingleConstructor, tn.range(startPos, tn.pos));
+            ], structDeclFlags | StructDeclAstFlags.shortcutSingleConstructor, tn.range(startPos, tn.pos));
         }
         const constrFields = this.parseStructConstrFields(flags);
         if (!Array.isArray(constrFields))
@@ -1885,17 +1907,14 @@ export class Parser extends DiagnosticEmitter {
         const expr = this.parseExpr(Precedence.Relational + 1);
         if (!expr)
             return undefined;
-        let noPatternCaseSeen = false;
         const cases = new Array();
         while (tn.skip(Token.Is)) {
-            if (noPatternCaseSeen)
-                return this.error(DiagnosticCode.This_case_will_never_be_evaluated_because_all_patterns_will_be_catched_before, tn.range());
             const startPos = tn.tokenPos;
             const matcher = this._parseVarDecl(CommonFlags.Const);
             if (!matcher)
                 return undefined;
-            if (matcher instanceof SimpleVarDecl)
-                noPatternCaseSeen = true;
+            // SimpleVarDecl patterns are validated by the AstCompiler, which
+            // has type info (enum-member promotion vs invalid catch-all).
             if (matcher.initExpr || matcher.type)
                 return this.error(DiagnosticCode.Patterns_may_not_have_initializers_or_explicit_types, matcher.initExpr ? matcher.initExpr.range : matcher.type.range);
             if (!tn.skip(Token.FatArrow))
@@ -2626,7 +2645,6 @@ export class Parser extends DiagnosticEmitter {
             return this.error(DiagnosticCode.Expression_expected, tn.range(startPos - 5, startPos));
         if (!tn.skip(Token.OpenBrace))
             return this.error(DiagnosticCode._0_expected, tn.range(), "{");
-        let noPatternCaseSeen = false;
         const cases = new Array();
         while (!tn.skip(Token.CloseBrace)
             && tn.peek() !== Token.Else) {
@@ -2637,10 +2655,8 @@ export class Parser extends DiagnosticEmitter {
             const pattern = this._parseVarDecl(CommonFlags.Const, true);
             if (!pattern)
                 return this.error(DiagnosticCode.Pattern_expected, tn.range());
-            if (noPatternCaseSeen)
-                return this.error(DiagnosticCode.This_case_will_never_be_evaluated_because_all_patterns_will_be_catched_before, pattern.range);
-            if (pattern instanceof SimpleVarDecl)
-                noPatternCaseSeen = true;
+            // SimpleVarDecl patterns are validated by the AstCompiler, which
+            // has type info (enum-member promotion vs invalid catch-all).
             if (!tn.skip(Token.Colon))
                 return this.error(DiagnosticCode._0_expected, tn.range(), ":");
             const statePreBody = tn.mark();

package/dist/tokenizer/Token.d.ts

@@ -164,11 +164,12 @@ export declare enum Token {
     List = 117,
     LinearMap = 118,
     Runtime = 119,
-    Identifier = 120,
-    StringLiteral = 121,
-    HexBytesLiteral = 122,
-    IntegerLiteral = 123,
-    StringTemplateLiteralQuote = 124,
-    Invalid = 125,
-    EndOfFile = 126
+    Untagged = 120,
+    Identifier = 121,
+    StringLiteral = 122,
+    HexBytesLiteral = 123,
+    IntegerLiteral = 124,
+    StringTemplateLiteralQuote = 125,
+    Invalid = 126,
+    EndOfFile = 127
 }

package/dist/tokenizer/Token.js

@@ -204,16 +204,17 @@ export var Token;
     // struct decl modifiers
     // taggedModifier,     // `tagged` data struct
     Token[Token["Runtime"] = 119] = "Runtime";
+    Token[Token["Untagged"] = 120] = "Untagged";
     // literals
-    Token[Token["Identifier"] = 120] = "Identifier";
-    Token[Token["StringLiteral"] = 121] = "StringLiteral";
-    Token[Token["HexBytesLiteral"] = 122] = "HexBytesLiteral";
-    Token[Token["IntegerLiteral"] = 123] = "IntegerLiteral";
+    Token[Token["Identifier"] = 121] = "Identifier";
+    Token[Token["StringLiteral"] = 122] = "StringLiteral";
+    Token[Token["HexBytesLiteral"] = 123] = "HexBytesLiteral";
+    Token[Token["IntegerLiteral"] = 124] = "IntegerLiteral";
     // FloatLiteral,
-    Token[Token["StringTemplateLiteralQuote"] = 124] = "StringTemplateLiteralQuote";
+    Token[Token["StringTemplateLiteralQuote"] = 125] = "StringTemplateLiteralQuote";
     // meta
-    Token[Token["Invalid"] = 125] = "Invalid";
-    Token[Token["EndOfFile"] = 126] = "EndOfFile";
+    Token[Token["Invalid"] = 126] = "Invalid";
+    Token[Token["EndOfFile"] = 127] = "EndOfFile";
 })(Token || (Token = {}));
 Object.freeze(Token);
 /*

package/dist/tokenizer/utils/tokenFromKeyword.js

@@ -221,6 +221,8 @@ export function tokenFromKeyword(text) {
                 return Token.Undefined;
             if (text === "using")
                 return Token.Using;
+            if (text === "untagged")
+                return Token.Untagged;
             break;
         }
         case 118 /* CharCode.v */: {

package/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const COMPILER_VERSION = "0.2.0";
+export declare const COMPILER_VERSION = "0.3.0";

package/dist/version.generated.js

@@ -1,2 +1,2 @@
 // This file is auto-generated by scripts/genVersion.js. Do not edit.
-export const COMPILER_VERSION = "0.2.0";
+export const COMPILER_VERSION = "0.3.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -53,12 +53,12 @@
   "homepage": "https://github.com/HarmonicLabs/pebble#readme",
   "dependencies": {
     "@harmoniclabs/bigint-utils": "^1.0.0",
-    "@harmoniclabs/cardano-costmodels-ts": "^1.4.0",
+    "@harmoniclabs/cardano-costmodels-ts": "^1.6.1",
     "@harmoniclabs/cbor": "^2.0.1",
     "@harmoniclabs/crypto": "^0.3.0",
     "@harmoniclabs/obj-utils": "^1.0.0",
     "@harmoniclabs/plutus-data": "^2.0.1",
-    "@harmoniclabs/plutus-machine": "^3.0.0",
+    "@harmoniclabs/plutus-machine": "^3.0.3",
     "@harmoniclabs/uint8array-utils": "^1.0.4",
     "@harmoniclabs/uplc": "^2.0.5"
   },

package/dist/IR/tree_utils/_ir_lazyChooseList.d.ts

@@ -1,3 +0,0 @@
-import { IRForced } from "../IRNodes/IRForced.js";
-import type { IRTerm } from "../IRTerm.js";
-export declare function _ir_lazyChooseList(listTerm: IRTerm, caseNil: IRTerm, caseCons: IRTerm): IRForced;

package/dist/IR/tree_utils/_ir_lazyChooseList.js

@@ -1,7 +0,0 @@
-import { _ir_apps } from "../IRNodes/IRApp.js";
-import { IRDelayed } from "../IRNodes/IRDelayed.js";
-import { IRForced } from "../IRNodes/IRForced.js";
-import { IRNative } from "../IRNodes/IRNative/index.js";
-export function _ir_lazyChooseList(listTerm, caseNil, caseCons) {
-    return new IRForced(_ir_apps(IRNative.strictChooseList, listTerm, new IRDelayed(caseNil), new IRDelayed(caseCons)));
-}