Fix NuGet restore on Ubuntu: skip MSBuildPath to avoid Mono/.NET SDK assembly loading issues

- Skip -MSBuildPath on non-Windows to prevent Mono from trying to load .NET SDK assemblies
- Add optional useDotnetRestore property (default: false) to opt-in to 'dotnet restore'
- Maintain backward compatibility: default behavior unchanged (uses nuget.exe with Mono)
- Fixes Ubuntu error: 'Can't find custom attr constructor' when Mono tries to load .NET 7.0 assemblies

Author: gamma

src/main/groovy/com/ullink/BaseNuGet.groovy

@@ -215,17 +215,90 @@ class BaseNuGet extends Exec {
         // Set deduplicated args
         setArgs(normalizedArgs)
 
-        if (isFamily(FAMILY_WINDOWS)) {
-            executable = localNuget.absolutePath
-        } else {
-            executable = "mono"
-            // Prepend nuget.exe path to args for mono execution
-            setArgs([localNuget.absolutePath] + normalizedArgs)
+        // Check if we should use dotnet restore instead of nuget.exe on non-Windows
+        // Only use dotnet restore if explicitly enabled via useDotnetRestore property
+        def useDotnetRestore = false
+        if (!isFamily(FAMILY_WINDOWS) && this instanceof NuGetRestore) {
+            try {
+                if (this.hasProperty('useDotnetRestore') && this.useDotnetRestore) {
+                    def dotnetPath = findDotnetPath()
+                    if (dotnetPath) {
+                        useDotnetRestore = true
+                    } else {
+                        project.logger.warn("useDotnetRestore is enabled but 'dotnet' command not found. Falling back to nuget.exe with Mono.")
+                    }
+                }
+            } catch (Exception e) {
+                project.logger.debug("Could not check useDotnetRestore property: ${e.message}")
+            }
+            
+            if (useDotnetRestore) {
+                executable = dotnetPath
+                // Convert nuget.exe restore args to dotnet restore args
+                def dotnetArgs = ['restore']
+                // Add solution file if present
+                if (this.hasProperty('solutionFile') && this.solutionFile) {
+                    def solutionPath = this.solutionFile instanceof File ? this.solutionFile.absolutePath : project.file(this.solutionFile).absolutePath
+                    dotnetArgs.add(solutionPath)
+                }
+                // Add packages.config file if present (dotnet restore doesn't support this directly, but we'll try)
+                if (this.hasProperty('packagesConfigFile') && this.packagesConfigFile) {
+                    project.logger.warn("packages.config files are not directly supported by 'dotnet restore'. Consider migrating to PackageReference format.")
+                }
+                // Add sources
+                if (this.hasProperty('sources') && !this.sources.isEmpty()) {
+                    this.sources.each { source ->
+                        dotnetArgs.add('--source')
+                        dotnetArgs.add(source)
+                    }
+                }
+                // Add config file
+                if (this.hasProperty('configFile') && this.configFile) {
+                    dotnetArgs.add('--configfile')
+                    dotnetArgs.add(this.configFile.absolutePath)
+                }
+                // Add packages directory
+                if (this.hasProperty('packagesDirectory') && this.packagesDirectory) {
+                    dotnetArgs.add('--packages')
+                    dotnetArgs.add(this.packagesDirectory)
+                }
+                // Add solution directory
+                if (this.hasProperty('solutionDirectory') && this.solutionDirectory) {
+                    dotnetArgs.add('--solution-directory')
+                    dotnetArgs.add(this.solutionDirectory.absolutePath)
+                }
+                // Disable parallel processing
+                if (this.hasProperty('disableParallelProcessing') && this.disableParallelProcessing) {
+                    dotnetArgs.add('--no-parallel')
+                }
+                setArgs(dotnetArgs)
+                project.logger.info("Using 'dotnet restore' instead of 'nuget.exe' (dotnet SDK detected)")
+            }
         }
 
-        // Add flags after setting the base args
-        args '-NonInteractive'
-        args '-Verbosity', (verbosity ?: getNugetVerbosity())
+        if (!useDotnetRestore) {
+            if (isFamily(FAMILY_WINDOWS)) {
+                executable = localNuget.absolutePath
+            } else {
+                executable = "mono"
+                // Prepend nuget.exe path to args for mono execution
+                setArgs([localNuget.absolutePath] + normalizedArgs)
+            }
+            
+            // Add nuget.exe-specific flags (not needed for dotnet restore)
+            args '-NonInteractive'
+            args '-Verbosity', (verbosity ?: getNugetVerbosity())
+        } else {
+            // For dotnet restore, add verbosity if needed (different format)
+            def verbosityLevel = verbosity ?: getNugetVerbosity()
+            if (verbosityLevel == 'detailed') {
+                args '--verbosity', 'detailed'
+            } else if (verbosityLevel == 'normal') {
+                args '--verbosity', 'normal'
+            } else if (verbosityLevel == 'quiet') {
+                args '--verbosity', 'quiet'
+            }
+        }
 
         project.logger.info("Final args before execution: ${getArgs().toList()}")
 
@@ -359,4 +432,20 @@ class BaseNuGet extends Exec {
         if (logger.infoEnabled) return 'normal'
         return 'quiet'
     }
+    
+    /**
+     * Find the dotnet executable path (for use with dotnet restore)
+     */
+    protected String findDotnetPath() {
+        try {
+            def process = ['which', 'dotnet'].execute()
+            process.waitFor()
+            if (process.exitValue() == 0) {
+                return process.text.trim()
+            }
+        } catch (Exception e) {
+            // dotnet not found
+        }
+        return null
+    }
 }

src/main/groovy/com/ullink/NuGetRestore.groovy

@@ -44,6 +44,8 @@ class NuGetRestore extends BaseNuGet {
     def packagesDirectory
     @Input
     def ignoreFailuresOnNonWindows = false
+    @Input
+    def useDotnetRestore = false  // Set to true to use 'dotnet restore' instead of 'nuget.exe' on non-Windows
 
     NuGetRestore() {
         super('restore')
@@ -106,38 +108,22 @@ class NuGetRestore extends BaseNuGet {
         if (solutionDirectory) args '-SolutionDirectory', solutionDirectory
         if (disableParallelProcessing) args '-DisableParallelProcessing'
 
-        // On non-Windows platforms, try to use modern .NET SDK's MSBuild if available
+        // On non-Windows platforms, skip MSBuildPath to avoid Mono/.NET SDK assembly loading issues
+        // When nuget.exe runs under Mono, it cannot load .NET SDK assemblies (e.g., .NET 7.0's Microsoft.Build.dll)
+        // So we skip -MSBuildPath on non-Windows to let NuGet use Mono's xbuild/MSBuild by default
         if (!isFamily(FAMILY_WINDOWS)) {
-            // If msBuildPath is not explicitly set, try to auto-detect dotnet SDK MSBuild
-            if (!msBuildPath) {
-                def dotnetPath = findDotnetPath()
-                if (dotnetPath) {
-                    def dotnetMsbuildPath = findDotnetMsbuildPath(dotnetPath)
-                    if (dotnetMsbuildPath) {
-                        msBuildPath = dotnetMsbuildPath
-                        project.logger.debug("Auto-detected dotnet MSBuild at: ${msBuildPath}")
-                    }
-                }
-            }
-            
-            // Use MSBuildPath if available (takes precedence over MSBuildVersion)
-            if (msBuildPath) {
-                args '-MSBuildPath', msBuildPath
-                project.logger.debug("Using MSBuildPath: ${msBuildPath}")
-            } else {
-                // Skip MSBuildVersion on non-Windows if no MSBuildPath found
-                // because Mono's xbuild/MSBuild doesn't work properly with NuGet restore
-                project.logger.debug("Skipping MSBuildVersion on non-Windows platform (no dotnet MSBuild found)")
-            }
+            // Skip MSBuildPath on non-Windows to avoid assembly loading errors
+            // If useDotnetRestore=true, BaseNuGet will use 'dotnet restore' which handles MSBuild automatically
+            project.logger.debug("Skipping MSBuildPath on non-Windows platform (NuGet will use Mono's xbuild/MSBuild)")
         } else {
             // On Windows, use MSBuildVersion as before
             if (!msBuildVersion) msBuildVersion = GradleHelper.getPropertyFromTask(project, 'version', 'msbuild')
             if (msBuildVersion) args '-MsBuildVersion', msBuildVersion
-        }
-        
-        // MSBuildPath can also be explicitly set on Windows
-        if (msBuildPath) {
-            args '-MSBuildPath', msBuildPath
+            
+            // MSBuildPath can also be explicitly set on Windows
+            if (msBuildPath) {
+                args '-MSBuildPath', msBuildPath
+            }
         }
 
         project.logger.info "Restoring NuGet packages " +
@@ -162,22 +148,6 @@ class NuGetRestore extends BaseNuGet {
         return new File(solutionDir ? solutionDir.toString() : '.', 'packages')
     }
 
-    /**
-     * Find the dotnet executable path
-     */
-    private String findDotnetPath() {
-        try {
-            def process = ['which', 'dotnet'].execute()
-            process.waitFor()
-            if (process.exitValue() == 0) {
-                return process.text.trim()
-            }
-        } catch (Exception e) {
-            // dotnet not found
-        }
-        return null
-    }
-    
     /**
      * Find the MSBuild.dll path in the dotnet SDK
      */