feat: add model type resolution to TypeResolver for context and property types

- TypeResolver: resolve context identifiers (e.g., "Patient") to their
  model ClassType, and resolve property access on model types (e.g.,
  Patient.birthDatetime → System.DateTime)
- SemanticAnalyzer: add ToDate wrapping in AgeIn desugarer for
  Year/Month precision (CQL spec requires Date precision)
- AgeOperators still skipped: ConversionExpression from desugaring emits
  incorrectly — ToDate wrapper disappears during emission. Needs
  investigation.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: JPercival

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

@@ -62,7 +62,7 @@ class SemanticAnalyzer(
 
         for (iteration in 1..maxIterations) {
             // INFER: type resolution + overload resolution (reads synthetics for effective types)
-            val resolver = TypeResolver(operatorRegistry, syntheticTable)
+            val resolver = TypeResolver(operatorRegistry, syntheticTable, modelManager)
             val iterationTypeTable = resolver.resolve(desugared, symbols)
 
             // Merge this iteration's results into the cumulative table.
@@ -178,8 +178,24 @@ private class AgeInDesugarer(private val birthDatePropertyName: String) :
         if (!isAt && args.isNotEmpty()) return super.visitFunctionCallExpression(expression)
         if (isAt && args.size != 1) return super.visitFunctionCallExpression(expression)
 
-        val birthDateExpr = buildBirthDateExpr(expression)
-        val calculateName = "CalculateAgeIn${name.removePrefix("AgeIn")}"
+        var birthDateExpr: org.hl7.cql.ast.Expression = buildBirthDateExpr(expression)
+        val suffix = name.removePrefix("AgeIn")
+        val calculateName = "CalculateAgeIn$suffix"
+
+        // CQL spec: AgeIn(Years|Months)() operates on Date precision.
+        // Wrap birthDate (DateTime) in ToDate for Year/Month 0-arg calls.
+        if (!isAt && (suffix == "Years" || suffix == "Months")) {
+            birthDateExpr =
+                org.hl7.cql.ast.ConversionExpression(
+                    operand = birthDateExpr,
+                    destinationType =
+                        org.hl7.cql.ast.NamedTypeSpecifier(
+                            name = org.hl7.cql.ast.QualifiedIdentifier(listOf("Date"))
+                        ),
+                    locator = expression.locator,
+                )
+        }
+
         val visitedArgs = args.map { visitExpression(it) }
         val newArgs = listOf(birthDateExpr) + visitedArgs
 

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

@@ -2,6 +2,7 @@
 
 package org.cqframework.cql.cql2elm.analysis
 
+import org.cqframework.cql.cql2elm.ModelManager
 import org.cqframework.cql.cql2elm.model.Conversion
 import org.cqframework.cql.cql2elm.model.OperatorResolution
 import org.hl7.cql.ast.AsExpression
@@ -82,6 +83,7 @@ import org.hl7.cql.model.TupleTypeElement
 class TypeResolver(
     internal val operatorRegistry: OperatorRegistry,
     private val syntheticTable: SyntheticTable? = null,
+    private val modelManager: ModelManager? = null,
 ) : ExpressionFold<DataType?> {
 
     /** Tracks expression definitions currently being resolved to detect circular references. */
@@ -294,8 +296,8 @@ class TypeResolver(
     ): DataType? = inferFunctionCallType(expr, arguments)
 
     override fun onPropertyAccess(expr: PropertyAccessExpression, target: DataType?): DataType? {
-        // Target already pre-folded (identifiers within resolved); nothing more to do
-        return null
+        if (target == null) return null
+        return resolvePropertyType(target, expr.property.value)
     }
 
     override fun onIndex(expr: IndexExpression, target: DataType?, index: DataType?): DataType? =
@@ -417,7 +419,7 @@ class TypeResolver(
         // referencing the context name should resolve as expression references.
         symbolTable.resolveContext(name)?.let { resolution ->
             typeTable.setIdentifierResolution(expression, resolution)
-            return null // Type unknown at analysis time (model-dependent)
+            return resolveContextType(name)
         }
 
         // Check parameter definitions
@@ -840,4 +842,47 @@ class TypeResolver(
         typeTable.setOperatorResolution(expression, resolution)
         return resolution.operator.resultType
     }
+
+    /** Resolve the type of a context identifier (e.g., "Patient") from the loaded models. */
+    private fun resolveContextType(contextName: String): DataType? {
+        val mm = modelManager ?: return null
+        for (usingDef in symbolTable.usingDefinitions) {
+            if (usingDef.modelIdentifier.simpleName == "System") continue
+            val model =
+                try {
+                    mm.resolveModel(usingDef.modelIdentifier.simpleName, usingDef.version?.value)
+                } catch (_: Exception) {
+                    continue
+                }
+            val ctx = model.resolveContextName(contextName, mustResolve = false)
+            if (ctx != null) return ctx.type
+        }
+        return null
+    }
+
+    /** Resolve the type of a property on a source type (e.g., "birthDatetime" on QDM.Patient). */
+    private fun resolvePropertyType(sourceType: DataType, propertyName: String): DataType? {
+        if (sourceType is org.hl7.cql.model.ClassType) {
+            // Search elements including inherited ones
+            var current: DataType? = sourceType
+            while (current is org.hl7.cql.model.ClassType) {
+                val element = current.elements.firstOrNull { it.name == propertyName }
+                if (element != null) return element.type
+                current = current.baseType
+            }
+        }
+        if (sourceType is org.hl7.cql.model.IntervalType) {
+            return when (propertyName) {
+                "low",
+                "high" -> sourceType.pointType
+                "lowClosed",
+                "highClosed" -> operatorRegistry.type("Boolean")
+                else -> null
+            }
+        }
+        if (sourceType is org.hl7.cql.model.TupleType) {
+            return sourceType.elements.firstOrNull { it.name == propertyName }?.type
+        }
+        return null
+    }
 }

Src/java/cql-to-elm/src/jvmTest/kotlin/org/cqframework/cql/cql2elm/codegen/FullParityTest.kt

@@ -214,11 +214,11 @@ class FullParityTest {
                     "Code→Concept conversion (ToConcept) and CodesToConcept error recovery",
                 // Name hiding: QDM model interval resolution and out-of-scope error recovery
                 "NameHiding" to "QDM interval resolution and out-of-scope error recovery",
-                // AgeOperators: desugaring works (AgeIn*→CalculateAgeIn* with birthDate injection)
-                // but TypeResolver can't resolve model property types (Patient.birthDatetime)
-                // so operator resolution doesn't discover the DateTime→Date conversion.
+                // AgeOperators: desugared before loop + model type resolution working, but
+                // ConversionExpression (ToDate) in desugared AST not emitting — needs
+                // investigation.
                 "AgeOperators" to
-                    "TypeResolver needs model type resolution for Patient.birthDatetime",
+                    "ConversionExpression(ToDate) from desugaring not emitting correctly",
                 // Terminology: legacy resolves retrieve code properties and function references
                 "TerminologyReferences" to
                     "Retrieve code properties and terminology function resolution",