modality-ts 0.0.2 → 0.0.3

package/dist/extraction/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extraction/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAA6B,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACrH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAE/B,MAAM,WAAW,yBAAyB;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,KAAK,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAClE,SAAS,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACpC,aAAa,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,sBAAuB,SAAQ,wBAAwB;IACtE,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AA0CD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,SAAS,EAAE,WAAW,GAAE,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,QAAQ,CAAa,GAAG,cAAc,CAuBhJ;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B,GAAG,wBAAwB,CAEzH;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B,GAAG,sBAAsB,CA2I3H"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extraction/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAA6B,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACrH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAE/B,MAAM,WAAW,yBAAyB;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,KAAK,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAClE,SAAS,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACpC,aAAa,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,sBAAuB,SAAQ,wBAAwB;IACtE,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AA0CD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,SAAS,EAAE,WAAW,GAAE,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,QAAQ,CAAa,GAAG,cAAc,CAuBhJ;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B,GAAG,wBAAwB,CAEzH;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B,GAAG,sBAAsB,CA4I3H"}

package/dist/extraction/index.js

@@ -68,8 +68,10 @@ export function extractUseStateSkeleton(sourceText, options = {}) {
         if (!componentName && isCustomHookDeclaration(node))
             return;
         const nextComponent = componentNameFor(node) ?? componentName;
-        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && isExtractableHandler(node.initializer)) {
-            handlers.set(node.name.text, node.initializer);
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+            const handler = extractableHandlerInitializer(node.initializer);
+            if (handler)
+                handlers.set(node.name.text, handler);
         }
         if (ts.isVariableDeclaration(node) && node.initializer && isUseReducerCall(node.initializer)) {
             warnings.push({ message: `Unsupported useReducer ${nextComponent ?? "Anonymous"}.useReducer`, ...lineAndColumn(source, node) });
@@ -391,6 +393,15 @@ function isUseEffectCall(node) {
 function isExtractableHandler(node) {
     return ts.isArrowFunction(node) || ts.isFunctionExpression(node);
 }
+function extractableHandlerInitializer(node) {
+    if (isExtractableHandler(node))
+        return node;
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "useCallback") {
+        const callback = node.arguments[0];
+        return callback && isExtractableHandler(callback) ? callback : undefined;
+    }
+    return undefined;
+}
 function refSetterTaint(node, setters) {
     if (ts.isVariableDeclaration(node) && node.initializer && isUseRefCall(node.initializer)) {
         const arg = node.initializer.arguments[0];
@@ -594,7 +605,7 @@ function transitionsFromResolvedHandler(source, fileName, node, attr, handler, s
     const loopTransitions = loopWriteTransitions(source, fileName, node, attr, handler, setters, component, locator);
     if (loopTransitions.length > 0)
         return applyParsedGuard(loopTransitions, disabledGuard);
-    const sequentialTransition = sequentialTransitionFromHandler(source, fileName, node, attr, handler, setters, component, locator);
+    const sequentialTransition = sequentialTransitionFromHandler(source, fileName, node, attr, handler, setters, handlers, component, locator);
     if (sequentialTransition)
         return applyParsedGuard([sequentialTransition], disabledGuard);
     const summary = callSummaryFromHandler(handler, setters);
@@ -606,6 +617,9 @@ function transitionsFromResolvedHandler(source, fileName, node, attr, handler, s
     const navigation = navigationTransition(source, fileName, node, attr, component, inlinedCall, locator);
     if (navigation)
         return applyParsedGuard([navigation], disabledGuard);
+    const swrMutate = swrMutateTransition(source, fileName, node, attr, component, inlinedCall, locator);
+    if (swrMutate)
+        return applyParsedGuard([swrMutate], disabledGuard);
     const setterCall = setterCallFrom(inlinedCall, setters);
     if (!setterCall) {
         const escaped = escapedSetters(inlinedCall, setters);
@@ -633,7 +647,7 @@ function transitionsFromResolvedHandler(source, fileName, node, attr, handler, s
             confidence: "exact"
         }], disabledGuard);
 }
-function sequentialTransitionFromHandler(source, fileName, node, attr, handler, setters, component, locator) {
+function sequentialTransitionFromHandler(source, fileName, node, attr, handler, setters, handlers, component, locator) {
     if (!ts.isBlock(handler.body))
         return undefined;
     const locals = new Map();
@@ -641,6 +655,11 @@ function sequentialTransitionFromHandler(source, fileName, node, attr, handler,
     for (const statement of handler.body.statements) {
         if (bindConstStatement(statement, setters, locals))
             continue;
+        const helper = helperSummariesFromStatement(statement, handlers, setters);
+        if (helper) {
+            summaries.push(...helper);
+            continue;
+        }
         const summary = summarizeSetterStatement(statement, setters, locals);
         if (!summary)
             return undefined;
@@ -662,6 +681,23 @@ function sequentialTransitionFromHandler(source, fileName, node, attr, handler,
         confidence: effects.some((effect) => effect.kind === "havoc") ? "over-approx" : "exact"
     };
 }
+function helperSummariesFromStatement(statement, handlers, setters) {
+    if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression) || !ts.isIdentifier(statement.expression.expression))
+        return undefined;
+    const helper = handlers.get(statement.expression.expression.text);
+    if (!helper || !ts.isBlock(helper.body))
+        return undefined;
+    const locals = new Map();
+    const summaries = [];
+    for (const child of helper.body.statements) {
+        if (bindConstStatement(child, setters, locals))
+            continue;
+        const summary = summarizeSetterStatement(child, setters, locals);
+        if (summary)
+            summaries.push(summary);
+    }
+    return summaries.length > 0 ? summaries : undefined;
+}
 function loopWriteTransitions(source, fileName, node, attr, handler, setters, component, locator) {
     if (!ts.isBlock(handler.body))
         return [];
@@ -727,6 +763,11 @@ function havocSetterTransition(source, fileName, node, attr, component, setter,
     };
 }
 function setterArgumentExpr(argument, setter, setters, locals) {
+    if (ts.isObjectLiteralExpression(argument)) {
+        const object = objectLiteralAssignmentExpr(argument, setter.domain, setters, locals);
+        if (object)
+            return object;
+    }
     if ((ts.isArrowFunction(argument) || ts.isFunctionExpression(argument)) && argument.parameters.length === 1 && ts.isIdentifier(argument.parameters[0].name)) {
         if (ts.isBlock(argument.body))
             return undefined;
@@ -734,11 +775,42 @@ function setterArgumentExpr(argument, setter, setters, locals) {
     }
     return valueExpr(argument, setters, locals);
 }
+function objectLiteralAssignmentExpr(expression, domain, setters, locals) {
+    const value = {};
+    const reads = new Set();
+    const fields = domain.kind === "record" ? domain.fields : domain.kind === "tagged" ? taggedFieldsForObject(expression, domain) : {};
+    for (const property of expression.properties) {
+        if (!ts.isPropertyAssignment(property))
+            return undefined;
+        const name = propertyName(property.name);
+        if (!name)
+            return undefined;
+        const literal = literalValue(property.initializer);
+        if (literal !== undefined) {
+            value[name] = literal;
+            continue;
+        }
+        const bound = valueExpr(property.initializer, setters, locals);
+        if (bound?.expr.kind === "lit") {
+            value[name] = bound.expr.value;
+            bound.reads.forEach((read) => reads.add(read));
+            continue;
+        }
+        value[name] = firstValue(fields[name] ?? { kind: "tokens", count: 1 });
+    }
+    return { expr: { kind: "lit", value }, reads: [...reads] };
+}
+function taggedFieldsForObject(expression, domain) {
+    const tagProperty = expression.properties.find((property) => ts.isPropertyAssignment(property) && propertyName(property.name) === domain.tag);
+    const tag = tagProperty ? literalValue(tagProperty.initializer) : undefined;
+    const variant = typeof tag === "string" ? domain.variants[tag] : undefined;
+    return variant?.kind === "record" ? variant.fields : {};
+}
 function valueExpr(expression, setters, locals) {
     const value = literalValue(expression);
     if (value !== undefined)
         return { expr: { kind: "lit", value }, reads: [] };
-    if (ts.isIdentifier(expression) || ts.isPropertyAccessExpression(expression))
+    if (ts.isIdentifier(expression) || isPropertyAccessLike(expression))
         return modeledReadExpr(expression, setters, locals);
     if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.ExclamationToken) {
         const parsed = booleanExpr(expression.operand, setters, locals);
@@ -747,7 +819,7 @@ function valueExpr(expression, setters, locals) {
     if (ts.isParenthesizedExpression(expression))
         return valueExpr(expression.expression, setters, locals);
     if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
-        return nullishOptionalReadExpr(expression, setters);
+        return nullishOptionalReadExpr(expression, setters, locals);
     }
     if (ts.isConditionalExpression(expression)) {
         const condition = booleanExpr(expression.condition, setters, locals);
@@ -791,22 +863,25 @@ function objectSpreadUpdateExpr(expression, setters, locals) {
     }
     return current;
 }
-function nullishOptionalReadExpr(expression, setters) {
-    if (literalValue(expression.right) !== null)
+function nullishOptionalReadExpr(expression, setters, locals = new Map()) {
+    const fallback = literalValue(expression.right);
+    if (fallback === undefined)
         return undefined;
     const read = optionalReadPath(expression.left);
     if (!read?.optional || read.path.length === 0)
         return undefined;
-    const varId = stateVarForName(read.base, setters);
+    const local = locals.get(read.base);
+    const varId = local?.expr.kind === "read" ? local.expr.var : stateVarForName(read.base, setters);
     if (!varId)
         return undefined;
+    const basePath = local?.expr.kind === "read" ? local.expr.path ?? [] : [];
     return {
         expr: {
             kind: "cond",
             args: [
-                { kind: "eq", args: [{ kind: "read", var: varId }, { kind: "lit", value: null }] },
-                { kind: "lit", value: null },
-                { kind: "read", var: varId, path: read.path }
+                { kind: "eq", args: [{ kind: "read", var: varId, ...(basePath.length > 0 ? { path: basePath } : {}) }, { kind: "lit", value: null }] },
+                { kind: "lit", value: fallback },
+                { kind: "read", var: varId, path: [...basePath, ...read.path] }
             ]
         },
         reads: [varId]
@@ -815,7 +890,7 @@ function nullishOptionalReadExpr(expression, setters) {
 function optionalReadPath(expression) {
     if (ts.isIdentifier(expression))
         return { base: expression.text, path: [], optional: false };
-    if (ts.isPropertyAccessExpression(expression)) {
+    if (isPropertyAccessLike(expression)) {
         const base = optionalReadPath(expression.expression);
         if (!base)
             return undefined;
@@ -891,9 +966,13 @@ function modeledReadExpr(expression, setters, locals) {
             reads: local.reads
         };
     }
-    const stateVar = stateVarForName(base, setters);
+    const setter = setterForName(base, setters);
+    const stateVar = setter?.varId;
     if (!stateVar)
         return undefined;
+    if (setter.domain.kind === "tagged" && segments.length > 0 && segments[0] !== setter.domain.tag) {
+        return { expr: { kind: "lit", value: firstValue(taggedPathDomain(setter.domain, segments) ?? { kind: "tokens", count: 1 }) }, reads: [] };
+    }
     return {
         expr: { kind: "read", var: stateVar, ...(segments.length > 0 ? { path: segments } : {}) },
         reads: [stateVar]
@@ -980,6 +1059,8 @@ function callSummaryFromHandler(handler, setters, initialLocals = new Map()) {
     const body = handler.body;
     if (ts.isCallExpression(body))
         return { call: body, locals: new Map(initialLocals) };
+    if (ts.isVoidExpression(body) && ts.isCallExpression(body.expression))
+        return { call: body.expression, locals: new Map(initialLocals) };
     if (ts.isBlock(body)) {
         const locals = new Map(initialLocals);
         for (let index = 0; index < body.statements.length; index += 1) {
@@ -987,12 +1068,29 @@ function callSummaryFromHandler(handler, setters, initialLocals = new Map()) {
             const isLast = index === body.statements.length - 1;
             if (isLast && ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression))
                 return { call: statement.expression, locals };
+            if (isLast && ts.isExpressionStatement(statement) && ts.isVoidExpression(statement.expression) && ts.isCallExpression(statement.expression.expression))
+                return { call: statement.expression.expression, locals };
             if (!bindConstStatement(statement, setters, locals))
                 return undefined;
         }
     }
     return undefined;
 }
+function swrMutateTransition(source, fileName, node, attr, component, call, locator) {
+    if (!ts.isIdentifier(call.expression) || call.expression.text !== "mutate")
+        return undefined;
+    return {
+        id: `${component}.${attr}.mutate`,
+        cls: "user",
+        label: labelForEvent(attr, locator),
+        source: [{ file: fileName, ...lineAndColumn(source, node) }],
+        guard: { kind: "lit", value: true },
+        effect: { kind: "seq", effects: [] },
+        reads: [],
+        writes: [],
+        confidence: "exact"
+    };
+}
 function bindConstStatement(statement, setters, locals, partialBoolean = false) {
     if (!ts.isVariableStatement(statement))
         return false;
@@ -1989,7 +2087,7 @@ function parseGuardExpression(expression, setters, locals = new Map()) {
         return { expr: { kind: "lit", value: true }, reads: [] };
     if (expression.kind === ts.SyntaxKind.FalseKeyword)
         return { expr: { kind: "lit", value: false }, reads: [] };
-    if (ts.isIdentifier(expression) || ts.isPropertyAccessExpression(expression))
+    if (ts.isIdentifier(expression) || isPropertyAccessLike(expression))
         return valueExpr(expression, setters, locals);
     if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.ExclamationToken) {
         const parsed = parseGuardExpression(expression.operand, setters, locals);
@@ -2034,7 +2132,7 @@ function parseGuardOperand(expression, setters, locals = new Map()) {
     const value = literalValue(expression);
     if (value !== undefined)
         return { expr: { kind: "lit", value }, reads: [] };
-    if (ts.isIdentifier(expression) || ts.isPropertyAccessExpression(expression))
+    if (ts.isIdentifier(expression) || isPropertyAccessLike(expression))
         return valueExpr(expression, setters, locals);
     return parseGuardExpression(expression, setters, locals);
 }
@@ -2050,7 +2148,32 @@ function parseConjunctiveGuardExpression(expression, setters, locals = new Map()
     return parseGuardExpression(expression, setters, locals);
 }
 function stateVarForName(name, setters) {
-    return [...setters.values()].find((setter) => setter.stateName === name)?.varId;
+    return setterForName(name, setters)?.varId;
+}
+function setterForName(name, setters) {
+    return setters.get(name) ?? [...setters.values()].find((setter) => setter.stateName === name);
+}
+function taggedPathDomain(domain, path) {
+    const [field, ...rest] = path;
+    if (!field)
+        return domain;
+    const variants = Object.values(domain.variants).filter((variant) => variant.kind === "record");
+    const fieldDomains = variants.map((variant) => variant.fields[field]).filter((candidate) => Boolean(candidate));
+    if (fieldDomains.length === 0)
+        return undefined;
+    const first = fieldDomains[0];
+    if (rest.length === 0)
+        return first;
+    return first.kind === "record" ? domainAtRecordPath(first, rest) : undefined;
+}
+function domainAtRecordPath(domain, path) {
+    const [field, ...rest] = path;
+    if (!field)
+        return domain;
+    const next = domain.fields[field];
+    if (!next || rest.length === 0)
+        return next;
+    return next.kind === "record" ? domainAtRecordPath(next, rest) : undefined;
 }
 function andGuard(left, right) {
     if (isTrueLiteral(left))
@@ -2149,12 +2272,15 @@ function isInputValueExpression(node, parameter) {
 function propertyAccessPath(node) {
     if (ts.isIdentifier(node))
         return [node.text];
-    if (ts.isPropertyAccessExpression(node)) {
+    if (isPropertyAccessLike(node)) {
         const base = propertyAccessPath(node.expression);
         return base ? [...base, node.name.text] : undefined;
     }
     return undefined;
 }
+function isPropertyAccessLike(node) {
+    return ts.isPropertyAccessExpression(node) || ts.isPropertyAccessChain(node);
+}
 function valueClassForDomain(domain) {
     if (domain.kind === "enum")
         return domain.values.join("|") || "enum";