fix: add better nullable check

Author: DylanPiercey

.changeset/fair-spoons-reply.md

@@ -0,0 +1,5 @@
+---
+"@marko/runtime-tags": patch
+---
+
+Add better nullable check to node evaluation.

packages/runtime-tags/src/__tests__/fixtures/error-const-mutation/__snapshots__/dom.expected/template.js

@@ -16,10 +16,10 @@ const $user_middleName = /* @__PURE__ */_$.value("user_middleName", $expr_user_f
 const $user_firstName = /* @__PURE__ */_$.value("user_firstName", $expr_user_fullName_user_firstName_user_middleName_user_lastName);
 const $user_fullName = /* @__PURE__ */_$.value("user_fullName", $expr_user_fullName_user_firstName_user_middleName_user_lastName);
 const $user = /* @__PURE__ */_$.value("user", ($scope, user) => {
-  $user_fullName($scope, user?.fullName);
-  $user_firstName($scope, user?.firstName);
-  $user_middleName($scope, user?.middleName);
-  $user_lastName($scope, user?.lastName);
+  $user_fullName($scope, user.fullName);
+  $user_firstName($scope, user.firstName);
+  $user_middleName($scope, user.middleName);
+  $user_lastName($scope, user.lastName);
 });
 export function $setup($scope) {
   $user($scope, {

packages/runtime-tags/src/translator/core/const.ts

@@ -50,7 +50,7 @@ export default {
         );
     }
 
-    const valueExtra = evaluate(valueAttr.value); // TODO could perform a more extensive "nullable" check.
+    const valueExtra = evaluate(valueAttr.value);
     const upstreamAlias = t.isIdentifier(valueAttr.value)
       ? tag.scope.getBinding(valueAttr.value.name)?.identifier.extra?.binding
       : undefined;
@@ -62,6 +62,7 @@ export default {
     const binding = trackVarReferences(tag, BindingType.derived, upstreamAlias);
 
     if (binding) {
+      if (!valueExtra.nullable) binding.nullable = false;
       setBindingValueExpr(binding, valueExtra);
     }
   },

packages/runtime-tags/src/translator/util/evaluate.ts

@@ -5,6 +5,7 @@ declare module "@marko/compiler/dist/types" {
   export interface NodeExtra {
     confident?: boolean;
     computed?: unknown;
+    nullable?: boolean;
   }
 }
 
@@ -20,14 +21,90 @@ export default function evaluate<T extends t.Expression>(value: T) {
     if (computed) {
       extra.computed = computed.value;
       extra.confident = true;
+      extra.nullable = computed.value == null;
     } else {
       extra.computed = undefined;
       extra.confident = false;
+      extra.nullable = isNullableExpr(value);
     }
   }
 
   return extra as T["extra"] & {
     confident: boolean;
+    nullable: boolean;
     computed: unknown;
   };
 }
+
+function isNullableExpr(expr: t.Expression): boolean {
+  switch (expr.type) {
+    case "ArrayExpression":
+    case "ArrowFunctionExpression":
+    case "BigIntLiteral":
+    case "BinaryExpression":
+    case "BooleanLiteral":
+    case "ClassExpression":
+    case "FunctionExpression":
+    case "NewExpression":
+    case "NumericLiteral":
+    case "ObjectExpression":
+    case "RegExpLiteral":
+    case "StringLiteral":
+    case "TemplateLiteral":
+    case "UpdateExpression":
+      return false;
+    case "AssignmentExpression":
+      switch (expr.operator) {
+        case "=":
+          return isNullableExpr(expr.right);
+        case "*=":
+        case "/=":
+        case "%=":
+        case "+=":
+        case "-=":
+        case "<<=":
+        case ">>=":
+        case ">>>=":
+        case "&=":
+        case "^=":
+        case "|=":
+        case "**=":
+          return false;
+        case "||=":
+        case "??=":
+          return (
+            isNullableExpr(expr.right) ||
+            isNullableExpr(expr.left as t.Expression)
+          );
+        case "&&=":
+          return (
+            isNullableExpr(expr.left as t.Expression) &&
+            isNullableExpr(expr.right)
+          );
+        default:
+          return true;
+      }
+    case "AwaitExpression":
+      return isNullableExpr(expr.argument);
+    case "ConditionalExpression":
+      return isNullableExpr(expr.consequent) && isNullableExpr(expr.alternate);
+    case "LogicalExpression":
+      switch (expr.operator) {
+        case "||":
+        case "??":
+          return isNullableExpr(expr.right) || isNullableExpr(expr.left);
+        case "&&":
+          return isNullableExpr(expr.left) && isNullableExpr(expr.right);
+        default:
+          return true;
+      }
+    case "ParenthesizedExpression":
+      return isNullableExpr(expr.expression);
+    case "SequenceExpression":
+      return isNullableExpr(expr.expressions[expr.expressions.length - 1]);
+    case "UnaryExpression":
+      return expr.operator === "void";
+    default:
+      return true;
+  }
+}

packages/runtime-tags/src/translator/visitors/program/index.ts

@@ -95,6 +95,8 @@ export default {
           if (value) {
             programExtra.returnValueExpr = value.extra ??= {};
           }
+
+          break;
         }
       }
     },