nCompile automated inclusion (optionally) of needed units

Author: perrydv

nCompiler/R/NC_Compile.R

@@ -46,6 +46,8 @@ nCompile_nClass <- function(NC,
     control
   )
   is_predefined <- !isFALSE(NCinternals(NC)$predefined)
+  gather_needed_units <- isTRUE(controlFull$always_include_units)
+  needed_units <- list()
   if(is_predefined) {
     predefined_dir <-  NCinternals(NC)$predefined
     # predefined can be character, quoted expression, or function.
@@ -63,6 +65,7 @@ nCompile_nClass <- function(NC,
        "It should give the directory path of the predefined nClass. ",
        "The classname argument to nClass gives the base for filenames in that directory.")
      regular_filename <-  NCinternals(NC)$cpp_classname
+     if(gather_needed_units) needed_units <- NCinternals(NC)$compileInfo$needed_units
   }
   if(is_predefined && isFALSE(controlFull$generate_predefined)) {
     RcppPacket <- loadRcppPacket(predefined_dir, regular_filename)
@@ -89,6 +92,10 @@ nCompile_nClass <- function(NC,
       # Now add interface calls if necessary for this live compilation, having
       # kept them out of the written packet code.
       cppDef$buildGenericInterface(interfaceCalls=TRUE, interface=FALSE)
+      # To do: check that there aren't any detected needed units that are not in the compileInfo$needed_units
+      # because for a predefined, needed units must be provided manually by compileInfo.
+    } else {
+      if(gather_needed_units) needed_units <- NC_Compiler$gather_needed_units()
     }
 
     ##
@@ -101,8 +108,10 @@ nCompile_nClass <- function(NC,
       return(NC_Compiler)
   }
 
-  if(stopAfterCppDef) return(cppDef)
-
+  if(stopAfterCppDef) {
+    if(gather_needed_units) return(list(cppDef = cppDef, needed_units = needed_units))
+    else return(cppDef)
+  }
   # We might deprecate from here onward.
   # Then nCompile_nClass would only be called via nCompile
   filebase <- controlFull$filename

nCompiler/R/NC_CompilerClass.R

@@ -115,6 +115,43 @@ NC_CompilerClass <- R6::R6Class(
                           NCgenerator)
         setupMethodSymbolTables()
       }
+    },
+    gather_needed_units = function() {
+      needed_nClasses1 <- nCompile_gather_needed_nClasses(cppDef, self$symbolTable)
+      needed_nClasses2 <- lapply(NFcompilers,
+                                  \(x) x$gather_needed_nClasses()) |> 
+                          unlist(recursive = FALSE) |> unique()
+      needed_nFunctions <- lapply(NFcompilers,
+                                  \(x) x$gather_needed_nFunctions()) |> 
+                           unlist(recursive = FALSE) |> unique()
+      list(
+        needed_nClasses = unique(c(needed_nClasses1, needed_nClasses2)),
+        needed_nFunctions = needed_nFunctions
+      )
     }
   )
 )
+
+nCompile_gather_needed_nClasses <- function(cppDef,
+                                            symTab,
+                                            NF_Compiler = NULL) {
+  # Collect nClass generators needed by this symbol table
+  new_needed <- list()
+  for(i in seq_along(symTab$symbols)) {
+    if(inherits(symTab$symbols[[i]], "symbolNC")) {
+      new_needed[[length(new_needed) + 1]] <-
+        symTab$symbols[[i]]$nClassGenerator
+    }
+  }
+  # For an nFunction, collection nClass generators identified
+  # from processing the code.
+  if(!is.null(NF_Compiler)) {
+    auxEnv_needed_nClasses <- NF_Compiler$auxEnv$needed_nClasses
+    if(length(auxEnv_needed_nClasses)) {
+      bool_NCgen <- lapply(auxEnv_needed_nClasses, isNCgenerator) |> unlist()
+      new_needed <- c(new_needed,
+                      auxEnv_needed_nClasses[bool_NCgen])
+    }
+  }
+  unique(new_needed)
+}

nCompiler/R/NF_Compile.R

@@ -58,6 +58,8 @@ nCompile_nFunction <- function(NF,
   if(is.null(compileInfo)) compileInfo <- NFinternals(NF)$compileInfo
 
   is_predefined <- !isFALSE(NFinternals(NF)$predefined)
+  gather_needed_units <- isTRUE(controlFull$always_include_units)
+  needed_units <- list()
   if(is_predefined) {
     predefined_dir <-  NFinternals(NF)$predefined
     # predefined can be character, quoted expression, or function.
@@ -75,6 +77,7 @@ nCompile_nFunction <- function(NF,
        "It should give the directory path of the predefined nFunction. ",
        "The name argument to nFunction gives the base for filenames in that directory.")
     regular_filename <-  NFinternals(NF)$cpp_code_name
+    if(gather_needed_units) needed_units <- NFinternals(NF)$compileInfo$needed_units
   }
   if(is_predefined && isFALSE(controlFull$generate_predefined)) {
     RcppPacket <- loadRcppPacket(predefined_dir, regular_filename)
@@ -98,6 +101,8 @@ nCompile_nFunction <- function(NF,
         predefined_gen_dir <- predefined_dir
       RcppPacket <- cppDefs_2_RcppPacket(NF_Compiler$cppDef)
       saveRcppPacket(RcppPacket, predefined_dir, regular_filename)
+    } else {
+      if(gather_needed_units) needed_units <- NF_Compiler$gather_needed_units()
     }
     stageName <- 'makeRcppPacket'
     if (logging) logBeforeStage(stageName)
@@ -106,8 +111,10 @@ nCompile_nFunction <- function(NF,
 
     cppDef <- NF_Compiler$cppDef
   }
-  if(stopAfterCppDef) return(cppDef)
-
+  if(stopAfterCppDef) {
+    if(gather_needed_units) return(list(needed_units = needed_units, cppDef = cppDef))
+    else return(cppDef)
+  }
   # We might deprecate from here down and make all usages start from nCompile.
 
   stop("Entering deprecated portion of nCompile_nFunction. Check what is going on.")

nCompiler/R/NF_CompilerClass.R

@@ -139,10 +139,29 @@ NF_CompilerClass <- R6::R6Class(
                       doKeywords,
                       .nCompilerProject,
                       initialTypeInferenceOnly)
+    },
+    gather_needed_units = function() {
+      list(
+        needed_nClasses = self$gather_needed_nClasses(),
+        needed_nFunctions = self$gather_needed_nFunctions()
+      )
+    },
+    gather_needed_nClasses = function() {
+      nCompile_gather_needed_nClasses(cppDef, self$symbolTable, self)
+    },
+    gather_needed_nFunctions = function() {
+      nCompile_gather_needed_nFunctions(cppDef, self$symbolTable)
     }
   )
 )
 
+nCompile_gather_needed_nFunctions <- function(cppDef,
+                                              NF_Compiler) {
+  lapply(NF_Compiler$auxEnv$needed_nFunctions,
+         function(x)
+           nGet(x[[1]], where = x[[2]])) |> unique()
+}
+
 processNFstages <- function(NFcompiler,
                             control = list(),
                             sourceObj = NULL,

nCompiler/R/cppDefs_nFunction.R

@@ -199,7 +199,7 @@ cpp_include_needed_nClasses <- function(cppDef,
     }
   }
   new_Hincludes <- unique(new_Hincludes)  
-  cppDef$Hincludes <- c(cppDef$Hincludes, new_Hincludes)
+  cppDef$Hincludes <- unique(c(cppDef$Hincludes, new_Hincludes))
   invisible(NULL)
 }