fix: classes with only embedded python files are now covered

Turns out there's no .INT routine generated for .CLS files with only embedded python,
which means that we can no longer piggyback finding out which python files to track
by using the .CLS files. I now keep track of relevant and new python coverage targets separately

Author: isc-cge

cls/TestCoverage/Manager.cls

@@ -66,6 +66,10 @@ Property Run As TestCoverage.Data.Run;
 /// Value at subscript is set to 1 if there are executable lines of code in the target, 0 if not.
 Property KnownCoverageTargets [ MultiDimensional, Private ];
 
+/// Known python coverage targets (already snapshotted). <br />
+/// Value at subscript is set to 1 if there are executable lines of code in the target, 0 if not.
+Property KnownPyCoverageTargets [ MultiDimensional, Private ];
+
 /// Cache of (name, type) -> hash
 Property Hashes [ MultiDimensional ];
 
@@ -229,34 +233,35 @@ Method StartCoverageTracking() As %Status [ Private ]
 	Set tSC = $$$OK
 	New $Namespace
 	Try {
-		If (..CoverageTargets '= "") {
+		If ((..CoverageTargets '= "" ) || (..PyCoverageTargets '= "")) {
 			Set $Namespace = ..SourceNamespace
 			Set tRelevantTargets = ""
-			Set tPyRelevantTargets = ""
 			Set tNewTargets = ""
 			Set tPointer = 0
 			While $ListNext(..CoverageTargets,tPointer,tCoverageTarget) {
 				If '$Data(..KnownCoverageTargets(tCoverageTarget),tIsRelevant)#2 {
 					Set tNewTargets = tNewTargets_$ListBuild(tCoverageTarget)
 				} ElseIf tIsRelevant {
 					Set tRelevantTargets = tRelevantTargets_$ListBuild(tCoverageTarget)
-					// check if the relevant old targets have python components
-					Set tOther = ##class(%Library.RoutineMgr).GetOther(tCoverageTarget,"INT",-1)
-					If (tOther '= "") && ($Piece(tOther,".",*) = "CLS") {
-						set tName = $piece(tOther, ".", 1, *-1)
-						If (..HasPython(tName)) {
-							set tPyRelevantTargets = tPyRelevantTargets _ $ListBuild(tName)
-						}
-					}
+				}
+			}
+
+			Set tPyRelevantTargets = ""
+			Set tNewPyTargets = ""
+			Set tPointer = 0
+			While $ListNext(..PyCoverageTargets,tPointer,tPyCoverageTarget) {
+				If '$Data(..KnownPyCoverageTargets(tPyCoverageTarget),tIsRelevant)#2 {
+					Set tNewPyTargets = tNewPyTargets_$ListBuild(tPyCoverageTarget)
+				} ElseIf tIsRelevant {
+					Set tPyRelevantTargets = tPyRelevantTargets_$ListBuild(tPyCoverageTarget)
 				}
 			}
 
-			If (tNewTargets '= "") {
+			If ((tNewTargets '= "") || (tNewPyTargets '= "")) {
 				$$$StartTimer("Taking snapshot of code and CLS/MAC/INT mappings")
-				Set tSC = ##class(TestCoverage.Utils).Snapshot(tNewTargets, .tNewRelevantTargets, .tNewPyRelevantTargets)
+				Set tSC = ##class(TestCoverage.Utils).Snapshot(tNewTargets, tNewPyTargets, .tNewRelevantTargets, .tNewPyRelevantTargets)
 				$$$StopTimer
 				$$$ThrowOnError(tSC)
-			
 				Set tPointer = 0
 				While $ListNext(tNewTargets,tPointer,tNewTarget) {
 					Set ..KnownCoverageTargets(tNewTarget) = 0
@@ -268,13 +273,19 @@ Method StartCoverageTracking() As %Status [ Private ]
 					Set tRelevantTargets = tRelevantTargets_$ListBuild(tRelevantTarget)
 				}
 
+				Set tPointer = 0
+				While $ListNext(tNewPyTargets,tPointer,tNewPyTarget) {
+					Set ..KnownPyCoverageTargets(tNewPyTarget) = 0
+				}
+
 				Set tPointer = 0
 				While $ListNext(tNewPyRelevantTargets,tPointer,tPyRelevantTarget) {
+					Set ..KnownPyCoverageTargets(tPyRelevantTarget) = 1
 					Set tPyRelevantTargets = tPyRelevantTargets_$ListBuild(tPyRelevantTarget)
 				}
 			}
 
-			If (tRelevantTargets = "") {
+			If ((tRelevantTargets = "") && (tPyRelevantTargets = "")) {
 				Write !,"WARNING: Nothing found to monitor for routine(s): "_$ListToString(tNewTargets)
 			}
 
@@ -374,7 +385,6 @@ Method UpdateCoverageTargetsForTestDirectory(pDirectory As %String) As %Status [
 				}
 			}
 		}
-		
 		Set tObjectCodeList = ..GetObjectCodeForSourceNames(tCoverageTargetList)
 		Set ..CoverageTargets = tObjectCodeList // Also restarts the monitor if it is running and updates data on covered routines/classes
 		Set ..PyCoverageTargets = tPyCoverageTargetList // no need to get the compiled names, it's already correct 
@@ -512,7 +522,7 @@ Method EndCoverageTracking(pTestSuite As %String = "", pTestClass As %String = "
 {
 	Set tSC = $$$OK
 	Try {
-		If (..CoverageTargets '= "") {
+		If ((..CoverageTargets '= "") || (..PyCoverageTargets '= "")) {
 			// Pause the monitor.
 			Set tSC = ..Monitor.Pause()
 			Do ##class(TestCoverage.Utils.LineByLineMonitor).PyStop()

cls/TestCoverage/Utils.cls

@@ -78,7 +78,7 @@ ClassMethod GetTestCoverageTableList() As %List
 /// This is parallelized using <class>%SYSTEM.WorkMgr</class> for better performance. <br />
 /// <var>pRelevantRoutines</var> is a $ListBuild list of .INT routines that map back to a .CLS or .MAC
 /// routine with at least one executable line.
-ClassMethod Snapshot(pIntRoutines As %List, Output pRelevantRoutines As %List = "", Output pPyRelevantRoutines As %List = "") As %Status
+ClassMethod Snapshot(pIntRoutines As %List, pPyRoutines As %List, Output pRelevantRoutines As %List = "", Output pPyRelevantRoutines As %List = "") As %Status
 {
 	Set tSC = $$$OK
 	Try {
@@ -96,6 +96,7 @@ ClassMethod Snapshot(pIntRoutines As %List, Output pRelevantRoutines As %List =
 		$$$ThrowOnError(tSC)
 
 
+
 		// See which routines are actually relevant (one or more lines mapping back to a class with 1 or more executable lines)
 		// There's no point in optimizing out .MAC routines; they'll always have code
 		Set tPointer = 0
@@ -106,17 +107,26 @@ ClassMethod Snapshot(pIntRoutines As %List, Output pRelevantRoutines As %List =
 				// This also snapshots the compiled python routine with it if there is one
 				#dim tCodeUnit As TestCoverage.Data.CodeUnit
 				Set tSC = ##class(TestCoverage.Data.CodeUnit).GetCurrentByName(tOther,,.tCodeUnit)
+				
 				If $$$ISERR(tSC) {
 					Continue // Non-fatal. Just skip it.
 				}
 				Set tName = tCodeUnit.Name // should be the same as tOther without the .cls, but if I have it already why not
+				Set SnapshottedClasses(tName) = 1
 				If ##class(TestCoverage.Manager).HasPython(tName) {
-					set pPyRelevantRoutines = pPyRelevantRoutines _ $ListBuild(tName)
 					// take a snapshot of the compiled python file 
 					$$$ThrowOnError(##class(TestCoverage.Data.CodeUnit).GetCurrentByName(tName_".PY",,.tPyCodeUnit))
 
 					// update the executable lines for the .cls file's python
 					$$$ThrowOnError(tCodeUnit.UpdatePyExecutableLines(tName, .tPyCodeUnit))
+
+					// update the relevant python routines
+					If ($BitCount(tPyCodeUnit.ExecutableLines, 1)) {
+						set pPyRelevantRoutines = pPyRelevantRoutines _ $ListBuild(tName)
+					} ElseIf '$BitCount(tCodeUnit.ExecutableLines,1) {
+						// if there's no executable python and no executable objectscript, skip it 
+						Continue
+					}
 
 				} ElseIf '$BitCount(tCodeUnit.ExecutableLines,1) {
 					// Skip it - no executable lines.
@@ -127,6 +137,21 @@ ClassMethod Snapshot(pIntRoutines As %List, Output pRelevantRoutines As %List =
 			Set pRelevantRoutines = pRelevantRoutines _ $ListBuild(tIntRoutine)
 		}
 
+		// Snapshot all the python routines and their corresponding classes that haven't already been snapshotted 
+		Set tPointer = 0
+		While $ListNext(pPyRoutines, tPointer, tPyRoutine) {
+			If ('$Data(SnapshottedClasses(tPyRoutine))) {
+				$$$ThrowOnError(##class(TestCoverage.Data.CodeUnit).GetCurrentByName(tPyRoutine_".CLS",,.tCodeUnit))
+				$$$ThrowOnError(##class(TestCoverage.Data.CodeUnit).GetCurrentByName(tPyRoutine_".PY",,.tPyCodeUnit))
+				$$$ThrowOnError(tCodeUnit.UpdatePyExecutableLines(tPyRoutine, .tPyCodeUnit))
+				
+				If ($BitCount(tPyCodeUnit.ExecutableLines, 1)) {
+					set pPyRelevantRoutines = pPyRelevantRoutines _ $ListBuild(tPyRoutine)
+				}
+				Set SnapshottedClasses(tPyRoutine) = 1
+			}
+		}
+
 		Write !
 	} Catch e {
 		Set tSC = e.AsStatus()