@jalvin/compiler 2.0.12 → 2.0.14

package/dist/typechecker.js

@@ -73,12 +73,14 @@ const JS_GLOBALS = new Set([
     "fetch", "URL", "URLSearchParams", "FormData", "Blob", "File",
     "localStorage", "sessionStorage", "performance", "navigator", "location",
     "HTMLElement", "Element", "Event", "CustomEvent",
+    "confirm", "alert", "prompt",
 ]);
 function nullable(t) {
     if (t.tag === "nullable")
         return t;
-    if (t.tag === "nothing")
-        return exports.T_UNIT; // Nothing? ≈ Unit?
+    // Note: Nothing? is kept as nullable(nothing), not collapsed to Unit.
+    // In Kotlin semantics Nothing? is the type of `null` and is assignable
+    // to every nullable type, which isAssignable() handles correctly.
     return { tag: "nullable", inner: t };
 }
 function unwrapNullable(t) {
@@ -548,6 +550,7 @@ class TypeChecker {
         }
         if (!decl.body)
             return;
+        const body = decl.body;
         const seen = new Set();
         // Collect all member names from parent class (for override/abstract checks)
         const parentMemberNames = new Set();
@@ -568,26 +571,75 @@ class TypeChecker {
             }
         }
         const concreteMembers = new Set();
