705 lines
35 KiB
C#
705 lines
35 KiB
C#
using Microsoft.CodeAnalysis;
|
|
using Microsoft.CodeAnalysis.CSharp;
|
|
using Microsoft.CodeAnalysis.CSharp.Scripting;
|
|
using Microsoft.CodeAnalysis.CSharp.Syntax;
|
|
using Microsoft.CodeAnalysis.Scripting;
|
|
using RobotNet10.Script;
|
|
using RobotNet10.ScriptEngine.Models;
|
|
using RobotNet10.ScriptEngine.Shared;
|
|
using System.Linq.Expressions;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
|
|
namespace RobotNet10.ScriptEngine.Helpers;
|
|
|
|
public static class ScriptHelper
|
|
{
|
|
public static Dictionary<string, object?> ConvertGlobalsToDictionary(object globals, Type type)
|
|
{
|
|
var globalsDic = new Dictionary<string, object?>();
|
|
|
|
foreach (var field in type.GetFields(BindingFlags.Public | BindingFlags.Instance))
|
|
{
|
|
globalsDic.TryAdd(field.Name, field.GetValue(globals));
|
|
}
|
|
|
|
foreach (var prop in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
|
|
{
|
|
if (prop.GetIndexParameters().Length == 0)
|
|
{
|
|
// Forward getter if available
|
|
if (prop.GetGetMethod() != null)
|
|
{
|
|
var getter = Delegate.CreateDelegate(
|
|
Expression.GetDelegateType([prop.PropertyType]),
|
|
globals,
|
|
prop.GetGetMethod()!
|
|
);
|
|
globalsDic.TryAdd($"get_{prop.Name}", getter);
|
|
}
|
|
// Forward setter if available
|
|
if (prop.GetSetMethod() != null)
|
|
{
|
|
var setter = Delegate.CreateDelegate(
|
|
Expression.GetDelegateType([prop.PropertyType, typeof(void)]),
|
|
globals,
|
|
prop.GetSetMethod()!
|
|
);
|
|
globalsDic.TryAdd($"set_{prop.Name}", setter);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Handle indexers (properties with parameters)
|
|
var indexParams = prop.GetIndexParameters().Select(p => p.ParameterType).ToArray();
|
|
|
|
// Forward indexer getter if available
|
|
if (prop.GetGetMethod() != null)
|
|
{
|
|
var getterParamTypes = indexParams.Concat([prop.PropertyType]).ToArray();
|
|
var getterDelegate = Delegate.CreateDelegate(
|
|
Expression.GetDelegateType(getterParamTypes),
|
|
globals,
|
|
prop.GetGetMethod()!
|
|
);
|
|
globalsDic.TryAdd($"get_{prop.Name}_indexer", getterDelegate);
|
|
}
|
|
|
|
// Forward indexer setter if available
|
|
if (prop.GetSetMethod() != null)
|
|
{
|
|
var setterParamTypes = indexParams.Concat([prop.PropertyType, typeof(void)]).ToArray();
|
|
var setterDelegate = Delegate.CreateDelegate(
|
|
Expression.GetDelegateType(setterParamTypes),
|
|
globals,
|
|
prop.GetSetMethod()!
|
|
);
|
|
globalsDic.TryAdd($"set_{prop.Name}_indexer", setterDelegate);
|
|
}
|
|
}
|
|
}
|
|
foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
|
|
{
|
|
if (!method.IsSpecialName)
|
|
{
|
|
var parameters = string.Join(", ", method.GetParameters().Select(p => $"{p.ParameterType.FullName} {p.Name}"));
|
|
var args = string.Join(", ", method.GetParameters().Select(p => p.Name));
|
|
var returnType = method.ReturnType == typeof(void) ? "void" : method.ReturnType.FullName;
|
|
|
|
var paramTypes = string.Join(",", method.GetParameters().Select(p => p.ParameterType.FullName));
|
|
var methodKey = $"{method.Name}({paramTypes})";
|
|
|
|
var del = Delegate.CreateDelegate(
|
|
Expression.GetDelegateType([.. method.GetParameters().Select(p => p.ParameterType), method.ReturnType]),
|
|
globals,
|
|
method
|
|
);
|
|
|
|
globalsDic.TryAdd(methodKey, del);
|
|
}
|
|
}
|
|
return globalsDic;
|
|
}
|
|
public static string BuildGlobalsScript(Type globalType)
|
|
{
|
|
var sb = new StringBuilder();
|
|
sb.AppendLine(BuildGlobalsScript(typeof(IScriptGlobals), nameof(ScriptGlobals.RobotNet)));
|
|
sb.AppendLine(BuildGlobalsScript(globalType, nameof(ScriptGlobals.AppApis)));
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static string BuildGlobalsScript(Type globalType, string nameOfGlobals)
|
|
{
|
|
var sb = new StringBuilder();
|
|
|
|
foreach (var field in globalType.GetFields(BindingFlags.Public | BindingFlags.Instance))
|
|
{
|
|
sb.AppendLine($@"{ScriptHelpers.ToString(field.FieldType)} {field.Name}
|
|
{{
|
|
get => ({ScriptHelpers.ToString(field.FieldType)}){nameOfGlobals}[""{field.Name}""];
|
|
set => {nameOfGlobals}[""{field.Name}""] = value;
|
|
}}");
|
|
}
|
|
|
|
foreach (var prop in globalType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
|
|
{
|
|
if (prop.GetIndexParameters().Length == 0)
|
|
{
|
|
var hasGetter = prop.GetGetMethod() != null;
|
|
var hasSetter = prop.GetSetMethod() != null;
|
|
if (hasGetter || hasSetter)
|
|
{
|
|
var propBuilder = new StringBuilder();
|
|
propBuilder.AppendLine($"{ScriptHelpers.ToString(prop.PropertyType)} {prop.Name}");
|
|
propBuilder.AppendLine("{");
|
|
if (hasGetter)
|
|
propBuilder.AppendLine($@" get => ((Func<{ScriptHelpers.ToString(prop.PropertyType)}>){nameOfGlobals}[""get_{prop.Name}""])();");
|
|
|
|
if (hasSetter)
|
|
propBuilder.AppendLine($@" set => ((Action<{ScriptHelpers.ToString(prop.PropertyType)}>){nameOfGlobals}[""set_{prop.Name}""])(value);");
|
|
propBuilder.AppendLine("}");
|
|
sb.AppendLine(propBuilder.ToString());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Handle indexers (properties with parameters)
|
|
var indexParams = prop.GetIndexParameters();
|
|
var paramDecl = string.Join(", ", indexParams.Select(p => $"{ScriptHelpers.ToString(p.ParameterType)} {p.Name}"));
|
|
var paramNames = string.Join(", ", indexParams.Select(p => p.Name));
|
|
var getterDelegateType = $"Func<{string.Join(", ", indexParams.Select(p => ScriptHelpers.ToString(p.ParameterType)).Concat([ScriptHelpers.ToString(prop.PropertyType)]))}>";
|
|
var setterDelegateType = $"Action<{string.Join(", ", indexParams.Select(p => ScriptHelpers.ToString(p.ParameterType)).Concat([ScriptHelpers.ToString(prop.PropertyType)]))}>";
|
|
|
|
var propBuilder = new StringBuilder();
|
|
propBuilder.AppendLine($"{ScriptHelpers.ToString(prop.PropertyType)} this[{paramDecl}]");
|
|
propBuilder.AppendLine("{");
|
|
if (prop.GetGetMethod() != null)
|
|
propBuilder.AppendLine($@" get => (({getterDelegateType}){nameOfGlobals}[""get_{prop.Name}_indexer""])({paramNames});");
|
|
if (prop.GetSetMethod() != null)
|
|
propBuilder.AppendLine($@" set => (({setterDelegateType}){nameOfGlobals}[""set_{prop.Name}_indexer""])({(string.IsNullOrEmpty(paramNames) ? "value" : paramNames + ", value")});");
|
|
propBuilder.AppendLine("}");
|
|
sb.AppendLine(propBuilder.ToString());
|
|
}
|
|
}
|
|
foreach (var method in globalType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
|
|
{
|
|
if (!method.IsSpecialName)
|
|
{
|
|
var parameters = method.GetParameters() ?? [];
|
|
var parametersStr = string.Join(", ", parameters.Select(ScriptHelpers.ToString));
|
|
var args = string.Join(", ", parameters.Select(p => p.Name));
|
|
var returnType = ScriptHelpers.ToString(method.ReturnType);
|
|
|
|
|
|
var paramTypes = string.Join(",", parameters.Select(p => p.ParameterType.FullName));
|
|
var methodKey = $"{method.Name}({paramTypes})";
|
|
|
|
var methodType = method.ReturnType == typeof(void)
|
|
? (parameters.Length == 0 ? "Action" : $"Action<{string.Join(", ", parameters.Select(p => ScriptHelpers.ToString(p.ParameterType)))}>")
|
|
: $"Func<{string.Join(", ", parameters.Select(p => ScriptHelpers.ToString(p.ParameterType)).Concat([ScriptHelpers.ToString(method.ReturnType)]))}>";
|
|
|
|
sb.AppendLine($@"{returnType} {method.Name}({parametersStr}) => (({methodType}){nameOfGlobals}[""{methodKey}""]){(string.IsNullOrEmpty(args) ? "()" : $"({args})")};");
|
|
}
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static IEnumerable<ScriptVariableModel> ExportScriptVariables(ClassDeclarationSyntax classNode, SemanticModel semanticModel, ScriptOptions scriptOptions)
|
|
{
|
|
List<ScriptVariableModel> variables = [];
|
|
var fields = classNode.Members.OfType<FieldDeclarationSyntax>();
|
|
foreach (var field in fields)
|
|
{
|
|
Type? resolvedType = semanticModel.ToSystemType(field.Declaration.Type);
|
|
if (resolvedType == null)
|
|
{
|
|
var fieldName = field.Declaration.Variables.FirstOrDefault()?.Identifier.Text ?? "unknown";
|
|
throw new ScriptCompilationException($"Failed to resolve type for field '{fieldName}': {field.Declaration.Type.ToFullString()}");
|
|
}
|
|
// Check if the field has VariableAttribute
|
|
|
|
VariableAttribute? varAttr = null;
|
|
foreach (var attrList in field.AttributeLists)
|
|
{
|
|
foreach (var attr in attrList.Attributes)
|
|
{
|
|
var attrType = semanticModel.GetTypeAttribute(attr);
|
|
if (attrType == VariableAttributeType)
|
|
{
|
|
varAttr = semanticModel.GetConstantAttribute(attr, attrType) as RobotNet10.Script.VariableAttribute;
|
|
break;
|
|
}
|
|
}
|
|
if (varAttr != null) break;
|
|
}
|
|
|
|
foreach (var variable in field.Declaration.Variables)
|
|
{
|
|
var name = variable.Identifier.Text;
|
|
if (string.IsNullOrEmpty(name)) continue;
|
|
|
|
|
|
|
|
if (variable.Initializer is null)
|
|
{
|
|
var value = resolvedType.IsValueType ? Activator.CreateInstance(resolvedType) : null;
|
|
variables.Add(new ScriptVariableModel(name, resolvedType, value, varAttr != null, varAttr?.PublicWrite ?? false));
|
|
}
|
|
else
|
|
{
|
|
var constant = semanticModel.GetConstantValue(variable.Initializer.Value);
|
|
if (constant.HasValue)
|
|
{
|
|
try
|
|
{
|
|
var value = Convert.ChangeType(constant.Value, resolvedType);
|
|
variables.Add(new ScriptVariableModel(name, resolvedType, value, varAttr != null, varAttr?.PublicWrite ?? false));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ScriptCompilationException($"Failed to convert value of variable '{name}' = \"{constant.Value}\" to type '{resolvedType.Name}': {ex.Message}", ex);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var code = variable.Initializer.Value.ToFullString();
|
|
object? value;
|
|
if (string.IsNullOrEmpty(code))
|
|
{
|
|
value = resolvedType.IsValueType ? Activator.CreateInstance(resolvedType) : null;
|
|
}
|
|
else
|
|
{
|
|
value = CSharpScript.EvaluateAsync<object>(code, scriptOptions).GetAwaiter().GetResult();
|
|
}
|
|
variables.Add(new ScriptVariableModel(name, resolvedType, value, varAttr != null, varAttr?.PublicWrite ?? false));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check auto-properties (properties with both getter and setter, no body) and add them to variables
|
|
var properties = classNode.Members.OfType<PropertyDeclarationSyntax>();
|
|
foreach (var prop in properties)
|
|
{
|
|
// Kiểm tra có cả getter và setter
|
|
var accessors = prop.AccessorList?.Accessors.ToList() ?? [];
|
|
bool hasGetter = accessors?.Any(a => a.Kind() == SyntaxKind.GetAccessorDeclaration) == true;
|
|
bool hasSetter = accessors?.Any(a => a.Kind() == SyntaxKind.SetAccessorDeclaration) == true;
|
|
|
|
// Kiểm tra auto-property: cả getter và setter đều không có body và không phải expression-bodied
|
|
bool isAutoProperty = hasGetter && hasSetter &&
|
|
accessors!.All(a => a.Body == null && a.ExpressionBody == null) &&
|
|
prop.ExpressionBody == null;
|
|
|
|
if (isAutoProperty)
|
|
{
|
|
var name = prop.Identifier.Text;
|
|
var type = semanticModel.ToSystemType(prop.Type);
|
|
if (type == null)
|
|
{
|
|
throw new ScriptCompilationException($"Failed to resolve type for auto-property '{name}': {prop.Type.ToFullString()}");
|
|
}
|
|
// Giá trị mặc định của auto-property là default(T)
|
|
object? value = type.IsValueType ? Activator.CreateInstance(type) : null;
|
|
variables.Add(new ScriptVariableModel(name, type, value, false, false));
|
|
}
|
|
}
|
|
|
|
return variables;
|
|
}
|
|
|
|
public static void ExportScriptTasksAndMissions(ClassDeclarationSyntax classNode,
|
|
SemanticModel semanticModel,
|
|
string globalScript,
|
|
ScriptOptions scriptOptions,
|
|
out List<ScriptTaskModel> tasks,
|
|
out List<ScriptMissionModel> missions)
|
|
{
|
|
tasks = [];
|
|
missions = [];
|
|
var methods = classNode.Members.OfType<MethodDeclarationSyntax>();
|
|
foreach (var method in methods)
|
|
{
|
|
bool attrDone = false;
|
|
foreach (var attrList in method.AttributeLists)
|
|
{
|
|
foreach (var attr in attrList.Attributes)
|
|
{
|
|
var attrType = semanticModel.GetTypeAttribute(attr);
|
|
if (attrType == TaskAttributeType)
|
|
{
|
|
attrDone = true;
|
|
|
|
if (semanticModel.GetConstantAttribute(attr, attrType) is not RobotNet10.Script.TaskAttribute taskAttr)
|
|
{
|
|
throw new ScriptCompilationException($"Failed to get TaskAttribute from method '{method.Identifier.Text}'. Ensure the attribute has valid parameters.");
|
|
}
|
|
|
|
// Check if method returns Task or Task<T>
|
|
var returnType = semanticModel.ToSystemType(method.ReturnType);
|
|
bool isTask = returnType == typeof(System.Threading.Tasks.Task);
|
|
//|| (returnType != null && returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(System.Threading.Tasks.Task<>));
|
|
bool isVoid = returnType == typeof(void);
|
|
|
|
if (method.ParameterList.Parameters.Count > 0)
|
|
{
|
|
throw new ScriptCompilationException($"Task method '{method.Identifier.Text}' with [Task] attribute must have no parameters. Found {method.ParameterList.Parameters.Count} parameter(s).");
|
|
}
|
|
|
|
if (!(isTask || isVoid))
|
|
{
|
|
var actualReturnType = returnType?.Name ?? "unknown";
|
|
throw new ScriptCompilationException($"Task method '{method.Identifier.Text}' with [Task] attribute must return void or Task. Found return type: {actualReturnType}.");
|
|
}
|
|
|
|
var code = ExtractRelatedCodeForScriptRunner(classNode, method, globalScript, $"{(isTask ? "await " : "")}{method.Identifier.Text}();");
|
|
|
|
var script = CSharpScript.Create(code, scriptOptions, globalsType: typeof(ScriptGlobals));
|
|
|
|
tasks.Add(new ScriptTaskModel(method.Identifier.Text,
|
|
taskAttr.Interval,
|
|
taskAttr.AutoStart,
|
|
method.ToFullString(),
|
|
script.CreateDelegate()));
|
|
break;
|
|
}
|
|
else if (attrType == MissionAttributeType)
|
|
{
|
|
attrDone = true;
|
|
if (semanticModel.GetConstantAttribute(attr, attrType) is not RobotNet10.Script.MissionAttribute missionAttr)
|
|
{
|
|
throw new ScriptCompilationException($"Failed to get MissionAttribute from method '{method.Identifier.Text}'. Ensure the attribute has valid parameters.");
|
|
}
|
|
var returnType = semanticModel.ToSystemType(method.ReturnType);
|
|
if (returnType is null)
|
|
{
|
|
throw new ScriptCompilationException($"Failed to resolve return type for mission method '{method.Identifier.Text}'.");
|
|
}
|
|
if (returnType != MissionReturnType)
|
|
{
|
|
throw new ScriptCompilationException($"Mission method '{method.Identifier.Text}' with [Mission] attribute must return IAsyncEnumerable<MissionStatus>. Found return type: {returnType.Name}.");
|
|
}
|
|
|
|
var inputParameters = new List<string>();
|
|
var parameters = new List<ScriptMissionParameterModel>();
|
|
bool hasCancellationTokenParameter = false;
|
|
foreach (var param in method.ParameterList.Parameters)
|
|
{
|
|
if (param.Type is null)
|
|
{
|
|
throw new ScriptCompilationException($"Parameter '{param.Identifier.Text}' in mission method '{method.Identifier.Text}' has no type specified.");
|
|
}
|
|
|
|
var paramType = semanticModel.ToSystemType(param.Type);
|
|
if (paramType == null)
|
|
{
|
|
throw new ScriptCompilationException($"Failed to resolve type for parameter '{param.Identifier.Text}' in mission method '{method.Identifier.Text}'. Type: {param.Type.ToFullString()}");
|
|
}
|
|
|
|
if (paramType == typeof(CancellationToken))
|
|
{
|
|
if (hasCancellationTokenParameter)
|
|
{
|
|
throw new ScriptCompilationException($"Mission method '{method.Identifier.Text}' has multiple CancellationToken parameters, which is not allowed. Only one CancellationToken parameter is supported.");
|
|
}
|
|
hasCancellationTokenParameter = true;
|
|
}
|
|
else if (!ScriptHelpers.SupportedTypes.Values.Contains(paramType))
|
|
{
|
|
throw new ScriptCompilationException($"Parameter type '{paramType.Name}' for parameter '{param.Identifier.Text}' in mission method '{method.Identifier.Text}' is not supported. Supported types: {string.Join(", ", ScriptHelpers.SupportedTypes.Values.Select(t => t.Name))}");
|
|
}
|
|
|
|
// lấy default value nếu có
|
|
object? defaultValue = null;
|
|
if (param.Default is EqualsValueClauseSyntax equalsValue)
|
|
{
|
|
var constValue = semanticModel.GetConstantValue(equalsValue.Value);
|
|
if (constValue.HasValue)
|
|
{
|
|
defaultValue = constValue.Value;
|
|
}
|
|
}
|
|
|
|
//inputParameters.Add($@"({paramType.FullName})parameters["""+param.Identifier.Text+"""]");
|
|
inputParameters.Add($@"({paramType.FullName}){nameof(ScriptGlobals.MissionParameters)}[""{param.Identifier.Text}""]");
|
|
parameters.Add(new ScriptMissionParameterModel(param.Identifier.Text, paramType, defaultValue));
|
|
}
|
|
|
|
var execScript = $"return {method.Identifier.Text}({string.Join(", ", inputParameters)});";
|
|
var code = ExtractRelatedCodeForScriptRunner(classNode, method, globalScript, execScript);
|
|
var script = CSharpScript.Create<IAsyncEnumerable<MissionStatus>>(code, scriptOptions, globalsType: typeof(ScriptGlobals));
|
|
missions.Add(new ScriptMissionModel(method.Identifier.Text,
|
|
parameters,
|
|
method.ToFullString(),
|
|
missionAttr.TotalScore,
|
|
missionAttr.IsMultipleRun,
|
|
missionAttr.AutoStart,
|
|
script.CreateDelegate()));
|
|
break;
|
|
}
|
|
|
|
}
|
|
if (attrDone) break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string ExtractRelatedCodeForScriptRunner(ClassDeclarationSyntax classNode, MethodDeclarationSyntax rootMethod, string globalScript, string execScript)
|
|
{
|
|
var allMethods = classNode.Members.OfType<MethodDeclarationSyntax>().ToList();
|
|
var allFields = classNode.Members.OfType<FieldDeclarationSyntax>().ToList();
|
|
var allProperties = classNode.Members.OfType<PropertyDeclarationSyntax>().ToList();
|
|
var allNestedTypes = classNode.Members
|
|
.Where(m => m is ClassDeclarationSyntax || m is StructDeclarationSyntax || m is InterfaceDeclarationSyntax || m is EnumDeclarationSyntax)
|
|
.ToList();
|
|
|
|
// 1. BFS: method + non-auto-property
|
|
var usedMethodNames = new HashSet<string>();
|
|
var usedPropertyNames = new HashSet<string>();
|
|
var methodQueue = new Queue<MemberDeclarationSyntax>();
|
|
var collectedMethods = new List<MethodDeclarationSyntax>();
|
|
var collectedNonAutoProperties = new List<PropertyDeclarationSyntax>();
|
|
|
|
methodQueue.Enqueue(rootMethod);
|
|
|
|
while (methodQueue.Count > 0)
|
|
{
|
|
var member = methodQueue.Dequeue();
|
|
if (member is MethodDeclarationSyntax method)
|
|
{
|
|
if (!usedMethodNames.Add(method.Identifier.Text))
|
|
continue;
|
|
collectedMethods.Add(method);
|
|
|
|
// Tìm các method/property được gọi trong method này
|
|
// Sử dụng InvocationExpressionSyntax và MemberAccessExpressionSyntax để tìm chính xác hơn
|
|
var invocationExpressions = method.DescendantNodes()
|
|
.OfType<InvocationExpressionSyntax>()
|
|
.Select(inv => inv.Expression)
|
|
.OfType<MemberAccessExpressionSyntax>()
|
|
.Select(ma => ma.Name.Identifier.Text)
|
|
.Distinct();
|
|
|
|
var memberAccessExpressions = method.DescendantNodes()
|
|
.OfType<MemberAccessExpressionSyntax>()
|
|
.Select(ma => ma.Name.Identifier.Text)
|
|
.Distinct();
|
|
|
|
var identifierNames = method.DescendantNodes()
|
|
.OfType<IdentifierNameSyntax>()
|
|
.Where(id => id.Parent is not MemberAccessExpressionSyntax) // Exclude already handled member accesses
|
|
.Select(id => id.Identifier.Text)
|
|
.Distinct();
|
|
|
|
var allInvokedNames = invocationExpressions
|
|
.Concat(memberAccessExpressions)
|
|
.Concat(identifierNames)
|
|
.Distinct();
|
|
|
|
foreach (var name in allInvokedNames)
|
|
{
|
|
// Method
|
|
var nextMethod = allMethods.FirstOrDefault(m => m.Identifier.Text == name);
|
|
if (nextMethod != null && !usedMethodNames.Contains(name))
|
|
methodQueue.Enqueue(nextMethod);
|
|
|
|
// Property
|
|
var nextProp = allProperties.FirstOrDefault(p => p.Identifier.Text == name);
|
|
if (nextProp != null && !usedPropertyNames.Contains(name))
|
|
methodQueue.Enqueue(nextProp);
|
|
}
|
|
}
|
|
else if (member is PropertyDeclarationSyntax prop)
|
|
{
|
|
if (!usedPropertyNames.Add(prop.Identifier.Text))
|
|
continue;
|
|
|
|
// Auto-property: bỏ qua, sẽ xử lý sau
|
|
var accessors = prop.AccessorList?.Accessors.ToList() ?? [];
|
|
bool hasGetter = accessors.Any(a => a.Kind() == SyntaxKind.GetAccessorDeclaration);
|
|
bool hasSetter = accessors.Any(a => a.Kind() == SyntaxKind.SetAccessorDeclaration);
|
|
bool isAutoProperty = hasGetter && hasSetter &&
|
|
accessors.All(a => a.Body == null && a.ExpressionBody == null) &&
|
|
prop.ExpressionBody == null;
|
|
|
|
if (isAutoProperty)
|
|
continue;
|
|
|
|
collectedNonAutoProperties.Add(prop);
|
|
|
|
// Tìm các method/property/field được gọi trong property này
|
|
// Sử dụng InvocationExpressionSyntax và MemberAccessExpressionSyntax để tìm chính xác hơn
|
|
var invocationExpressions = prop.DescendantNodes()
|
|
.OfType<InvocationExpressionSyntax>()
|
|
.Select(inv => inv.Expression)
|
|
.OfType<MemberAccessExpressionSyntax>()
|
|
.Select(ma => ma.Name.Identifier.Text)
|
|
.Distinct();
|
|
|
|
var memberAccessExpressions = prop.DescendantNodes()
|
|
.OfType<MemberAccessExpressionSyntax>()
|
|
.Select(ma => ma.Name.Identifier.Text)
|
|
.Distinct();
|
|
|
|
var identifierNames = prop.DescendantNodes()
|
|
.OfType<IdentifierNameSyntax>()
|
|
.Where(id => id.Parent is not MemberAccessExpressionSyntax) // Exclude already handled member accesses
|
|
.Select(id => id.Identifier.Text)
|
|
.Distinct();
|
|
|
|
var allInvokedNames = invocationExpressions
|
|
.Concat(memberAccessExpressions)
|
|
.Concat(identifierNames)
|
|
.Distinct();
|
|
|
|
foreach (var name in allInvokedNames)
|
|
{
|
|
// Method
|
|
var nextMethod = allMethods.FirstOrDefault(m => m.Identifier.Text == name);
|
|
if (nextMethod != null && !usedMethodNames.Contains(name))
|
|
methodQueue.Enqueue(nextMethod);
|
|
|
|
// Property
|
|
var nextProp = allProperties.FirstOrDefault(p => p.Identifier.Text == name);
|
|
if (nextProp != null && !usedPropertyNames.Contains(name))
|
|
methodQueue.Enqueue(nextProp);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. Collect all used member names (from all collected methods & non-auto-properties)
|
|
var usedMemberNames = new HashSet<string>();
|
|
foreach (var method in collectedMethods)
|
|
{
|
|
foreach (var id in method.DescendantNodes().OfType<IdentifierNameSyntax>().Select(id => id.Identifier.Text))
|
|
usedMemberNames.Add(id);
|
|
}
|
|
foreach (var prop in collectedNonAutoProperties)
|
|
{
|
|
foreach (var id in prop.DescendantNodes().OfType<IdentifierNameSyntax>().Select(id => id.Identifier.Text))
|
|
usedMemberNames.Add(id);
|
|
}
|
|
|
|
// 3. Collect fields
|
|
var relatedFields = new List<string>();
|
|
foreach (var field in allFields)
|
|
{
|
|
foreach (var variable in field.Declaration.Variables)
|
|
{
|
|
if (usedMemberNames.Contains(variable.Identifier.Text))
|
|
{
|
|
var varType = field.Declaration.Type.ToString();
|
|
var varName = variable.Identifier.Text;
|
|
var propertyCode = $@"public {varType} {varName}
|
|
{{
|
|
get => ({varType}){nameof(ScriptGlobals.GlobalVariables)}[""{varName}""];
|
|
set => {nameof(ScriptGlobals.GlobalVariables)}[""{varName}""] = value;
|
|
}}";
|
|
relatedFields.Add(propertyCode.Trim());
|
|
}
|
|
}
|
|
}
|
|
|
|
// 4. Collect auto-properties
|
|
var relatedAutoProperties = new List<string>();
|
|
foreach (var prop in allProperties)
|
|
{
|
|
var accessors = prop.AccessorList?.Accessors.ToList() ?? [];
|
|
bool hasGetter = accessors.Any(a => a.Kind() == SyntaxKind.GetAccessorDeclaration);
|
|
bool hasSetter = accessors.Any(a => a.Kind() == SyntaxKind.SetAccessorDeclaration);
|
|
bool isAutoProperty = hasGetter && hasSetter &&
|
|
accessors.All(a => a.Body == null && a.ExpressionBody == null) &&
|
|
prop.ExpressionBody == null;
|
|
|
|
if (isAutoProperty && (usedMemberNames.Contains(prop.Identifier.Text) || usedPropertyNames.Contains(prop.Identifier.Text)))
|
|
{
|
|
var propType = prop.Type.ToString();
|
|
var propName = prop.Identifier.Text;
|
|
var propertyCode = $@"public {propType} {propName}
|
|
{{
|
|
get => ({propType}){nameof(ScriptGlobals.GlobalVariables)}[""{propName}""];
|
|
set => {nameof(ScriptGlobals.GlobalVariables)}[""{propName}""] = value;
|
|
}}";
|
|
relatedAutoProperties.Add(propertyCode.Trim());
|
|
}
|
|
}
|
|
|
|
// 5. Collect nested types if referenced
|
|
var usedNestedTypeNames = new HashSet<string>(usedMemberNames);
|
|
var relatedNestedTypes = allNestedTypes
|
|
.Where(nt =>
|
|
{
|
|
if (nt is BaseTypeDeclarationSyntax btd)
|
|
return usedNestedTypeNames.Contains(btd.Identifier.Text);
|
|
return false;
|
|
})
|
|
.Select(nt => nt.NormalizeWhitespace().ToFullString())
|
|
.ToList();
|
|
|
|
// 6. Compose the script
|
|
var sb = new StringBuilder();
|
|
sb.AppendLine(globalScript);
|
|
foreach (var nt in relatedNestedTypes)
|
|
sb.AppendLine(nt);
|
|
foreach (var f in relatedFields)
|
|
sb.AppendLine(f);
|
|
foreach (var p in relatedAutoProperties)
|
|
sb.AppendLine(p);
|
|
foreach (var p in collectedNonAutoProperties)
|
|
sb.AppendLine(p.NormalizeWhitespace().ToFullString());
|
|
foreach (var m in collectedMethods)
|
|
sb.AppendLine(m.NormalizeWhitespace().ToFullString());
|
|
|
|
sb.AppendLine(execScript);
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static Type? GetTypeAttribute(this SemanticModel semanticModel, AttributeSyntax attrSynctax)
|
|
{
|
|
var typeInfo = semanticModel.GetTypeInfo(attrSynctax);
|
|
if (typeInfo.Type is null) return null;
|
|
|
|
string metadataName = typeInfo.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat).Replace("global::", "");
|
|
return ScriptHelpers.ResolveTypeFromString(metadataName);
|
|
}
|
|
|
|
private static object? GetConstantAttribute(this SemanticModel semanticModel, AttributeSyntax attrSynctax, Type type)
|
|
{
|
|
var args = new List<object?>();
|
|
|
|
foreach (var arg in attrSynctax.ArgumentList?.Arguments ?? default)
|
|
{
|
|
var constValue = semanticModel.GetConstantValue(arg.Expression);
|
|
if (constValue.HasValue)
|
|
args.Add(constValue.Value);
|
|
else
|
|
args.Add(null); // fallback nếu không phân giải được
|
|
}
|
|
|
|
// Find the constructor with the same number or more parameters (with optional)
|
|
var ctors = type.GetConstructors();
|
|
foreach (var ctor in ctors)
|
|
{
|
|
var parameters = ctor.GetParameters();
|
|
if (args.Count <= parameters.Length)
|
|
{
|
|
// Fill missing optional parameters with their default values
|
|
var finalArgs = args.ToList();
|
|
for (int i = args.Count; i < parameters.Length; i++)
|
|
{
|
|
if (parameters[i].IsOptional)
|
|
finalArgs.Add(parameters[i].DefaultValue);
|
|
else
|
|
goto NextCtor; // Not enough arguments and not optional
|
|
}
|
|
return ctor.Invoke([.. finalArgs]);
|
|
}
|
|
NextCtor:;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static Type? ToSystemType(this SemanticModel semanticModel, TypeSyntax typeSyntax)
|
|
{
|
|
var typeSymbol = semanticModel.GetTypeInfo(typeSyntax).Type;
|
|
if (typeSymbol is null) return null;
|
|
|
|
if (typeSyntax is PredefinedTypeSyntax predefinedType
|
|
&& ScriptHelpers.SupportedTypes.TryGetValue(predefinedType.Keyword.Text, out var systemType))
|
|
{
|
|
return systemType;
|
|
}
|
|
|
|
string metadataName = typeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat).Replace("global::", "");
|
|
return metadataName.Equals("void") ? typeof(void) : ScriptHelpers.ResolveTypeFromString(metadataName);
|
|
}
|
|
|
|
private static readonly Type TaskAttributeType = typeof(RobotNet10.Script.TaskAttribute);
|
|
private static readonly Type MissionAttributeType = typeof(RobotNet10.Script.MissionAttribute);
|
|
private static readonly Type MissionReturnType = typeof(IAsyncEnumerable<RobotNet10.Script.MissionStatus>);
|
|
private static readonly Type VariableAttributeType = typeof(RobotNet10.Script.VariableAttribute);
|
|
}
|