Resolve constants?

[Lombra]

Hi,

Using ICSharpCode.Decompiler, can I somehow (selectively) resolve literal values back to a constant? I probably don't want to do it across the board, but something like selecting specific method arguments, possibly for calls within specific methods.

Similar to the following issue, except not as a default.

#3222

[Lombra]

Had a go at this again and, after a lot of trial and error, ended up with something that works, though I barely know how.

public class ResolveGameVersionLiteral : IAstTransform {
	public void Run(AstNode rootNode, TransformContext context) {
		foreach (var section in rootNode.Descendants.OfType<InvocationExpression>().Where(e => e.Arguments.Count > 0)) {
			var method = (IMethod)section.GetSymbol();
			if (method.FullName == "System.IO.BinaryWriter.Write" && (method.Parameters[0]?.Type.IsKnownType(KnownTypeCode.Int32) ?? false)) {
				var firstArgument = section.Arguments.First();
				if (firstArgument is PrimitiveExpression expression && expression.Value is int value && value == C.GameVersion) {
					firstArgument = firstArgument.ReplaceWith(expr => new MemberReferenceExpression(new IdentifierExpression("Misc"), "GAME_VERSION"));
				}
			}
		}
	}
}

The goal was to replace any calls to System.IO.BinaryWriter.Write where the argument is a given literal integer value, with the constant Misc.GAME_VERSION.

Would appreciate any advice on how to improve the logic, such as the checking for the correct method.

Also, is there any way to pass the searched value into the transform, or do I have to store it as some class field like this?

[siegfriedpammer]

Sorry for taking so long to get to this.

is there any way to pass the searched value into the transform, or do I have to store it as some class field like this?

Configuration for your custom transform should be stored in the IAstTransform implementation instance. Currently there is no other way (such as to pass custom info via the TransformContext).

Would appreciate any advice on how to improve the logic, such as the checking for the correct method.

This looks good overall, you don't need to check whether method.Parameters[0] is null. Individual parameters are never null.

I would go for something like this (UNTESTED code):

public class ResolveGameVersionLiteral : IAstTransform
{
	public void Run(AstNode rootNode, TransformContext context)
	{
		foreach (var section in rootNode.Descendants.OfType<InvocationExpression>())
		{
			if (section.GetSymbol() is not IMethod { FullName: "System.IO.BinaryWriter.Write" } method)
				continue;
			if (method.Parameters is not [var firstParam] || !firstParam.Type.IsKnownType(KnownTypeCode.Int32))
				continue;
			var firstArgument = section.Arguments.First();
			if (firstArgument is PrimitiveExpression { Value: int value } expression && value == C.GameVersion)
			{
				firstArgument = firstArgument.ReplaceWith(expr => new MemberReferenceExpression(new IdentifierExpression("Misc"), "GAME_VERSION"));
			}
		}
	}
}

Note, in order to produce correct output that can be processed by other transforms, you would have to add ResolveResult instances as annotations to the newly created AstNodes. Otherwise things like GetSymbol() will break for transforms that are applied after your transform. If your transform is the last one and the next step would be to just produce C# files from the syntax trees, then this is not necessary.

In the decompiler there is similar logic for well-known constants such as Math.PI, however, it is not exactly reusable outside of the core library. But, maybe it helps:

ILSpy/ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs

Lines 1516 to 1533 in 83c34d4

	Expression MakeFieldReference()
	{
	AstType mathAstType = ConvertType(mathType);
	var fieldRef = new MemberReferenceExpression(new TypeReferenceExpression(mathAstType), memberName);
	if (AddResolveResultAnnotations)
	{
	var field = mathType.GetFields(f => f.Name == memberName).FirstOrDefault();
	if (field != null)
	{
	fieldRef.WithRR(new MemberResolveResult(mathAstType.GetResolveResult(), field));
	}
	}
	if (type.IsKnownType(KnownTypeCode.Double))
	return fieldRef;
	if (mathType.Name == "MathF")
	return fieldRef;
	return new CastExpression(ConvertType(type), fieldRef);
	}