-        for (const member of decl.body.members) {
-            const mName = this.memberName(member);
-            if (mName) {
-                if (seen.has(mName)) {
-                    this.diag.error(member.span, diagnostics_js_1.E_DUPLICATE_CLASS_MEMBER, `Duplicate member '${mName}'`);
+        // Build a class-level scope so that methods can call sibling members and
+        // reference `this` by bare name — mirroring Kotlin's behaviour.
+        const classScope = new Scope(this.scope);
+        classScope.define({
+            name: "this",
+            type: classType(decl.name, [], decl),
+            mutable: false,
+            span: decl.span,
+        });
+        // Hoist primary-constructor val/var params as class properties
+        const ctor = decl.primaryConstructor
+            ?? decl.primaryConstructor
+            ?? null;
+        if (ctor) {
+            for (const p of ctor.params) {
+                if (p.propertyKind) {
+                    classScope.define({
+                        name: p.name,
+                        type: this.resolveTypeRef(p.type),
+                        mutable: p.propertyKind === "var",
+                        span: p.span,
+                    });
                 }
-                seen.add(mName);
-                // Check `override` is actually overriding something
-                if ((member.kind === "FunDecl" || member.kind === "PropertyDecl") &&
-                    member.modifiers.modifiers.includes("override")) {
-                    if (!parentMemberNames.has(mName)) {
-                        this.diag.error(member.span, diagnostics_js_1.E_OVERRIDE_NOTHING, `'${mName}' overrides nothing`);
+            }
+        }
+        // Hoist all class body members so they're visible to each other
+        for (const member of body.members) {
+            if (member.kind === "FunDecl") {
+                classScope.define({ name: member.name, type: this.funDeclType(member), mutable: false, span: member.span });
+            }
+            else if (member.kind === "PropertyDecl") {
+                classScope.define({
+                    name: member.name,
+                    type: member.type ? this.resolveTypeRef(member.type) : exports.T_UNKNOWN,
+                    mutable: member.mutable,
+                    span: member.span,
+                });
+            }
+            else if (member.kind === "ComponentDecl") {
+                classScope.define({
+                    name: member.name,
+                    type: { tag: "func", params: this.componentParamTypes(member), ret: exports.T_UNIT, suspend: false },
+                    mutable: false,
+                    span: member.span,
+                });
+            }
+        }
+        this.withScope(classScope, () => {
+            for (const member of body.members) {
+                const mName = this.memberName(member);
+                if (mName) {
+                    if (seen.has(mName)) {
+                        this.diag.error(member.span, diagnostics_js_1.E_DUPLICATE_CLASS_MEMBER, `Duplicate member '${mName}'`);
+                    }
+                    seen.add(mName);
+                    // Check `override` is actually overriding something
+                    if ((member.kind === "FunDecl" || member.kind === "PropertyDecl") &&
+                        member.modifiers.modifiers.includes("override")) {
+                        if (!parentMemberNames.has(mName)) {
+                            this.diag.error(member.span, diagnostics_js_1.E_OVERRIDE_NOTHING, `'${mName}' overrides nothing`);
+                        }
+                    }
+                    if (!(member.kind === "FunDecl" && member.modifiers.modifiers.includes("abstract"))) {
+                        concreteMembers.add(mName);
                     }
                 }
-                if (!(member.kind === "FunDecl" && member.modifiers.modifiers.includes("abstract"))) {
-                    concreteMembers.add(mName);
-                }
+                this.checkClassMember(member);
             }
-            this.checkClassMember(member);
-        }
+        });
         // Check all abstract parent members are implemented (only for non-abstract, non-sealed subclasses)
         const isAbstract = decl.modifiers.modifiers.includes("abstract");
         const isSealed = decl.kind === "SealedClassDecl";
@@ -791,6 +843,7 @@ class TypeChecker {
      * Extract smart-cast bindings from an `is`-check condition.
      * `x is T` → { x: T }
      * `x is T && y is U` → { x: T, y: U }
+     * `x != null` → { x: unwrapped(x) }
      */
     extractSmartCasts(condition) {
         const result = new Map();
@@ -799,6 +852,15 @@ class TypeChecker {
                 result.set(condition.expr.name, this.resolveTypeRef(condition.type));
             }
         }
+        else if (condition.kind === "BinaryExpr" &&
+            (condition.op === "!=" || condition.op === "!==") &&
+            condition.right.kind === "NullLiteralExpr" &&
+            condition.left.kind === "NameExpr") {
+            // x != null → narrow x to its non-nullable type inside then-branch
+            const varType = this.scope.lookup(condition.left.name)?.type;
+            if (varType)
+                result.set(condition.left.name, unwrapNullable(varType));
+        }
         else if (condition.kind === "BinaryExpr" && condition.op === "&&") {
             for (const [k, v] of this.extractSmartCasts(condition.left))
                 result.set(k, v);
@@ -811,6 +873,7 @@ class TypeChecker {
      * Extract smart-cast bindings for the ELSE branch.
      * `x !is T` → in else, `x` IS `T` → { x: T }
      * `x !is T || y !is U` → in else (both negations must fail), { x: T, y: U }
+     * `x == null` → in else, x is non-null → { x: unwrapped(x) }
      */
     extractElseSmartCasts(condition) {
         const result = new Map();
@@ -820,6 +883,15 @@ class TypeChecker {
                 result.set(condition.expr.name, this.resolveTypeRef(condition.type));
             }
         }
+        else if (condition.kind === "BinaryExpr" &&
+            (condition.op === "==" || condition.op === "===") &&
+            condition.right.kind === "NullLiteralExpr" &&
+            condition.left.kind === "NameExpr") {
+            // x == null → in else branch, x is non-null
+            const varType = this.scope.lookup(condition.left.name)?.type;
+            if (varType)
+                result.set(condition.left.name, unwrapNullable(varType));
+        }
         else if (condition.kind === "BinaryExpr" && condition.op === "||") {
             // x !is T || y !is U → both must be false to reach else, so both narrow
             for (const [k, v] of this.extractElseSmartCasts(condition.left))
@@ -1003,6 +1075,9 @@ class TypeChecker {
                     // Don't error on Bibi — it's a special runtime symbol
                     if (expr.name === "Bibi")
                         return { tag: "func", params: [exports.T_STRING], ret: classType("BibiClient"), suspend: false };
+                    // Unit singleton — usable as a value (e.g. LaunchedEffect(Unit))
+                    if (expr.name === "Unit")
+                        return classType("Unit");
                     // Companion-like type objects (for Int.MAX_VALUE, Long.MIN_VALUE)
                     if (expr.name === "Int")
                         return classType("IntCompanion");
@@ -1079,6 +1154,20 @@ class TypeChecker {
                 return exports.T_UNKNOWN;
             }
             case "CallExpr": return this.checkCallExpr(expr);
+            case "SafeCallExpr": {
+                const calleeType = this.checkExpr(expr.callee);
+                for (const arg of expr.args)
+                    this.checkExpr(arg.value);
+                if (expr.trailingLambda)
+                    this.checkLambda(expr.trailingLambda);
+                const inner = unwrapNullable(calleeType);
+                if (inner.tag === "func")
+                    return nullable(inner.ret);
+                if (inner.tag === "any" || inner.tag === "unknown" || inner.tag === "error")
+                    return exports.T_UNKNOWN;
+                this.diag.error(expr.span, diagnostics_js_1.E_NOT_A_FUNCTION, `Type '${this.typeToString(calleeType)}' is not callable`);
+                return exports.T_ERROR;
+            }
             case "LambdaExpr": return this.checkLambda(expr);
             case "IfExpr": return this.checkIfExpr(expr);
             case "WhenExpr": {
@@ -1345,12 +1434,16 @@ class TypeChecker {
     }
     checkLambda(expr, expectedParamTypes) {
         const childScope = new Scope(this.scope);
-        // If the lambda has no explicit params, synthesise an `it` binding using
-        // the first expected parameter type.
-        if (expr.params.length === 0 && expectedParamTypes && expectedParamTypes.length === 1) {
+        // If the lambda has no explicit params, synthesise an `it` binding.
+        // Use the expected parameter type when available, otherwise T_UNKNOWN.
+        // This ensures `it` is always resolvable in single-param lambdas.
+        if (expr.params.length === 0) {
+            const itType = (expectedParamTypes && expectedParamTypes.length === 1)
+                ? expectedParamTypes[0]
+                : exports.T_UNKNOWN;
             childScope.define({
                 name: "it",
-                type: expectedParamTypes[0],
+                type: itType,
                 mutable: false,
                 span: expr.span,
             });
@@ -2165,6 +2258,9 @@ class TypeChecker {
             return true;
         if (from.tag === "unknown" || to.tag === "unknown")
             return true;
+        // nullable(Nothing) is the type of the `null` literal — assignable to every nullable type
+        if (from.tag === "nullable" && from.inner.tag === "nothing")
+            return to.tag === "nullable";
         if (to.tag === "nullable")
             return this.isAssignable(from, to.inner) || from.tag === "nullable";
         if (from.tag === "nullable")