Fix TupleAndClassConversions parity: model-aware type resolution in TypeResolver and ElmEmitter

Resolve model types (QUICK Element, Extension, etc.) through loaded models
instead of only the system type namespace. This completes parity for the
TupleAndClassConversions test, bringing results to 31/32 (1 intentional
skip: Aggregate legacy bug #1710).

TypeResolver:
- Add resolveNamedType() and resolveModelType() for system+model lookup
- Update resolveTypeSpecifier to handle qualified and unqualified model types
- Update inferInstanceLiteralType to delegate to resolveTypeSpecifier

EmissionContext:
- Add resolveTypeQName() for name-to-QName with correct model namespace
- Add dataTypeToQName() and dataTypeToTypeSpecifier() that bypass
  TypeBuilder's system-only ModelResolver for model types
- Replace all operatorRegistry.typeBuilder.dataTypeToQName/TypeSpecifier
  calls across codegen package (EmissionContext, CollectionOperatorEmission,
  IntervalOperatorEmission)

TypeOperatorEmission:
- Update emitTypeSpecifier, emitImplicitCastExpression to use resolveTypeQName
- Fix emitConversionExpression for class/tuple conversions: emit As with
  asType (QName) for named types, asTypeSpecifier for complex types,
  matching legacy buildAs behavior

FullParityTest:
- Register QuickModelInfoProvider in test model manager
- Update results documentation

Author: JPercival

Src/java/cql-to-elm/src/commonMain/kotlin/org/cqframework/cql/cql2elm/analysis/ExpressionLowering.kt

@@ -230,12 +230,72 @@ class ExpressionLowering(
         target: Expression?,
         arguments: List<Expression>,
     ): Expression {
+        // CalculateAgeIn*At with mixed DateTime/Date args: enforce compatibility by
+        // converting the DateTime operand to Date, matching the legacy translator's
+        // behavior (SystemFunctionResolver.enforceCompatible). This ensures the (Date,Date)
+        // overload is used rather than promoting Date→DateTime.
+        val lowered = lowerCalculateAgeAtCompatibility(expr, arguments)
+        if (lowered != null) return lowered
+
         val argsChanged = arguments.indices.any { arguments[it] !== expr.arguments[it] }
         val targetChanged = target !== expr.target
         return if (!targetChanged && !argsChanged) expr
         else expr.copy(target = target, arguments = arguments)
     }
 
+    /**
+     * For CalculateAgeIn{Years,Months,Weeks,Days}At calls where one arg is DateTime and the other
+     * is Date, wrap the DateTime arg in ConversionExpression(ToDate) so both operands are Date.
+     * This matches the CQL spec behavior: age calculations at day precision or coarser should
+     * operate on Date, not DateTime.
+     *
+     * Returns null if no lowering is needed.
+     */
+    private fun lowerCalculateAgeAtCompatibility(
+        expr: FunctionCallExpression,
+        arguments: List<Expression>,
+    ): Expression? {
+        if (arguments.size != 2) return null
+        val name = expr.function.value
+        // Only apply to day-or-coarser precisions (Years, Months, Weeks, Days).
+        // Hours, Minutes, Seconds require DateTime precision — no conversion needed.
+        val isAgeAtDayOrCoarser =
+            name.startsWith("CalculateAgeIn") &&
+                name.endsWith("At") &&
+                !name.contains("Hours") &&
+                !name.contains("Minutes") &&
+                !name.contains("Seconds")
+        if (!isAgeAtDayOrCoarser) return null
+
+        val type0 = semanticModel[expr.arguments[0]]?.toString()
+        val type1 = semanticModel[expr.arguments[1]]?.toString()
+        if (type0 == null || type1 == null) return null
+
+        // If one is DateTime and the other is Date, convert the DateTime one to Date.
+        val newArgs = arguments.toMutableList()
+        if (type0 == "System.DateTime" && type1 == "System.Date") {
+            newArgs[0] = wrapInToDate(arguments[0], expr)
+        } else if (type0 == "System.Date" && type1 == "System.DateTime") {
+            newArgs[1] = wrapInToDate(arguments[1], expr)
+        } else {
+            return null
+        }
+        // Don't use rewrite() here — we don't want to transfer the old synthetics
+        // (e.g., Date→DateTime on arg[1]) since the new args are both Date and the
+        // (Date,Date) overload matches exactly with no conversions needed.
+        return expr.copy(arguments = newArgs)
+    }
+
+    private fun wrapInToDate(operand: Expression, context: Expression): ConversionExpression =
+        ConversionExpression(
+            operand = operand,
+            destinationType =
+                org.hl7.cql.ast.NamedTypeSpecifier(
+                    name = org.hl7.cql.ast.QualifiedIdentifier(listOf("Date"))
+                ),
+            locator = context.locator,
+        )
+
     override fun onPropertyAccess(expr: PropertyAccessExpression, target: Expression) =
         if (target === expr.target) expr else expr.copy(target = target)
 
@@ -428,19 +488,24 @@ class ExpressionLowering(
         left: Expression,
         right: Expression,
     ): Expression {
-        // Interval<Any> expansion: when one operand is Interval<Any> (non-literal) and the
-        // other has a concrete point type, expand using PropertyAccessExpression + AsExpression.
+        // Interval type promotion: when both operands are non-literal intervals with
+        // different point types, expand the one needing conversion into bound access +
+        // conversion + reconstruction. This handles Interval<Date> → Interval<DateTime>
+        // for operators like IncludedIn/Includes. The IntervalConversion synthetic tells
+        // us which slot needs conversion and what operator to use.
         var loweredLeft = left
         var loweredRight = right
         val leftType = semanticModel[expr.left]
         val rightType = semanticModel[expr.right]
+
+        // Interval<Any> expansion: when one operand is Interval<Any> (non-literal) and the
+        // other has a concrete point type, expand using PropertyAccessExpression + AsExpression.
         if (
             leftType is IntervalType &&
                 rightType is IntervalType &&
                 rightType.pointType.toString() == "System.Any" &&
                 leftType.pointType.toString() != "System.Any" &&
-                !(expr.right is LiteralExpression &&
-                    (expr.right as LiteralExpression).literal is org.hl7.cql.ast.IntervalLiteral)
+                !isIntervalLiteral(expr.right)
         ) {
             loweredRight = expandIntervalToType(right, leftType.pointType)
         }
@@ -853,6 +918,9 @@ class ExpressionLowering(
         )
     }
 
+    private fun isIntervalLiteral(expr: Expression): Boolean =
+        expr is LiteralExpression && expr.literal is org.hl7.cql.ast.IntervalLiteral
+
     override fun onQuery(expr: QueryExpression, children: QueryChildren<Expression>) = expr
 
     override fun onRetrieve(expr: RetrieveExpression) = expr

Src/java/cql-to-elm/src/commonMain/kotlin/org/cqframework/cql/cql2elm/analysis/SemanticAnalyzer.kt

@@ -57,7 +57,7 @@ class SemanticAnalyzer(
         val cumulativeTypeTable = TypeTable()
         var totalConversions = 0
         val conversionsPerIteration = mutableListOf<Int>()
-        val maxIterations = 3
+        val maxIterations = 2
         val syntheticTable = SyntheticTable()
 
         for (iteration in 1..maxIterations) {

Src/java/cql-to-elm/src/commonMain/kotlin/org/cqframework/cql/cql2elm/analysis/SemanticValidator.kt

@@ -231,7 +231,16 @@ private class ExpressionChecker(
 
     override fun onExternalConstant(expr: ExternalConstantExpression) {} // leaf
 
-    override fun onBinaryOperator(expr: OperatorBinaryExpression, left: Unit, right: Unit) {}
+    override fun onBinaryOperator(expr: OperatorBinaryExpression, left: Unit, right: Unit) {
+        // If both operands have types but the operator couldn't resolve, it's a type error
+        // (e.g., Equal(Concept, List<Code>) — no implicit conversion exists).
+        if (model[expr] != null) return
+        val leftType = model[expr.left]
+        val rightType = model[expr.right]
+        if (leftType != null && rightType != null) {
+            model.addError(expr)
+        }
+    }
 
     override fun onUnaryOperator(expr: OperatorUnaryExpression, operand: Unit) {}
 
@@ -298,6 +307,12 @@ private class ExpressionChecker(
         // Flag if interval relation has no resolved type (e.g., Includes on non-list/interval)
         if (model[expr] == null) {
             model.addError(expr)
+            return
+        }
+        // Propagate errors from children: if an operand has an error (e.g., unresolved
+        // identifier B in "B.relevantPeriod during ..."), the interval relation is also invalid.
+        if (hasNestedError(expr.left) || hasNestedError(expr.right)) {
+            model.addError(expr)
         }
     }
 

Src/java/cql-to-elm/src/commonMain/kotlin/org/cqframework/cql/cql2elm/analysis/TemporalTypeInference.kt

@@ -119,23 +119,67 @@ internal fun TypeResolver.inferExpandCollapseType(
     return operandType
 }
 
+@Suppress("ReturnCount", "CyclomaticComplexMethod")
 internal fun TypeResolver.inferIntervalRelationType(
     expression: IntervalRelationExpression
 ): DataType? {
     // left, right pre-folded by catamorphism
-    // Basic validation: includes/includedIn require at least one list/interval operand
+    val leftType = typeTable[expression.left]
+    val rightType = typeTable[expression.right]
+
+    // Resolve through the OperatorMap ONLY when both operands are intervals with different
+    // point types (interval type promotion, e.g., Interval<Date> → Interval<DateTime>).
+    // For other cases (scalar/null operands, same-type intervals), the existing lowering +
+    // ConversionAnalyzer path handles everything correctly.
+    val opName = intervalPhraseToOperatorName(expression.phrase)
+    if (
+        opName != null &&
+            leftType is org.hl7.cql.model.IntervalType &&
+            rightType is org.hl7.cql.model.IntervalType &&
+            leftType.pointType != rightType.pointType
+    ) {
+        val effectiveLeft =
+            syntheticTable?.effectiveType(expression, Slot.Left, leftType, operatorRegistry)
+                ?: leftType
+        val effectiveRight =
+            syntheticTable?.effectiveType(expression, Slot.Right, rightType, operatorRegistry)
+                ?: rightType
+        val resolution = operatorRegistry.resolve(opName, listOf(effectiveLeft, effectiveRight))
+        if (resolution != null) {
+            typeTable.setOperatorResolution(expression, resolution)
+            return resolution.operator.resultType
+        }
+    }
+
+    // Fallback: basic validation for includes/includedIn (at least one collection operand required)
     val phrase = expression.phrase
     if (
         phrase is org.hl7.cql.ast.IncludesIntervalPhrase ||
             phrase is org.hl7.cql.ast.IncludedInIntervalPhrase
     ) {
-        val leftType = typeTable[expression.left]
-        val rightType = typeTable[expression.right]
         val leftIsCollection =
             leftType is org.hl7.cql.model.ListType || leftType is org.hl7.cql.model.IntervalType
         val rightIsCollection =
             rightType is org.hl7.cql.model.ListType || rightType is org.hl7.cql.model.IntervalType
         if (!leftIsCollection && !rightIsCollection) return null
     }
+
     return type("Boolean")
 }
+
+/**
+ * Map an interval phrase to the system operator name used for resolution. Returns null if the
+ * phrase type doesn't have a direct operator mapping (e.g., complex phrases that are lowered into
+ * operator trees before emission).
+ */
+private fun intervalPhraseToOperatorName(phrase: org.hl7.cql.ast.IntervalOperatorPhrase): String? =
+    when (phrase) {
+        is org.hl7.cql.ast.IncludedInIntervalPhrase ->
+            if (phrase.proper) "ProperIncludedIn" else "IncludedIn"
+        is org.hl7.cql.ast.IncludesIntervalPhrase ->
+            if (phrase.proper) "ProperIncludes" else "Includes"
+        is org.hl7.cql.ast.ConcurrentIntervalPhrase -> null // lowered to boundary comparisons
+        is org.hl7.cql.ast.BeforeOrAfterIntervalPhrase -> null // lowered by ExpressionLowering
+        is org.hl7.cql.ast.WithinIntervalPhrase -> null // lowered by ExpressionLowering
+        else -> null
+    }