Using preprocessor directives with Roslyn / SourceCodeKind.Regular

[mo-russo]

Hello,

We used to be a able to do the following when our scripts where targeting .Net Framework 4:

//css_precompiler ../precompilers/plugin_precompiler

And inside plugin_precompiler, do something like this:

public class Plugin_Precompiler
{
    public static bool Compile(ref string code, string scriptFile, bool isPrimaryScript, Hashtable context)
    {
       code = "#define MY_DEFINE" + System.Environment.NewLine + code
       return true;
    }
}

And this worked pretty well. It also supported imports.

Now that we moved to .NET 9 and using CSScriptLib with the Roslyn evaluator, this functionnality does not seem to work anymore. We looked into trying to pass the defines via some options, we couldn't find anything. The closest we found was some commented out code Evaluator.Roslyn.cs with the following comment: "unfortunately the next code block will not work. Roslyn scripting fails to create compilation if ParseOptions are set".

We tried injecting the #define at the top of the script file. It works, but as soon as there are imports that use said define, the compilation fails:
CSScriptLib.CompilerException: <script>(1,2): error CS1032: Cannot define/undefine preprocessor symbols after first token in file.

We're out of ideas on how to solve this issue. Anyone knows how this can be solved?

[oleg-shilo]

Good news. I found teh way to pass global preprocessorSymbols with SourceCodeKind.Script. See

cs-script/src/Tests.CSScriptLib/Evaluator.Roslyn.Tests.cs

Lines 448 to 466 in 0bc0924

	CSScript.EvaluatorConfig.CompilerOptions = "-define:test";
	dynamic util2 = CSScript.Evaluator
	.With(e => e.DebugBuild = true)
	.LoadCode(@"using System;
	using System.Diagnostics;
	public class Util
	{
	public string foo()
	{
	#if test
	return ""test"";
	#else
	return ""not-test"";
	#endif
	}
	}");
	var result2 = util2.foo();
	Assert.Equal("test", result);

Will update the API and release within a few days or so.

[mo-russo]

Good news. I found teh way to pass global preprocessorSymbols with SourceCodeKind.Script. See

Will update the API and release within a few days or so.

Good news indeed! Thanks @oleg-shilo !

[oleg-shilo]

Done. Please check new Release v4.14.0

[mo-russo]

@oleg-shilo it does not seem to be working on my side using CSScript.Evaluator.CompileAssemblyFromFile.

public class Script
{
    public void Execute()
    {
		#if MY_DEFINE
        System.Windows.MessageBox.Show("Hello!");
		#else
        System.Windows.MessageBox.Show("Sad :(");
		#endif
    }
}

The script is read from a .cs file, then we create, load and execute an assembly like so:

    CSScript.EvaluatorConfig.CompilerOptions = "/d:MY_DEFINE";
    var commandAssemblyPath = CSScript.Evaluator.CompileAssemblyFromFile(_commandFile, scriptDllOutputPath);
    var assembly = Assembly.LoadFrom(commandAssemblyPath);
    // use reflection to create an instance of the Script class and call its Execute method.

Debugged a bit, you're code seems to be passing the proper defines to the SyntaxTree parse function. But it still does not seem to be working sadly.

UPDATE: Seems like I had to do this for it to work: Globals.DefaultRoslynCompilationToScript = false;

[oleg-shilo]

Yep, that's the expected behaviour.

Though I have made a mistake not pointing out to you that by default the new behaviour is disabled, and the compilation for Regular happens exactly as before. The reason for this is not very technical but very real: I felt uneasy making such a dramatic change and forcing all users to this new algorithm in one single release.

The plan is:

1. Release the new compilation algorithm, but disabled by default: Globals.DefaultRoslynCompilationToScript = true.
2. Release new version with the new algorithm enabled by default: Globals.DefaultRoslynCompilationToScript = false
3. Remove the option for the old algorithm: Globals.DefaultRoslynCompilationToScript

Step 1 is done, the rest of teh steps will be completed over the next 2-3 releases.

I also wanted to thank you for bringing this whole Script vs Regular business to my attention. It helped me also to solve the old problem of Roslyn engine not allowing namespace declarations. This is because when it was implemented, Roslyn did not have (or did not expose) Regular option, and I took it as a permanent limitation. But now it's solved.

[mo-russo]

@oleg-shilo thanks to you as well. Your hard work on CS-Script is very appreciated.

One more question for you, could you clarify the reason why the precompiler (//css_precompiler) does not work when using Roslyn?

As shown in my original post above, we were doing processing to the code (granted, it was a hack) but we were also using the Hashtable context to set "NewReferences".