semantifold 0.10.0 → 0.11.0

package/src/backends/shared.js

@@ -37,6 +37,7 @@ const task012Languages = new Set(["php", "ruby", "javascript", "typescript", "ja
 const task014Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task032Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task033Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
+const task048ConditionalLanguages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const javaReferenceMethodHooks = new Set(["clone", "equals", "finalize", "getClass", "hashCode", "notify", "notifyAll", "toString", "wait"])
 const javascriptReferenceMethodHooks = new Set([
   "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "__proto__", "constructor",
@@ -1129,6 +1130,11 @@ function expressionContainsKind(expression, kind) {
   if (expression.kind == "BinaryExpression") {
     return expressionContainsKind(expression.left, kind) || expressionContainsKind(expression.right, kind)
   }
+  if (expression.kind == "ConditionalExpression") {
+    return expressionContainsKind(expression.condition, kind) ||
+      expressionContainsKind(expression.consequent, kind) ||
+      expressionContainsKind(expression.alternate, kind)
+  }
   if (expression.kind == "CallExpression") return expression.arguments.some((argument) => expressionContainsKind(argument, kind))
   if (expression.kind == "MethodCallExpression") {
     return expressionContainsKind(expression.receiver, kind) ||
@@ -1936,6 +1942,19 @@ function validateExpression(expression, language, ownerLocation, allowJavaNegate
     return
   }
 
+  if (candidate.kind == "ConditionalExpression") {
+    const fields = Object.keys(candidate).filter((key) => key != "sourceProvenance").sort().join(",")
+
+    if (fields != "alternate,condition,consequent,kind,location,type") {
+      unsupportedCapability(language, "malformed ConditionalExpression", location)
+    }
+    if (!task048ConditionalLanguages.has(language)) unsupportedCapability(language, "Task 048 conditional expression", location)
+    validateExpression(candidate.condition, language, location, false, expressionPath, externalDeclarationIds)
+    validateExpression(candidate.consequent, language, location, false, expressionPath, externalDeclarationIds)
+    validateExpression(candidate.alternate, language, location, false, expressionPath, externalDeclarationIds)
+    return
+  }
+
   unsupportedCapability(language, String(Reflect.get(expression, "kind")), location)
 }
 
@@ -2364,6 +2383,17 @@ export function emitExpression(writer, expression, path, language, emitIdentifie
     return
   }
 
+  if (expression.kind == "ConditionalExpression") {
+    writer.mapped("(", {mappingKind: "anchor", node: expression, path})
+    emitExpression(writer, expression.condition, `${path}/condition`, language, emitIdentifier)
+    writer.mapped(" ? ", {mappingKind: "exact", node: expression, path, role: "operator"})
+    emitExpression(writer, expression.consequent, `${path}/consequent`, language, emitIdentifier)
+    writer.mapped(" : ", {mappingKind: "exact", node: expression, path, role: "colon"})
+    emitExpression(writer, expression.alternate, `${path}/alternate`, language, emitIdentifier)
+    writer.mapped(")", {mappingKind: "anchor", node: expression, path})
+    return
+  }
+
   if (expression.kind == "UnaryExpression") {
     if (language == "dart" && expression.operation == "IntegerNegate") {
       emitDartIntegerHelper(writer, expression, path, "_semantifoldIntegerNegate", [

package/src/frontends/java.js

@@ -329,6 +329,29 @@ function convertExpression(node, filename, source, context, expectedType) {
     return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (semantic))
   }
 
+  if (node.name == "TernaryExpression") {
+    const children = directChildren(node)
+    const question = children.find((child) => child.name == "?" || (child.name == "LogicOp" && nodeText(child, source) == "?"))
+    const colon = children.find((child) => child.name == ":" || (child.name == "LogicOp" && nodeText(child, source) == ":"))
+    const named = children.filter((child) => child !== question && child !== colon)
+
+    if (!question || !colon || named.length != 3) return unsupportedSyntax("java", "ternary expression", location)
+
+    return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (withParserRanges({
+      alternate: convertExpression(named[2], filename, source, context),
+      condition: convertExpression(named[0], filename, source, context),
+      consequent: convertExpression(named[1], filename, source, context),
+      kind: /** @type {const} */ ("ConditionalExpression"),
+      location
+    }, {
+      alternate: nodeLocation(named[2], filename, source),
+      colon: nodeLocation(colon, filename, source),
+      condition: nodeLocation(named[0], filename, source),
+      consequent: nodeLocation(named[1], filename, source),
+      operator: nodeLocation(question, filename, source)
+    })))
+  }
+
   if (node.name == "MethodInvocation") {
     if (isEqualsInvocation(node, source) && !isZeroArgumentRecordMemberInvocation(node, filename, source, context)) {
       const methodName = requiredChild(node, "MethodName", filename, source)
@@ -626,6 +649,7 @@ function isSupportedExpressionNode(node) {
     "StringLiteral",
     "UnaryExpression",
     "BinaryExpression",
+    "TernaryExpression",
     "MethodInvocation",
     "ObjectCreationExpression",
     "FieldAccess",

package/src/frontends/javascript-typescript.js

@@ -7,7 +7,7 @@ import {blockReferencesProtectedEntry} from "../semantic/effects.js"
 import {locationFromOffsets, moduleLocation} from "../semantic/location.js"
 import {withAdaptedOperation} from "../semantic/operators.js"
 import {withParserRanges} from "../semantic/provenance.js"
-import {hasOnlyUnicodeScalars} from "../semantic/scalars.js"
+import {hasOnlyUnicodeScalars, scalarType} from "../semantic/scalars.js"
 import {isTask034ResourceProbe} from "../semantic/capabilities.js"
 import {hasExactEffectSupport} from "../backends/effects.js"
 import {requireSourceReturnType, requireSourceScalarType} from "./scalars.js"
@@ -431,7 +431,38 @@ function convertExpression(node, language, filename, source, context = {bindings
   }
 
   if (node.type == "TemplateLiteral") {
-    if (node.expressions.length > 0) return unsupportedSyntax(language, "interpolated string", location)
+    if (node.expressions.length > 0) {
+      /** @type {import("../semantic/types.js").Expression[]} */
+      const ordered = []
+
+      node.quasis.forEach((quasi, index) => {
+        if (typeof quasi.value.cooked != "string" || !hasOnlyUnicodeScalars(quasi.value.cooked)) {
+          return unsupportedSyntax(language, "invalid Unicode string literal", nodeLocation(quasi, filename, source))
+        }
+        const quasiLocation = nodeLocation(quasi, filename, source)
+
+        if (quasi.value.cooked.length > 0) ordered.push(withParserRanges({kind: /** @type {const} */ ("StringLiteral"), location: quasiLocation, value: quasi.value.cooked}, {literal: quasiLocation}))
+        if (index < node.expressions.length) {
+          ordered.push(convertExpression(/** @type {import("@babel/types").Expression} */ (node.expressions[index]), language, filename, source, context, scalarType("string")))
+        }
+      })
+      if (ordered.length == 0) return unsupportedSyntax(language, "interpolated string", location)
+
+      let lowered = ordered[0]
+
+      for (const part of ordered.slice(1)) {
+        const semantic = withAdaptedOperation({
+          kind: /** @type {const} */ ("BinaryExpression"),
+          left: lowered,
+          location,
+          right: part
+        }, /** @type {import("../semantic/operators.js").AdaptedOperation} */ ("StringConcat"))
+
+        lowered = /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (semantic))
+      }
+
+      return lowered
+    }
 
     const quasi = node.quasis[0]
 
@@ -442,6 +473,22 @@ function convertExpression(node, language, filename, source, context = {bindings
     return withParserRanges({kind: /** @type {const} */ ("StringLiteral"), location, value: quasi.value.cooked}, {literal: location})
   }
 
+  if (node.type == "ConditionalExpression") {
+    return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (withParserRanges({
+      alternate: convertExpression(node.alternate, language, filename, source, context),
+      condition: convertExpression(node.test, language, filename, source, context),
+      consequent: convertExpression(node.consequent, language, filename, source, context),
+      kind: /** @type {const} */ ("ConditionalExpression"),
+      location
+    }, {
+      alternate: nodeLocation(node.alternate, filename, source),
+      colon: tokenLocation(node, ":", node.consequent.end ?? node.test.end ?? node.start ?? 0, node.alternate.start ?? node.end ?? source.length, filename, source),
+      condition: nodeLocation(node.test, filename, source),
+      consequent: nodeLocation(node.consequent, filename, source),
+      operator: tokenLocation(node, "?", node.test.end ?? node.start ?? 0, node.consequent.start ?? node.end ?? source.length, filename, source)
+    })))
+  }
+
   if (node.type == "UnaryExpression" && ["!", "-"].includes(node.operator)) {
     const operand = convertExpression(node.argument, language, filename, source, context)
     const semantic = withAdaptedOperation(withParserRanges({

package/src/frontends/php.js

@@ -222,9 +222,37 @@ function convertExpression(node, filename, source, context, expectedType, preser
 
   if (node.kind == "encapsed") {
     const literal = /** @type {import("php-parser").Encapsed} */ (node)
-    const detail = literal.type == "string" ? "interpolated string" : `${literal.type} string`
 
-    return unsupportedSyntax("php", detail, location)
+    if (literal.type != "string") return unsupportedSyntax("php", `${literal.type} string`, location)
+    if (!Array.isArray(literal.value)) return unsupportedSyntax("php", "interpolated string", location)
+
+    const parts = literal.value.map((part) => {
+      if (part.kind != "encapsedpart") return unsupportedSyntax("php", `interpolated string part ${part.kind}`, nodeLocation(part, filename, source))
+      const encapsedPart = /** @type {import("php-parser").EncapsedPart} */ (part)
+
+      if (!encapsedPart.expression) return unsupportedSyntax("php", "interpolated string part without expression", nodeLocation(encapsedPart, filename, source))
+
+      return convertExpression(encapsedPart.expression, filename, source, context, scalarType("string"))
+    })
+
+    if (parts.length == 0) {
+      return withParserRanges({kind: /** @type {const} */ ("StringLiteral"), location, value: ""}, {literal: location})
+    }
+
+    let lowered = parts[0]
+
+    for (const part of parts.slice(1)) {
+      const semantic = withAdaptedOperation({
+        kind: /** @type {const} */ ("BinaryExpression"),
+        left: lowered,
+        location,
+        right: part
+      }, /** @type {import("../semantic/operators.js").AdaptedOperation} */ ("StringConcat"))
+
+      lowered = /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (semantic))
+    }
+
+    return withParserRanges(lowered, {literal: location})
   }
 
   if (node.kind == "nowdoc") return unsupportedSyntax("php", "nowdoc string", location)
@@ -414,6 +442,37 @@ function convertExpression(node, filename, source, context, expectedType, preser
     return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (semantic))
   }
 
+  if (node.kind == "retif") {
+    const ternary = /** @type {import("php-parser").RetIf} */ (node)
+
+    if (!ternary.test || !ternary.trueExpr || !ternary.falseExpr) return unsupportedSyntax("php", "short ternary", location)
+    if (ternary.test.kind == "variable") {
+      const tested = /** @type {import("php-parser").Variable} */ (ternary.test)
+
+      if (typeof tested.name == "string" && context.bindings.get(tested.name)?.kind == "OptionalType") {
+        return unsupportedSyntax("php", "optional truthiness condition", nodeLocation(tested, filename, source))
+      }
+    }
+
+    return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (withParserRanges({
+      alternate: convertExpression(ternary.falseExpr, filename, source, context),
+      condition: convertExpression(ternary.test, filename, source, context),
+      consequent: convertExpression(ternary.trueExpr, filename, source, context),
+      kind: /** @type {const} */ ("ConditionalExpression"),
+      location
+    }, {
+      alternate: tokenLocation(":", ternary.trueExpr.loc?.end.offset ?? 0, ternary.falseExpr.loc?.start.offset ?? source.length, filename, source),
+      colon: tokenLocation(":", ternary.trueExpr.loc?.end.offset ?? 0, ternary.falseExpr.loc?.start.offset ?? source.length, filename, source),
+      condition: ternary.test.loc ? nodeLocation(ternary.test, filename, source) : location,
+      consequent: ternary.trueExpr.loc ? nodeLocation(ternary.trueExpr, filename, source) : location,
+      operator: tokenLocation("?", ternary.test.loc?.end.offset ?? 0, ternary.trueExpr.loc?.start.offset ?? source.length, filename, source)
+    })))
+  }
+
+  if (node.kind == "nullsafepropertylookup" || node.kind == "nullsafemethodcall") {
+    return unsupportedSyntax("php", "safe navigation", location)
+  }
+
   if (node.kind == "bin") {
     const binary = /** @type {import("php-parser").Bin} */ (node)
     if (binary.type == "!==" && binary.left.kind == "variable" && binary.right.kind == "nullkeyword") {

package/src/frontends/ruby.js

@@ -14,6 +14,7 @@ import {
   ConstantReadNode,
   DefNode,
   ElseNode,
+  EmbeddedStatementsNode,
   FalseNode,
   HashNode,
   IfNode,
@@ -49,7 +50,7 @@ import {blockReferencesProtectedEntry} from "../semantic/effects.js"
 import {locationFromOffsets, moduleLocation, utf8ByteOffsetToUtf16Offset} from "../semantic/location.js"
 import {withAdaptedOperation} from "../semantic/operators.js"
 import {withParserRanges} from "../semantic/provenance.js"
-import {hasOnlyUnicodeScalars} from "../semantic/scalars.js"
+import {hasOnlyUnicodeScalars, scalarType} from "../semantic/scalars.js"
 import {isTask034ResourceProbe} from "../semantic/capabilities.js"
 import {hasExactEffectSupport} from "../backends/effects.js"
 import {requireSourceReturnType} from "./scalars.js"
@@ -207,7 +208,65 @@ function convertExpression(node, filename, source, context, expectedType, preser
     return withParserRanges({kind: /** @type {const} */ ("StringLiteral"), location, value: decoded.value}, {literal: location})
   }
 
-  if (node instanceof InterpolatedStringNode) return unsupportedSyntax("ruby", "interpolated string", location)
+  if (node instanceof InterpolatedStringNode) {
+    if (node.openingLoc && slicePrismSource(source, node.openingLoc.startOffset, node.openingLoc.startOffset + node.openingLoc.length).startsWith("<<")) {
+      return unsupportedSyntax("ruby", "heredoc string", location)
+    }
+
+    const parts = node.parts.map((part) => {
+      if (part instanceof StringNode) return convertExpression(part, filename, source, context, scalarType("string"))
+      if (part instanceof EmbeddedStatementsNode) {
+        const statements = part.statements
+
+        if (!statements || statements.body.length != 1) return unsupportedSyntax("ruby", "interpolated statement", nodeLocation(part, filename, source))
+
+        return convertExpression(statements.body[0], filename, source, context, scalarType("string"))
+      }
+
+      return unsupportedSyntax("ruby", part.constructor.name, nodeLocation(part, filename, source))
+    })
+
+    if (parts.length == 0) return withParserRanges({kind: /** @type {const} */ ("StringLiteral"), location, value: ""}, {literal: location})
+
+    let lowered = parts[0]
+
+    for (const part of parts.slice(1)) {
+      const semantic = withAdaptedOperation({
+        kind: /** @type {const} */ ("BinaryExpression"),
+        left: lowered,
+        location,
+        right: part
+      }, /** @type {import("../semantic/operators.js").AdaptedOperation} */ ("StringConcat"))
+
+      lowered = /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (semantic))
+    }
+
+    return withParserRanges(lowered, {literal: location})
+  }
+
+  if (node instanceof IfNode && !node.ifKeywordLoc) {
+    const elseClause = node.subsequent
+    const consequentStatements = node.statements
+    const consequentArm = consequentStatements && consequentStatements.body.length == 1 ? consequentStatements.body[0] : undefined
+
+    if (!(elseClause instanceof ElseNode) || !elseClause.statements || elseClause.statements.body.length != 1 || !consequentArm || !node.thenKeywordLoc) {
+      return unsupportedSyntax("ruby", "ternary without alternate", location)
+    }
+
+    return /** @type {import("../semantic/types.js").Expression} */ (/** @type {unknown} */ (withParserRanges({
+      alternate: convertExpression(elseClause.statements.body[0], filename, source, context),
+      condition: convertExpression(node.predicate, filename, source, context),
+      consequent: convertExpression(consequentArm, filename, source, context),
+      kind: /** @type {const} */ ("ConditionalExpression"),
+      location
+    }, {
+      alternate: nodeLocation(elseClause.statements.body[0], filename, source),
+      colon: prismLocation(elseClause.elseKeywordLoc ?? elseClause.location, filename, source),
+      condition: nodeLocation(node.predicate, filename, source),
+      consequent: nodeLocation(consequentArm, filename, source),
+      operator: prismLocation(node.thenKeywordLoc, filename, source)
+    })))
+  }
 
   if (node instanceof OrNode && node.left instanceof LocalVariableReadNode &&
     context.bindings.get(node.left.name)?.kind == "OptionalType") {
@@ -863,6 +922,7 @@ function convertStatement(node, comments, context, filename, source) {
     if ((context.loopDepth ?? 0) > 0) return unsupportedSyntax("ruby", "nonlocal return from each block", nodeLocation(node, filename, source))
     return convertReturn(node, filename, source, context)
   }
+  if (node instanceof IfNode && !node.ifKeywordLoc) return unsupportedSyntax("ruby", "ternary statement", nodeLocation(node, filename, source))
   if (node instanceof IfNode || node instanceof UnlessNode) return convertIf(node, comments, context, filename, source)
   if (node instanceof WhileNode) return convertWhile(node, comments, context, filename, source)
   if (node instanceof BeginNode) return convertRubyTry(node, comments, context, filename, source)

package/src/language-registry.js

@@ -171,6 +171,8 @@ export function createLanguageRegistry(candidateRecords) {
     const featuresCandidate = candidate.features ?? {
       closedRecords: false,
       conditionControlledLoops: false,
+      conditionalExpressions: false,
+      stringInterpolation: false,
       effectfulCapabilitiesAndResources: false,
       generalFunctionsAndCalls: false,
       immutableCollections: false,
@@ -183,9 +185,10 @@ export function createLanguageRegistry(candidateRecords) {
     }
 
     if (!isPlainObject(featuresCandidate) ||
-      Object.keys(featuresCandidate).sort().join(",") != "closedRecords,conditionControlledLoops,effectfulCapabilitiesAndResources,generalFunctionsAndCalls,immutableCollections,optionalValues,orderedListIteration,orderedMapIteration,referenceClasses,typeParametersAndGenerics,typedErrors" ||
+      Object.keys(featuresCandidate).sort().join(",") != "closedRecords,conditionControlledLoops,conditionalExpressions,effectfulCapabilitiesAndResources,generalFunctionsAndCalls,immutableCollections,optionalValues,orderedListIteration,orderedMapIteration,referenceClasses,stringInterpolation,typeParametersAndGenerics,typedErrors" ||
       typeof featuresCandidate.closedRecords != "boolean" ||
       typeof featuresCandidate.conditionControlledLoops != "boolean" ||
+      typeof featuresCandidate.conditionalExpressions != "boolean" ||
       typeof featuresCandidate.effectfulCapabilitiesAndResources != "boolean" ||
       typeof featuresCandidate.generalFunctionsAndCalls != "boolean" ||
       typeof featuresCandidate.immutableCollections != "boolean" ||
@@ -193,6 +196,7 @@ export function createLanguageRegistry(candidateRecords) {
       typeof featuresCandidate.orderedListIteration != "boolean" ||
       typeof featuresCandidate.orderedMapIteration != "boolean" ||
       typeof featuresCandidate.referenceClasses != "boolean" ||
+      typeof featuresCandidate.stringInterpolation != "boolean" ||
       typeof featuresCandidate.typedErrors != "boolean" ||
       typeof featuresCandidate.typeParametersAndGenerics != "boolean") {
       invalidRegistry(`Registry record '${id}' has an invalid feature declaration.`, id)
@@ -200,6 +204,7 @@ export function createLanguageRegistry(candidateRecords) {
     const features = deepFreeze(/** @type {import("./semantic/types.js").LanguageFeatureCapabilities} */ ({
       closedRecords: featuresCandidate.closedRecords,
       conditionControlledLoops: featuresCandidate.conditionControlledLoops,
+      conditionalExpressions: featuresCandidate.conditionalExpressions,
       effectfulCapabilitiesAndResources: featuresCandidate.effectfulCapabilitiesAndResources,
       generalFunctionsAndCalls: featuresCandidate.generalFunctionsAndCalls,
       immutableCollections: featuresCandidate.immutableCollections,
@@ -207,6 +212,7 @@ export function createLanguageRegistry(candidateRecords) {
       orderedListIteration: featuresCandidate.orderedListIteration,
       orderedMapIteration: featuresCandidate.orderedMapIteration,
       referenceClasses: featuresCandidate.referenceClasses,
+      stringInterpolation: featuresCandidate.stringInterpolation,
       typedErrors: featuresCandidate.typedErrors,
       typeParametersAndGenerics: featuresCandidate.typeParametersAndGenerics
     }))
@@ -592,6 +598,8 @@ const records = [
     features: {
       closedRecords: false,
       conditionControlledLoops: false,
+      conditionalExpressions: false,
+      stringInterpolation: false,
       effectfulCapabilitiesAndResources: false,
       generalFunctionsAndCalls: true,
       immutableCollections: false,
@@ -615,6 +623,8 @@ const records = [
     features: {
       closedRecords: false,
       conditionControlledLoops: false,
+      conditionalExpressions: false,
+      stringInterpolation: false,
       effectfulCapabilitiesAndResources: false,
       generalFunctionsAndCalls: true,
       immutableCollections: false,
@@ -636,7 +646,7 @@ const records = [
     artifactMultiplicity: "multiple",
     binaryBackend: generateBrowserWasm,
     defaultFilename: "program.wasm",
-    features: {closedRecords: false, conditionControlledLoops: false, effectfulCapabilitiesAndResources: false, generalFunctionsAndCalls: false, immutableCollections: false, optionalValues: false, orderedListIteration: false, orderedMapIteration: false, referenceClasses: false, typedErrors: false, typeParametersAndGenerics: false},
+    features: {closedRecords: false, conditionControlledLoops: false, conditionalExpressions: false, stringInterpolation: false, effectfulCapabilitiesAndResources: false, generalFunctionsAndCalls: false, immutableCollections: false, optionalValues: false, orderedListIteration: false, orderedMapIteration: false, referenceClasses: false, typedErrors: false, typeParametersAndGenerics: false},
     id: "wasm",
     mapping: {binaryRanges: true, richText: true, sourceMapV3: true},
     mediaType: "application/wasm",
@@ -646,7 +656,7 @@ const records = [
     acceptance: {stages: ["generate", "compile", "validate", "instantiate", "execute"], toolchains: ["android"]},
     applicationBackend: generateAndroidApplication,
     artifactMultiplicity: "multiple",
-    features: {closedRecords: false, conditionControlledLoops: false, effectfulCapabilitiesAndResources: false, generalFunctionsAndCalls: false, immutableCollections: false, optionalValues: false, orderedListIteration: false, orderedMapIteration: false, referenceClasses: false, typedErrors: false, typeParametersAndGenerics: false},
+    features: {closedRecords: false, conditionControlledLoops: false, conditionalExpressions: false, stringInterpolation: false, effectfulCapabilitiesAndResources: false, generalFunctionsAndCalls: false, immutableCollections: false, optionalValues: false, orderedListIteration: false, orderedMapIteration: false, referenceClasses: false, typedErrors: false, typeParametersAndGenerics: false},
     id: "android",
     mapping: {binaryRanges: true, richText: true, sourceMapV3: true},
     roundTrip: false
@@ -655,7 +665,7 @@ const records = [
     acceptance: {stages: ["generate"], toolchains: []},
     applicationBackend: generateIosApplication,
     artifactMultiplicity: "multiple",
-    features: {closedRecords: false, conditionControlledLoops: false, effectfulCapabilitiesAndResources: false, generalFunctionsAndCalls: false, immutableCollections: false, optionalValues: false, orderedListIteration: false, orderedMapIteration: false, referenceClasses: false, typedErrors: false, typeParametersAndGenerics: false},
+    features: {closedRecords: false, conditionControlledLoops: false, conditionalExpressions: false, stringInterpolation: false, effectfulCapabilitiesAndResources: false, generalFunctionsAndCalls: false, immutableCollections: false, optionalValues: false, orderedListIteration: false, orderedMapIteration: false, referenceClasses: false, typedErrors: false, typeParametersAndGenerics: false},
     id: "ios",
     mapping: {binaryRanges: true, richText: true, sourceMapV3: true},
     roundTrip: false
@@ -664,7 +674,7 @@ const records = [
     acceptance: {stages: ["generate", "restore", "compile", "validate", "instantiate", "execute"], toolchains: ["flutter", "android"]},
     applicationBackend: generateFlutterApplication,
     artifactMultiplicity: "multiple",
-    features: {closedRecords: false, conditionControlledLoops: false, effectfulCapabilitiesAndResources: false, generalFunctionsAndCalls: false, immutableCollections: false, optionalValues: false, orderedListIteration: false, orderedMapIteration: false, referenceClasses: false, typedErrors: false, typeParametersAndGenerics: false},
+    features: {closedRecords: false, conditionControlledLoops: false, conditionalExpressions: false, stringInterpolation: false, effectfulCapabilitiesAndResources: false, generalFunctionsAndCalls: false, immutableCollections: false, optionalValues: false, orderedListIteration: false, orderedMapIteration: false, referenceClasses: false, typedErrors: false, typeParametersAndGenerics: false},
     id: "flutter",
     mapping: {binaryRanges: true, richText: true, sourceMapV3: true},
     roundTrip: false
@@ -689,6 +699,8 @@ function language(values) {
     features: {
       closedRecords: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
       conditionControlledLoops: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
+      conditionalExpressions: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
+      stringInterpolation: ["php", "ruby", "javascript", "typescript"].includes(String(values.id)),
       effectfulCapabilitiesAndResources: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
       generalFunctionsAndCalls: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),
       immutableCollections: ["php", "ruby", "javascript", "typescript", "java"].includes(String(values.id)),

package/src/semantic/effects.js

@@ -722,6 +722,7 @@ function expressionChildren(expression) {
   if (expression.kind == "MethodCallExpression") return [expression.receiver, ...expression.arguments]
   if (expression.kind == "OwnedBorrowExpression" || expression.kind == "OwnedMoveExpression") return [expression.expression]
   if (expression.kind == "BinaryExpression") return [expression.left, expression.right]
+  if (expression.kind == "ConditionalExpression") return [expression.condition, expression.consequent, expression.alternate]
   if (expression.kind == "UnaryExpression") return [expression.operand]
   if (expression.kind == "OptionalSome") return [expression.value]
   if (expression.kind == "OptionalIsPresent" || expression.kind == "OptionalUnwrap") return [expression.operand]

package/src/semantic/provenance.js

@@ -592,6 +592,10 @@ export function semanticEntries(module) {
     } else if (node.kind == "BinaryExpression") {
       visit(node.left, `${path}/left`, location)
       visit(node.right, `${path}/right`, location)
+    } else if (node.kind == "ConditionalExpression") {
+      visit(node.condition, `${path}/condition`, location)
+      visit(node.consequent, `${path}/consequent`, location)
+      visit(node.alternate, `${path}/alternate`, location)
     } else if (node.kind == "CallExpression" || node.kind == "EffectCallExpression") {
       node.arguments.forEach((child, index) => visit(child, `${path}/arguments/${index}`, location))
     } else if (node.kind == "OwnedMoveExpression" || node.kind == "OwnedBorrowExpression") {
@@ -951,6 +955,10 @@ function resolveSymbols(module, records) {
     } else if (expression.kind == "BinaryExpression") {
       visitExpression(expression.left, scope, `${path}/left`)
       visitExpression(expression.right, scope, `${path}/right`)
+    } else if (expression.kind == "ConditionalExpression") {
+      visitExpression(expression.condition, scope, `${path}/condition`)
+      visitExpression(expression.consequent, scope, `${path}/consequent`)
+      visitExpression(expression.alternate, scope, `${path}/alternate`)
     } else if (expression.kind == "ListLiteral") {
       for (const [index, element] of expression.elements.entries()) visitExpression(element, scope, `${path}/elements/${index}`)
     } else if (expression.kind == "MapLiteral" || expression.kind == "OrderedMapLiteral") {

package/src/semantic/types.js

@@ -180,6 +180,8 @@
  * @property {boolean} orderedListIteration - Task 008 ordered immutable-list iteration and nearest-loop control.
  * @property {boolean} orderedMapIteration - Task 014 insertion-ordered immutable-map pair iteration.
  * @property {boolean} conditionControlledLoops - Task 032 strict-Boolean pre-condition loops and resolved control.
+ * @property {boolean} conditionalExpressions - Task 048 strict-Boolean conditional expressions with joined arm types.
+ * @property {boolean} stringInterpolation - Task 048 parser-proved string interpolation lowered to checked string concatenation.
  * @property {boolean} closedRecords - Task 009 nominal closed immutable records, construction, and member reads.
  * @property {boolean} typedErrors - Task 011 nominal unchecked errors, raises, and exact typed catches.
  * @property {boolean} typeParametersAndGenerics - Task 012 invariant unbounded type parameters and closed generic applications.
@@ -983,6 +985,17 @@
  * @property {SemanticNodeSourceProvenance} [sourceProvenance] - Node-associated provenance.
  */
 
+/**
+ * @typedef ConditionalExpression
+ * @property {"ConditionalExpression"} kind - Node discriminator.
+ * @property {Expression} condition - Strict boolean test evaluated exactly once.
+ * @property {Expression} consequent - Arm evaluated when the test is true.
+ * @property {Expression} alternate - Arm evaluated when the test is false.
+ * @property {SemanticTypeName} type - Joined arm result type assigned by validation.
+ * @property {SourceLocation} location - Source location.
+ * @property {SemanticNodeSourceProvenance} [sourceProvenance] - Node-associated provenance.
+ */
+
 /**
  * @typedef CallExpression
  * @property {"CallExpression"} kind - Node discriminator.
@@ -1082,7 +1095,7 @@
  * @property {SemanticNodeSourceProvenance} [sourceProvenance] - Parser-owned message-member range.
  */
 
-/** @typedef {IdentifierExpression | ReceiverExpression | IntegerLiteral | BooleanLiteral | StringLiteral | OptionalNone | OptionalSome | OptionalIsPresent | OptionalUnwrap | ListLiteral | MapLiteral | OrderedMapLiteral | ListIndexExpression | MapLookupExpression | CollectionSizeExpression | UnaryExpression | BinaryExpression | CallExpression | EffectCallExpression | OwnedMoveExpression | OwnedBorrowExpression | MethodCallExpression | ReferenceConstruction | RecordConstruction | MemberRead | PrivateFieldRead | ErrorMessageRead} Expression */
+/** @typedef {IdentifierExpression | ReceiverExpression | IntegerLiteral | BooleanLiteral | StringLiteral | OptionalNone | OptionalSome | OptionalIsPresent | OptionalUnwrap | ListLiteral | MapLiteral | OrderedMapLiteral | ListIndexExpression | MapLookupExpression | CollectionSizeExpression | UnaryExpression | BinaryExpression | ConditionalExpression | CallExpression | EffectCallExpression | OwnedMoveExpression | OwnedBorrowExpression | MethodCallExpression | ReferenceConstruction | RecordConstruction | MemberRead | PrivateFieldRead | ErrorMessageRead} Expression */
 
 /**
  * @typedef LocalDeclaration

package/src/semantic/validate.js

@@ -2284,6 +2284,32 @@ function inferExpressionType(expression, scope, functions, records, fail, normal
     }
     return scalarType(signature.result)
   }
+  if (expression.kind == "ConditionalExpression") {
+    const conditionType = inferValueExpressionType(expression.condition, scope, functions, records, fail,
+      normalizeOperations, "a condition")
+
+    if (!isScalarType(conditionType, "boolean")) {
+      fail("NON_BOOLEAN_CONDITION", `Conditional expression condition type ${typeDescription(conditionType)}; expected boolean.`,
+        expression.condition.location)
+    }
+    const consequentScope = createScope(scope, [])
+    const alternateScope = createScope(scope, [])
+
+    applyPresenceNarrowing(expression.condition, scope, consequentScope, true)
+    applyPresenceNarrowing(expression.condition, scope, alternateScope, false)
+    const consequentType = inferValueExpressionType(expression.consequent, consequentScope, functions, records, fail,
+      normalizeOperations, "a conditional expression consequent")
+    const alternateType = inferValueExpressionType(expression.alternate, alternateScope, functions, records, fail,
+      normalizeOperations, "a conditional expression alternate")
+
+    if (!sameType(consequentType, alternateType)) {
+      fail("TYPE_MISMATCH", `Conditional expression arms ${typeDescription(consequentType)} and ${typeDescription(alternateType)}; expected one joined type.`,
+        expression.alternate.location)
+    }
+    Reflect.set(expression, "type", consequentType)
+
+    return consequentType
+  }
   if (expression.kind == "BinaryExpression") {
     const left = inferValueExpressionType(expression.left, scope, functions, records, fail, normalizeOperations, "a binary operand")
     const right = inferValueExpressionType(expression.right, scope, functions, records, fail, normalizeOperations, "a binary operand")

package/src/toolchains.js

@@ -21,9 +21,9 @@ export const canonicalToolchains = deepFreeze({
   javac: definition("javac", "SEMANTIFOLD_JAVAC", ["-version"], /^javac (?:1[7-9]|2[0-9])\./u),
   java: definition("java", "SEMANTIFOLD_JAVA", ["-version"], /^(?:openjdk|java) version "(?:1[7-9]|2[0-9])\./u),
   java25: definition("java", "SEMANTIFOLD_JAVA", ["-version"],
-    /^(?:openjdk version "25\.0\.4" 2026-07-21\nOpenJDK Runtime Environment \(build 25\.0\.4\+7-1-24\.04-Ubuntu\)\nOpenJDK 64-Bit Server VM \(build 25\.0\.4\+7-1-24\.04-Ubuntu, mixed mode, sharing\)|openjdk version "25\.0\.4\.1" 2026-08-18\nOpenJDK Runtime Environment \(build 25\.0\.4\.1\+1-1-26\.04\.4-Ubuntu\)\nOpenJDK 64-Bit Server VM \(build 25\.0\.4\.1\+1-1-26\.04\.4-Ubuntu, mixed mode, sharing\))$/u),
+    /^openjdk version "25\.0\.4\.1" 2026-08-18\nOpenJDK Runtime Environment \(build 25\.0\.4\.1\+1-1-(?:24\.04\.4|26\.04\.4)-Ubuntu\)\nOpenJDK 64-Bit Server VM \(build 25\.0\.4\.1\+1-1-(?:24\.04\.4|26\.04\.4)-Ubuntu, mixed mode, sharing\)$/u),
   kotlinc: definition("kotlinc", "SEMANTIFOLD_KOTLINC", ["-version"],
-    /^info: kotlinc-jvm 2\.4\.20 \(JRE (?:25\.0\.4\+7-1-24\.04|25\.0\.4\.1\+1-1-26\.04\.4)-Ubuntu\)$/u),
+    /^info: kotlinc-jvm 2\.4\.20 \(JRE 25\.0\.4\.1\+1-1-(?:24\.04\.4|26\.04\.4)-Ubuntu\)$/u),
   python: definition("python3", "SEMANTIFOLD_PYTHON", ["--version"], /^Python 3\./u),
   dotnet: definition("dotnet", "SEMANTIFOLD_DOTNET", ["--version"], /^10\./u),
   go: definition("go", "SEMANTIFOLD_GO", ["version"], /^go version go1\.26\.\d+ linux\/amd64$/u),