- upgraded compiler-utils lib

- added TypeCheckContext as arg to all type check functions

Author: christianschmitz

package.json

@@ -66,7 +66,7 @@
     },
     "dependencies": {
         "@helios-lang/codec-utils": "^0.3.4",
-        "@helios-lang/compiler-utils": "^0.5.15",
+        "@helios-lang/compiler-utils": "^0.5.17",
         "@helios-lang/ir": "0.3.9",
         "@helios-lang/type-utils": "^0.3.0",
         "@helios-lang/uplc": "^0.7.17"

pnpm-lock.yaml

@@ -3,7 +3,8 @@ import { AnyType } from "../typecheck/index.js"
 import { Expr } from "./Expr.js"
 
 /**
- * @typedef {import("@helios-lang/compiler-utils").Site} Site
+ * @import { Site } from "@helios-lang/compiler-utils"
+ * @import { TypeCheckContext } from "../index.js"
  * @typedef {import("../typecheck/index.js").EvalEntity} EvalEntity
  */
 
@@ -19,10 +20,11 @@ export class AnyTypeExpr extends Expr {
     }
 
     /**
-     * @param {Scope} scope
+     * @param {TypeCheckContext} _ctx
+     * @param {Scope} _scope
      * @returns {EvalEntity}
      */
-    evalInternal(scope) {
+    evalInternal(_ctx, _scope) {
         return new AnyType()
     }
 

src/expressions/AnyTypeExpr.js

@@ -5,8 +5,9 @@ import { AnyEntity } from "../typecheck/index.js"
 import { Expr } from "./Expr.js"
 
 /**
- * @typedef {import("@helios-lang/compiler-utils").Site} Site
- * @typedef {import("@helios-lang/ir").SourceMappedStringI} SourceMappedStringI
+ * @import { Site } from "@helios-lang/compiler-utils"
+ * @import { SourceMappedStringI } from "@helios-lang/ir"
+ * @import { TypeCheckContext } from "../index.js"
  * @typedef {import("../typecheck/index.js").Instance} Instance
  */
 
@@ -22,10 +23,11 @@ export class AnyValueExpr extends Expr {
     }
 
     /**
+     * @param {TypeCheckContext} ctx
      * @param {Scope} _scope
      * @returns {Instance}
      */
-    evalInternal(_scope) {
+    evalInternal(ctx, _scope) {
         return new AnyEntity()
     }
 

src/expressions/AnyValueExpr.js

@@ -11,8 +11,9 @@ import { Expr } from "./Expr.js"
 import { PathExpr } from "./PathExpr.js"
 
 /**
- * @typedef {import("@helios-lang/compiler-utils").Site} Site
- * @typedef {import("@helios-lang/ir").SourceMappedStringI} SourceMappedStringI
+ * @import { Site } from "@helios-lang/compiler-utils"
+ * @import { SourceMappedStringI } from "@helios-lang/ir"
+ * @import { TypeCheckContext } from "../index.js"
  * @typedef {import("../typecheck/index.js").EvalEntity} EvalEntity
  */
 
@@ -47,24 +48,26 @@ export class AssignExpr extends ChainExpr {
     }
 
     /**
+     * @param {TypeCheckContext} ctx
      * @param {Scope} scope
      * @returns {EvalEntity}
      */
-    evalInternal(scope) {
+    evalInternal(ctx, scope) {
         const subScope = new Scope(scope, scope.allowShadowing)
 
-        let upstreamVal = this.upstreamExpr.eval(scope)
+        let upstreamVal = this.upstreamExpr.eval(ctx, scope)
 
         if (upstreamVal && upstreamVal.asTyped) {
             if (new VoidType().isBaseOf(upstreamVal.asTyped.type)) {
-                throw makeTypeError(
+                ctx.errors.type(
                     this.upstreamExpr.site,
                     "can't assign to unit type"
                 )
             }
 
             if (this._nameType.hasType() || this._nameType.isTuple()) {
                 this._nameType.evalInAssignExpr(
+                    ctx,
                     subScope,
                     expectDefined(upstreamVal.asTyped.type.asType),
                     0
@@ -90,13 +93,14 @@ export class AssignExpr extends ChainExpr {
             }
         } else if (this._nameType.hasType()) {
             // this is the fallback case if the upstream has itself a typeerror
-            this._nameType.evalInAssignExpr(subScope, undefined, 0)
+            this._nameType.evalInAssignExpr(ctx, subScope, undefined, 0)
         } else {
-            throw makeTypeError(this.upstreamExpr.site, "rhs isn't an instance")
+            ctx.errors.type(this.upstreamExpr.site, "rhs isn't an instance")
+
             subScope.set(this._nameType.name, new DataEntity(new AnyType()))
         }
 
-        const downstreamVal = this.downstreamExpr.eval(subScope)
+        const downstreamVal = this.downstreamExpr.eval(ctx, subScope)
 
         subScope.assertAllUsed()
 

src/expressions/AssignExpr.js

@@ -4,10 +4,12 @@ import { expectDefined } from "@helios-lang/type-utils"
 import { TAB, ToIRContext } from "../codegen/index.js"
 import { Scope } from "../scopes/index.js"
 import { Expr } from "./Expr.js"
+import { AnyType, DataEntity } from "../typecheck/common.js"
 
 /**
  * @import { SymbolToken, Word } from "@helios-lang/compiler-utils"
- * @typedef {import("@helios-lang/ir").SourceMappedStringI} SourceMappedStringI
+ * @import { SourceMappedStringI } from "@helios-lang/ir"
+ * @import { TypeCheckContext } from "../index.js"
  * @typedef {import("../typecheck/index.js").EvalEntity} EvalEntity
  */
 
@@ -140,27 +142,32 @@ export class BinaryExpr extends Expr {
     }
 
     /**
+     * @param {TypeCheckContext} ctx
      * @param {Scope} scope
      * @returns {EvalEntity}
      */
-    evalInternal(scope) {
-        const a_ = this._a.eval(scope)
-        const b_ = this._b.eval(scope)
+    evalInternal(ctx, scope) {
+        const a_ = this._a.eval(ctx, scope)
+        const b_ = this._b.eval(ctx, scope)
 
         const a = a_.asInstance
         if (!a) {
-            throw makeTypeError(
+            ctx.errors.type(
                 this._a.site,
                 `lhs of ${this._op.toString()} not an instance`
             )
+
+            return new DataEntity(new AnyType())
         }
 
         const b = b_.asInstance
         if (!b) {
-            throw makeTypeError(
+            ctx.errors.type(
                 this._b.site,
                 `rhs of ${this._op.toString()} not an instance`
             )
+
+            return new DataEntity(new AnyType())
         }
 
         for (let swap of this.isCommutative() ? [false, true] : [false]) {
@@ -190,10 +197,12 @@ export class BinaryExpr extends Expr {
             }
         }
 
-        throw makeTypeError(
+        ctx.errors.type(
             this.site,
             `'${a.type.toString()} ${this._op.toString()} ${b.type.toString()}' undefined`
         )
+
+        return new DataEntity(new AnyType())
     }
 
     /**

src/expressions/BinaryExpr.js

@@ -4,6 +4,7 @@ import { Expr } from "./Expr.js"
 
 /**
  * @import { Site, Token, Word } from "@helios-lang/compiler-utils"
+ * @import { TypeCheckContext } from "../index.js"
  * @typedef {import("../typecheck/index.js").EvalEntity} EvalEntity
  */
 
@@ -16,7 +17,7 @@ import { Expr } from "./Expr.js"
  *   isNamed(): boolean
  *   isLiteral(): boolean
  *   toString(): string
- *   eval(scope: Scope): EvalEntity
+ *   eval(ctx: TypeCheckContext, scope: Scope): EvalEntity
  * }} CallArgExprI
  */
 
@@ -102,10 +103,11 @@ export class CallArgExpr {
     }
 
     /**
+     * @param {TypeCheckContext} ctx
      * @param {Scope} scope
      * @returns {EvalEntity}
      */
-    eval(scope) {
-        return this._valueExpr.eval(scope)
+    eval(ctx, scope) {
+        return this._valueExpr.eval(ctx, scope)
     }
 }

src/expressions/CallArgExpr.js

@@ -4,6 +4,8 @@ import { expectDefined } from "@helios-lang/type-utils"
 import { ToIRContext } from "../codegen/index.js"
 import { Scope } from "../scopes/index.js"
 import {
+    AnyType,
+    DataEntity,
     FuncType,
     IntType,
     ParametricFunc,
@@ -18,7 +20,8 @@ import { PathExpr } from "./PathExpr.js"
 
 /**
  * @import { Site } from "@helios-lang/compiler-utils"
- * @typedef {import("@helios-lang/ir").SourceMappedStringI} SourceMappedStringI
+ * @import { SourceMappedStringI } from "@helios-lang/ir"
+ * @import { TypeCheckContext } from "../index.js"
  * @typedef {import("../typecheck/index.js").EvalEntity} EvalEntity
  * @typedef {import("../typecheck/index.js").Func} Func
  * @typedef {import("../typecheck/index.js").Type} Type
@@ -120,19 +123,21 @@ export class CallExpr extends Expr {
     }
 
     /**
+     * @param {TypeCheckContext} ctx
      * @param {Scope} scope
      * @returns {EvalEntity}
      */
-    evalInternal(scope) {
-        const fnVal = this._fnExpr.eval(scope)
+    evalInternal(ctx, scope) {
+        const fnVal = this._fnExpr.eval(ctx, scope)
 
         const argVals = this._argExprs.map((ae, i) => {
-            const av_ = ae.eval(scope)
+            const av_ = ae.eval(ctx, scope)
 
             const av = av_.asTyped
 
             if (!av) {
-                throw makeTypeError(ae.site, `arg ${i + 1} not an instance`)
+                ctx.errors.type(ae.site, `arg ${i + 1} not an instance`)
+                return new DataEntity(new AnyType())
             }
 
             return av
@@ -192,11 +197,12 @@ export class CallExpr extends Expr {
                 viableCasts
             )
         } else {
-            throw makeTypeError(
+            ctx.errors.type(
                 this._fnExpr.site,
-
                 `unable to call ${fnVal.toString()} (returned by ${this._fnExpr.toString()})`
             )
+
+            return new DataEntity(new AnyType())
         }
     }
 

src/expressions/CallExpr.js

@@ -6,8 +6,9 @@ import { ErrorType, VoidType } from "../typecheck/index.js"
 import { Expr } from "./Expr.js"
 
 /**
- * @typedef {import("@helios-lang/compiler-utils").Site} Site
- * @typedef {import("@helios-lang/ir").SourceMappedStringI} SourceMappedStringI
+ * @import { Site } from "@helios-lang/compiler-utils"
+ * @import { SourceMappedStringI } from "@helios-lang/ir"
+ * @import { TypeCheckContext } from "../index.js"
  * @typedef {import("../typecheck/index.js").EvalEntity} EvalEntity
  */
 
@@ -43,36 +44,34 @@ export class ChainExpr extends Expr {
     }
 
     /**
+     * @param {TypeCheckContext} ctx
      * @param {Scope} scope
      * @returns {EvalEntity}
      */
-    evalInternal(scope) {
-        const upstreamVal_ = this.upstreamExpr.eval(scope)
+    evalInternal(ctx, scope) {
+        const upstreamVal_ = this.upstreamExpr.eval(ctx, scope)
 
         if (upstreamVal_) {
             const upstreamVal = upstreamVal_.asTyped
 
             if (!upstreamVal) {
-                throw makeTypeError(
-                    this.upstreamExpr.site,
-                    "upstream isn't typed"
-                )
+                ctx.errors.type(this.upstreamExpr.site, "upstream isn't typed")
             } else {
                 if (new ErrorType().isBaseOf(upstreamVal.type)) {
-                    throw makeTypeError(
+                    ctx.errors.type(
                         this.downstreamExpr.site,
                         "unreachable code (upstream always throws error)"
                     )
                 } else if (!new VoidType().isBaseOf(upstreamVal.type)) {
-                    throw makeTypeError(
+                    ctx.errors.type(
                         this.upstreamExpr.site,
                         "unexpected return value (hint: use '='"
                     )
                 }
             }
         }
 
-        return this.downstreamExpr.eval(scope)
+        return this.downstreamExpr.eval(ctx, scope)
     }
 
     /**