awing-library 2.1.2-dev.99 → 2.1.2-preview.1

package/dotnet-wasm/ExpressionAnalyzer.cs

@@ -0,0 +1,900 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public sealed class ExpressionAnalyzer
+{
+    private readonly ExpressionSchema _schema;
+
+    public ExpressionAnalyzer(ExpressionSchema schema)
+    {
+        _schema = schema;
+    }
+
+    public AnalyzeResult Analyze(string code, int cursor)
+    {
+        var suggestions = new List<SuggestionItem>();
+        try
+        {
+            var tree = CSharpSyntaxTree.ParseText(code);
+            var root = tree.GetRoot();
+
+            var lambda = root.DescendantNodes()
+                .OfType<SimpleLambdaExpressionSyntax>()
+                .FirstOrDefault();
+
+            if (lambda == null)
+                return Error("Expression must be lambda: x => ...");
+
+            var param = lambda.Parameter.Identifier.Text;
+
+            if (lambda.Body is not ExpressionSyntax bodyExpr)
+            {
+                return Error("Lambda body must be an expression");
+            }
+
+            suggestions = BuildSuggest(root, bodyExpr, param, cursor);
+
+            var validation = ValidateExpression(bodyExpr, param);
+            return new AnalyzeResult
+            {
+                IsValid = validation.IsValid,
+                ResultType = validation.ResultType,
+                Errors = validation.Errors,
+                Suggestions = suggestions ?? []
+            };
+        }
+        catch (Exception ex)
+        {
+            return Error(ex.Message, suggestions);
+        }
+    }
+
+    // ================= SUGGEST =================
+
+    private List<SuggestionItem> BuildSuggest(
+        SyntaxNode root,
+        ExpressionSyntax expr,
+        string param,
+        int cursor)
+    {
+        var token = root.FindToken(cursor);
+
+        // x.Na
+        if (token.IsKind(SyntaxKind.IdentifierToken))
+        {
+            var text = token.Text;
+            var parent = token.Parent;
+
+            if (parent is IdentifierNameSyntax &&
+                parent.Parent is MemberAccessExpressionSyntax ma)
+            {
+                var type = Resolve(ma.Expression, param);
+                if (type != null)
+                    return Suggest(type, text);
+            }
+        }
+
+        // x.
+        if (token.IsKind(SyntaxKind.DotToken) &&
+            token.Parent is MemberAccessExpressionSyntax dot)
+        {
+            var type = Resolve(dot.Expression, param);
+            if (type != null)
+                return Suggest(type, null);
+        }
+
+        return [];
+    }
+
+    /// <summary>
+    /// Generates a list of property and function suggestions based on the specified type and optional prefix.
+    /// </summary>
+    /// <param name="type">The type context, which determines the available properties for suggestions. Must be an instance of
+    /// ObjectSchema to include property suggestions.</param>
+    /// <param name="prefix">An optional string used to filter suggestions. Only properties and functions whose names start with this
+    /// prefix (case-insensitive) are included. If null, all available suggestions are returned.</param>
+    /// <returns>An AnalyzeResult containing the list of matching property and function suggestions. The result may be empty
+    /// if no suggestions match the specified prefix.</returns>
+    private List<SuggestionItem> Suggest(TypeDef type, string? prefix)
+    {
+        var result = new List<SuggestionItem>();
+        var prefixLength = prefix?.Length ?? 0;
+
+        if (type is ObjectSchemaDef obj)
+        {
+            foreach (var p in obj.Properties)
+            {
+                if (prefix == null || p.Key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+                {
+                    var isObj = p.Value is ObjectSchemaDef;
+                    result.Add(new SuggestionItem
+                    {
+                        Label = p.Key,
+                        InsertText = p.Key[prefixLength..],
+                        Kind = "property"
+                    });
+                }
+            }
+        }
+
+        foreach (var fn in _schema.Functions)
+        {
+            if (fn.IsExtension && fn.Parameters.Count > 0 && CompareType(type, fn.Parameters.First()) &&
+                (prefix == null || fn.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)))
+            {
+                //Nếu là không param hoặc extension và chỉ có một param thì gợi ý ()
+                //Còn lại thì chỉ gợi ý dấu (
+                var postfix = "(";
+                if (fn.Parameters.Count == 0 || fn.IsExtension && fn.Parameters.Count == 1)
+                    postfix = "()";
+
+                result.Add(new SuggestionItem
+                {
+                    Label = fn.Name + postfix,
+                    InsertText = fn.Name[prefixLength..] + postfix,
+                    Kind = "function"
+                });
+            }
+        }
+
+        return result;
+    }
+
+    // ================= VALIDATION =================
+
+    /// <summary>
+    /// Validates the specified expression and determines its result type.
+    /// </summary>
+    /// <param name="expr">The expression to validate.</param>
+    /// <param name="param">The name of the parameter associated with the expression. Used for error reporting and context.</param>
+    /// <returns>An AnalyzeResult indicating whether the expression is valid and, if so, its result type.</returns>
+    private AnalyzeResult ValidateExpression(
+        ExpressionSyntax expr,
+        string param)
+    {
+        return new AnalyzeResult
+        {
+            IsValid = true,
+            ResultType = Resolve(expr, param)
+        };
+    }
+
+    // ================= RESOLUTION =================
+
+    private TypeDef Resolve(
+        ExpressionSyntax expr,
+        string param)
+    {
+        // x 
+        if (expr is IdentifierNameSyntax id)
+        {
+            if (id.Identifier.Text != param)
+                throw new InvalidOperationException($"Unknown identifier: {id.Identifier.Text}");
+
+            // x đại diện cho root object T
+            return _schema.RootObject;
+        }
+
+        // x.Prop
+        if (expr is MemberAccessExpressionSyntax ma)
+        {
+            return ResolveMember(ma, param);
+        }
+
+        // x.Prop.Method()
+        if (expr is InvocationExpressionSyntax inv)
+        {
+            return ResolveInvocation(inv, param);
+        }
+
+        // x.ArrayProp[index]
+        if (expr is ElementAccessExpressionSyntax ea)
+        {
+            return ResolveElementAccess(ea, param);
+        }
+
+        // new { ... }
+        if (expr is AnonymousObjectCreationExpressionSyntax anon)
+        {
+            var newType = new ObjectSchemaDef();
+            foreach (var i in anon.Initializers)
+            {
+                var paramType = Resolve(i.Expression, param);
+                var name = i.NameEquals?.Name.Identifier.Text
+                    ?? (i.Expression as IdentifierNameSyntax)?.Identifier.Text
+                    ?? "unknown";
+                newType.Properties[name] = paramType;
+
+            }
+            return newType;
+        }
+
+        //UnaryExpression
+        if (expr is PrefixUnaryExpressionSyntax unary)
+        {
+            return PrefixUnary(unary, param);
+        }
+
+        if (expr is BinaryExpressionSyntax bin)
+        {
+            return ResolveBinary(bin, param);
+        }
+
+        if (expr is LiteralExpressionSyntax literal)
+        {
+            return ResolveLiteral(literal);
+        }
+
+        if (expr is ParenthesizedExpressionSyntax parenthesized)
+        {
+            return Resolve(parenthesized.Expression, param);
+        }
+
+        //if (expr is SimpleLambdaExpressionSyntax simpleLambdaExpression)
+        //{
+        //    var analyzer = new ExpressionAnalyzer(new ExpressionSchema
+        //    {
+        //        RootObject = new 
+        //        Functions = _schema.Functions
+        //    });
+        //}
+
+        throw new InvalidOperationException($"Unsupported expression type: {expr.GetType().Name}.");
+    }
+
+    private static TypeDef ResolveLiteral(LiteralExpressionSyntax literal)
+    {
+        var parsedType = TypeRefParser.Parse(literal);
+        if (parsedType != null)
+        {
+            return parsedType;
+        }
+        throw new InvalidOperationException($"Unsupported literal type {literal.Kind()}.");
+    }
+
+    private TypeDef PrefixUnary(PrefixUnaryExpressionSyntax unary, string param)
+    {
+        var operandType = Resolve(unary.Operand, param);
+
+        var op = unary.OperatorToken.Kind();
+        switch (op)
+        {
+            case SyntaxKind.ExclamationToken:
+            case SyntaxKind.LogicalNotExpression:
+                // Logical NOT requires a boolean operand.
+                if (operandType is PrimitiveTypeDef pt && pt.BaseType == "bool")
+                {
+                    return TypeRefParser.Parse("bool");
+                }
+                break;
+        }
+        throw new InvalidOperationException($"Invalid unary operation {op}.");
+    }
+
+    private TypeDef ResolveBinary(BinaryExpressionSyntax bin, string param)
+    {
+        var leftType = Resolve(bin.Left, param);
+        var rightType = Resolve(bin.Right, param);
+
+        var op = bin.OperatorToken.Kind();
+        switch (op)
+        {
+            case SyntaxKind.EqualsEqualsToken:
+            case SyntaxKind.ExclamationEqualsToken:
+                if (CompareType(leftType, rightType) || CompareType(rightType, leftType))
+                {
+                    return TypeRefParser.Parse("bool");
+                }
+                break;
+            case SyntaxKind.GreaterThanToken:
+            case SyntaxKind.GreaterThanEqualsToken:
+            case SyntaxKind.LessThanToken:
+            case SyntaxKind.LessThanEqualsToken:
+                // For comparison, types must be compatible.
+                // Allow comparison if one can be assigned to the other.
+                if (!CompareType(leftType, rightType) && !CompareType(rightType, leftType))
+                    break;
+
+                return TypeRefParser.Parse("bool");
+            case SyntaxKind.LogicalAndExpression:
+            case SyntaxKind.LogicalOrExpression:
+            case SyntaxKind.AmpersandAmpersandToken:
+            case SyntaxKind.AmpersandToken:
+            case SyntaxKind.BarBarToken:
+            case SyntaxKind.BarToken:
+                // Logical operations require both operands to be boolean.
+                if (leftType is PrimitiveTypeDef lpt && lpt.BaseType == "bool" &&
+                    rightType is PrimitiveTypeDef rpt && rpt.BaseType == "bool")
+                {
+                    return TypeRefParser.Parse("bool");
+                }
+                break;
+            case SyntaxKind.PlusToken:
+                // Allow string concatenation or numeric addition.
+                if (leftType is PrimitiveTypeDef lpt2 && rightType is PrimitiveTypeDef rpt2)
+                {
+                    if (lpt2.BaseType == "string" && rpt2.BaseType == "string")
+                    {
+                        return TypeRefParser.Parse("string");
+                    }
+                    if (lpt2.BaseType == "int" && rpt2.BaseType == "int")
+                    {
+                        return TypeRefParser.Parse("int");
+                    }
+                }
+                break;
+            case SyntaxKind.MinusToken:
+            case SyntaxKind.AsteriskToken:
+            case SyntaxKind.SlashToken:
+            case SyntaxKind.PercentToken:
+                // Arithmetic operations require both operands to be numeric.
+                if (leftType is PrimitiveTypeDef lpt3 && lpt3.BaseType == "int" &&
+                    rightType is PrimitiveTypeDef rpt3 && rpt3.BaseType == "int")
+                {
+                    return TypeRefParser.Parse("int");
+                }
+                break;
+        }
+
+        throw new InvalidOperationException($"Invalid binary operation {op}.");
+    }
+
+    private TypeDef ResolveMember(
+        MemberAccessExpressionSyntax ma,
+        string param)
+    {
+        var parent = Resolve(ma.Expression, param);
+
+        if (parent is PrimitiveTypeDef)
+            throw new InvalidOperationException("Primitive type does not have members.");
+
+        if (parent is ObjectSchemaDef obj && obj.Properties.TryGetValue(ma.Name.Identifier.Text, out var node))
+        {
+            return node;
+        }
+
+        throw new InvalidOperationException($"Property '{ma.Name.Identifier.Text}' not found on type. Expression: {ma}");
+    }
+
+    private TypeDef ResolveInvocation(
+        InvocationExpressionSyntax inv,
+        string param)
+    {
+        // Kiểm tra đã kết thúc bằng dấu ) chưa
+        if (inv.ArgumentList.CloseParenToken.IsMissing)
+            throw new InvalidOperationException("Incomplete function invocation.");
+
+        if (inv.Expression is not MemberAccessExpressionSyntax ma)
+            throw new InvalidOperationException("Invalid function invocation.");
+
+        var target = Resolve(ma.Expression, param);
+
+        var fn = _schema.Functions.FirstOrDefault(f =>
+            f.Name == ma.Name.Identifier.Text &&
+            (f.IsExtension && f.Parameters.Count >= 1 && CompareType(target, f.Parameters.First())));
+
+        if (fn == null)
+            throw new InvalidOperationException("Function not found.");
+
+        return GetReturnTypeAndValidateFunctionArguments(inv, param, fn, target);
+    }
+
+    private TypeDef GetReturnTypeAndValidateFunctionArguments(InvocationExpressionSyntax inv, string param, FunctionSchema fn, TypeDef sourceType)
+    {
+        Dictionary<string, TypeDef> genericTypeMap = [];
+        // Các tham số nullable ở cuối cùng có thể bỏ qua
+        var maxParams = fn.Parameters.Count;
+        var minParams = fn.Parameters.Count;
+        if (fn.IsExtension)
+        {
+            maxParams--;
+            minParams--;
+
+            // Kiểm tra và map generic type từ tham số mở rộng
+            genericTypeMap = MapExtensionParameterGenericTypes(fn.Parameters.First(), sourceType, genericTypeMap);
+        }
+        var argsCount = inv.ArgumentList.Arguments.Count;
+        for (int i = fn.Parameters.Count - 1; i >= 0; i--)
+        {
+            var p = fn.Parameters[i];
+            if (p.IsNullable)
+                minParams--;
+            else
+                break;
+        }
+        var args = inv.ArgumentList.Arguments;
+        if (argsCount < minParams || argsCount > maxParams)
+            throw new InvalidOperationException("Invalid number of arguments.");
+
+        for (int i = 0; i < args.Count; i++)
+        {
+            var argExpression = args[i].Expression;
+
+            var paramType = fn.IsExtension ? fn.Parameters[i + 1] : fn.Parameters[i];
+            //var paramSourceType = Resolve(argExpression, argExpression.ToFullString());
+            paramType = GetRealType(paramType, genericTypeMap);
+
+            if (argExpression is SimpleLambdaExpressionSyntax simpleLambdaExpression &&
+                paramType is FuncType funcType &&
+                funcType.Parameters.Count == 1)
+            {
+                //Kiểm tra tham số của lambda có khớp với funcType không
+                if (simpleLambdaExpression.Parameter is not ParameterSyntax lambdaParam)
+                    throw new InvalidOperationException("Invalid lambda parameter.");
+
+                genericTypeMap = MapExtensionParameterGenericTypes(funcType.Parameters.First(), sourceType, genericTypeMap);
+                var firstParamType = GetRealType(funcType.Parameters.First(), genericTypeMap);
+
+                var analyzer = new ExpressionAnalyzer(new ExpressionSchema
+                {
+                    RootObject = firstParamType,
+                    Functions = _schema.Functions
+                });
+                var expr = simpleLambdaExpression.ToFullString();
+                var analysisResult = analyzer.Analyze(expr, expr.Length - 1);
+                if (!analysisResult.IsValid)
+                    throw new InvalidOperationException($"Invalid lambda expression in argument. Function {fn.Name}");
+
+                genericTypeMap = MapExtensionParameterGenericTypes(funcType.ReturnType, analysisResult.ResultType!, genericTypeMap);
+
+                continue;
+            }
+            else
+            {
+                var argSourceType = Resolve(argExpression, param);
+                genericTypeMap = MapExtensionParameterGenericTypes(paramType, argSourceType, genericTypeMap);
+
+                if (!CompareType(argSourceType, paramType))
+                    throw new InvalidOperationException($"Argument type mismatch. Function {fn.Name}");
+            }
+        }
+
+        return GetRealType(fn.ReturnType, genericTypeMap); ;
+    }
+
+    /// <summary>
+    /// Map kiểu generic từ tham số và map vào genericTypeMap
+    /// </summary>
+    /// <param name="funcParam"></param>
+    /// <param name="sourceType"></param>
+    /// <param name="initMap"></param>
+    /// <returns></returns>
+    /// <exception cref="InvalidOperationException"></exception>
+    private static Dictionary<string, TypeDef> MapExtensionParameterGenericTypes(TypeDef funcParam, TypeDef sourceType, Dictionary<string, TypeDef> initMap)
+    {
+        Dictionary<string, TypeDef> genericTypeMap = new(initMap);
+        if (funcParam is GenericType gt)
+        {
+            if (gt.IsMatch(sourceType) == false)
+                throw new InvalidOperationException("Generic type mismatch.");
+
+            if (!genericTypeMap.ContainsKey(gt.Name))
+                genericTypeMap[gt.Name] = gt.GetRealType(sourceType, isNullable: false);
+        }
+        else if (funcParam is ArrayTypeDef arrayTypeDef && arrayTypeDef.ElementType is GenericType arrayElType)
+        {
+            if (sourceType is not ArrayTypeDef sourceArrayType)
+                throw new InvalidOperationException("Generic type must be an array.");
+
+            genericTypeMap = MapExtensionParameterGenericTypes(arrayTypeDef.ElementType, sourceArrayType.ElementType, genericTypeMap);
+        }
+        else if (funcParam is FuncType funcType)
+        {
+            if (sourceType is not FuncType sourceFuncType)
+                throw new InvalidOperationException("Generic type must be a function.");
+
+            foreach (var p in funcType.Parameters)
+            {
+                genericTypeMap = MapExtensionParameterGenericTypes(p, sourceFuncType, genericTypeMap);
+            }
+        }
+
+        return genericTypeMap;
+    }
+
+    /// <summary>
+    /// Detect kiểu generic từ tham số và map vào genericTypeMap
+    /// </summary>
+    /// <param name="funcParam"></param>
+    /// <param name="genericTypeMap"></param>
+    /// <returns></returns>
+    /// <exception cref="InvalidOperationException"></exception>
+    private static TypeDef GetRealType(TypeDef funcParam, Dictionary<string, TypeDef> genericTypeMap)
+    {
+        TypeDef realParamType = funcParam;
+        if (funcParam is GenericType gt)
+        {
+            realParamType = gt.GetRealType(genericTypeMap[gt.Name]);
+        }
+        else if (funcParam is ArrayTypeDef arrayTypeDef && arrayTypeDef.ElementType is GenericType arrayElType)
+        {
+            realParamType = new ArrayTypeDef
+            {
+                ElementType = arrayElType.GetRealType(genericTypeMap[arrayElType.Name]),
+                IsNullable = arrayTypeDef.IsNullable
+            };
+        }
+        else if (funcParam is FuncType funcType)
+        {
+            realParamType = funcType.GetRealType(genericTypeMap);
+        }
+
+        return realParamType;
+    }
+
+    private TypeDef ResolveElementAccess(
+        ElementAccessExpressionSyntax ea,
+        string param)
+    {
+        var parent = Resolve(ea.Expression, param);
+        if (parent is not ArrayTypeDef arrayTypeDef)
+        {
+            throw new InvalidOperationException("Element access is only supported on array types.");
+        }
+
+        // Kiếm tra xem có phải argument là số không
+        var arg = ea.ArgumentList.Arguments.First().Expression;
+        if (arg is not LiteralExpressionSyntax nle || nle.Kind() != SyntaxKind.NumericLiteralExpression)
+        {
+            throw new InvalidOperationException("Array index must be a numeric literal.");
+        }
+
+        return arrayTypeDef.ElementType;
+    }
+
+    /// <summary>
+    /// Kiểm tra kiểu a có gắn được cho kiểu b không
+    /// </summary>
+    /// <param name="a"></param>
+    /// <param name="b"></param>
+    /// <returns></returns>
+    private static bool CompareType(TypeDef a, TypeDef b)
+    {
+        if (a == null || b == null) return false;
+
+        if (a is PrimitiveTypeDef na && na.BaseType == "null")
+        {
+            return true;
+        }
+
+        if (a is ArrayTypeDef aa && b is ArrayTypeDef ab)
+        {
+            return CompareType(aa.ElementType, ab.ElementType);
+        }
+
+        if (a.IsNullable && !b.IsNullable)
+            return false;
+        if (a is PrimitiveTypeDef ta && b is PrimitiveTypeDef tb)
+        {
+            if (b.IsNullable && ta.BaseType == "null")
+                return true;
+
+            return ta.BaseType == tb.BaseType;
+        }
+        if (b is EnumTypeDef eb)
+        {
+            if (a is EnumTypeDef ea)
+            {
+                if (ea.Values.Count != eb.Values.Count)
+                    return false;
+                for (int i = 0; i < ea.Values.Count; i++)
+                {
+                    if (ea.Values[i] != eb.Values[i])
+                        return false;
+                }
+            }
+            else if (a is PrimitiveTypeDef pa)
+            {
+                //So sánh enum với primitive
+                if (pa.BaseType != "string" || !eb.Values.Contains(pa.Raw))
+                    return false;
+            }
+            return true;
+        }
+        if (b is ObjectSchemaDef ob && a is ObjectSchemaDef oa)
+        {
+            if (oa.Properties.Count != ob.Properties.Count)
+                return false;
+            foreach (var p in oa.Properties)
+            {
+                if (!ob.Properties.TryGetValue(p.Key, out var pb))
+                    return false;
+                if (!CompareType(p.Value, pb))
+                    return false;
+            }
+            return true;
+        }
+        if (a is FuncType fa && b is FuncType fb)
+        {
+            if (fa.Parameters.Count != fb.Parameters.Count)
+                return false;
+            for (int i = 0; i < fa.Parameters.Count; i++)
+            {
+                if (!CompareType(fa.Parameters[i], fb.Parameters[i]))
+                    return false;
+            }
+            if (!CompareType(fa.ReturnType, fb.ReturnType))
+                return false;
+            return true;
+        }
+        if (b is GenericType gb && gb.IsMatch(a))
+        {
+            return true;
+        }
+        return false;
+    }
+
+
+    private static AnalyzeResult Error(string message, List<SuggestionItem>? suggestions = null)
+    {
+        return new AnalyzeResult
+        {
+            IsValid = false,
+            Errors = { message },
+            Suggestions = suggestions ?? []
+        };
+    }
+}
+
+public abstract class TypeDef
+{
+    public bool IsNullable { get; init; }
+}
+
+public sealed class ArrayTypeDef : TypeDef
+{
+    public required TypeDef ElementType { get; init; }
+
+    public bool IsGenericType => ElementType is GenericType;
+}
+
+public sealed class PrimitiveTypeDef : TypeDef
+{
+    public string Raw { get; init; } = default!; // string, string?, string[], enum[X]
+    public string BaseType { get; init; } = default!;
+}
+
+public sealed class EnumTypeDef : TypeDef
+{
+    public List<string> Values { get; init; } = [];
+}
+
+public sealed class ObjectSchemaDef : TypeDef
+{
+    public Dictionary<string, TypeDef> Properties { get; init; } = new();
+}
+
+public sealed class GenericType : TypeDef
+{
+    public string Name { get; init; } = default!;
+
+    // Kiểm tra kiểu có khớp với GenericType không
+    public bool IsMatch(TypeDef other)
+    {
+        return other.IsNullable == IsNullable;
+    }
+
+    public TypeDef GetRealType(TypeDef typeDef, bool? isNullable = null)
+    {
+        var newIsNullable = isNullable ?? IsNullable;
+        if (typeDef is PrimitiveTypeDef primitiveTypeDef)
+        {
+            return new PrimitiveTypeDef
+            {
+                IsNullable = newIsNullable,
+                BaseType = primitiveTypeDef.BaseType,
+                Raw = primitiveTypeDef.BaseType + (newIsNullable ? "?" : "")
+            };
+        }
+        else if (typeDef is ObjectSchemaDef objectSchemaDef)
+        {
+            return new ObjectSchemaDef
+            {
+                IsNullable = newIsNullable,
+                Properties = objectSchemaDef.Properties
+            };
+        }
+        else if (typeDef is EnumTypeDef enumTypeDef)
+        {
+            return new EnumTypeDef
+            {
+                IsNullable = newIsNullable,
+                Values = enumTypeDef.Values
+            };
+        }
+        else if (typeDef is ArrayTypeDef arrayTypeDef)
+        {
+            return new ArrayTypeDef
+            {
+                IsNullable = newIsNullable,
+                ElementType = GetRealType(arrayTypeDef.ElementType, isNullable)
+            };
+        }
+        else if (typeDef is GenericType genericType)
+        {
+            return this;
+        }
+        //else if (typeDef is FuncType funcType)
+        //{
+        //    return funcType.GetRealType(typeDef);
+        //}
+        throw new InvalidOperationException("Unsupported TypeDef for GenericType substitution.");
+    }
+}
+
+public sealed class FuncType : TypeDef
+{
+    public List<TypeDef> Parameters { get; init; } = [];
+    public TypeDef ReturnType { get; init; } = default!;
+
+    public FuncType GetRealType(Dictionary<string, TypeDef> typeDefDict)
+    {
+        return new FuncType
+        {
+            IsNullable = this.IsNullable,
+            Parameters = this.Parameters.Select(p => 
+            {
+                if (p is GenericType gt)
+                    return gt.GetRealType(typeDefDict[gt.Name]);
+                return p;
+            }).ToList(),
+            ReturnType = (this.ReturnType is GenericType gr && typeDefDict.ContainsKey(gr.Name)) ?
+                gr.GetRealType(typeDefDict[gr.Name]) :
+                this.ReturnType
+        };
+    }
+}
+
+public sealed class FunctionSchema
+{
+    public string Name { get; init; } = default!;
+    public List<string> GenericTypes { get; init; } = [];
+    public TypeDef ReturnType { get; init; } = default!;
+    public List<TypeDef> Parameters { get; init; } = [];
+    public bool IsExtension { get; init; }
+}
+
+//public sealed class EnumSchema
+//{
+//    public string Name { get; init; } = default!;
+//    public List<string> Values { get; init; } = [];
+//}
+
+public sealed class ExpressionSchema
+{
+    public TypeDef RootObject { get; init; } = default!;
+    public List<FunctionSchema> Functions { get; init; } = [];
+    //public List<EnumSchema> Enums { get; init; } = [];
+}
+
+public class AnalyzeResult
+{
+    public bool IsValid { get; set; }
+    public TypeDef? ResultType { get; init; }
+    public List<string> Errors { get; init; } = [];
+    public List<SuggestionItem> Suggestions { get; init; } = [];
+}
+
+public sealed class SuggestionItem
+{
+    public string Label { get; init; } = default!;
+    public string InsertText { get; init; } = default!;
+    public string Kind { get; init; } = default!; // property | function | enum
+}
+
+public static class TypeRefParser
+{
+    public static TypeDef Parse(string raw, string[]? genericTypes = null)
+    {
+        var type = raw.Trim();
+        var isNullable = type.EndsWith("?") || raw == "null";
+        if (isNullable) type = type[..^1];
+
+        var isArray = type.EndsWith("[]");
+        if (isArray)
+        {
+            type = type[..^2];
+            return new ArrayTypeDef
+            {
+                IsNullable = isNullable,
+                ElementType = Parse(type, genericTypes)
+            };
+        }
+
+        var isEnum = type.StartsWith("(") && type.EndsWith(")");
+
+        if (isEnum)
+        {
+            var valuesRaw = type[1..^1];
+            var values = valuesRaw
+                .Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+                .Select(x => x.Trim('\''))
+                .ToList();
+            return new EnumTypeDef
+            {
+                IsNullable = isNullable,
+                Values = values
+            };
+        }
+        else
+        {
+            // Nếu là định dạng func<Type1, Type2, ..., TypeResult> thì tạo FuncType
+            if (type.StartsWith("func"))
+            {
+                // Phân tích các tham số và kiểu trả về
+                var genericArgs = type[5..^1].Split(',', StringSplitOptions.TrimEntries);
+                var funcType = new FuncType
+                {
+                    IsNullable = isNullable,
+                    Parameters = [],
+                    ReturnType = Parse(genericArgs[^1], genericTypes)
+                };
+
+                for (int i = 0; i < genericArgs.Length - 1; i++)
+                {
+                    funcType.Parameters.Add(Parse(genericArgs[i], genericTypes));
+                }
+
+                return funcType;
+            }
+            else if (genericTypes == null || genericTypes.Length == 0 || !genericTypes.Contains(type))
+            {
+                return new PrimitiveTypeDef
+                {
+                    Raw = raw,
+                    IsNullable = isNullable,
+                    BaseType = type
+                };
+            }
+            else
+            {
+                return new GenericType
+                {
+                    IsNullable = isNullable,
+                    Name = type
+                };
+            }
+        }
+    }
+
+    public static TypeDef? Parse(LiteralExpressionSyntax literalExpressionSyntax)
+    {
+        switch (literalExpressionSyntax.Kind())
+        {
+            case SyntaxKind.NumericLiteralExpression:
+                return new PrimitiveTypeDef
+                {
+                    Raw = literalExpressionSyntax.Token.ValueText,
+                    IsNullable = false,
+                    BaseType = "int"
+                };
+            case SyntaxKind.StringLiteralExpression:
+                return new PrimitiveTypeDef
+                {
+                    Raw = literalExpressionSyntax.Token.ValueText,
+                    IsNullable = false,
+                    BaseType = "string"
+                };
+            case SyntaxKind.TrueLiteralExpression:
+            case SyntaxKind.FalseLiteralExpression:
+                return new PrimitiveTypeDef
+                {
+                    Raw = literalExpressionSyntax.Token.ValueText,
+                    IsNullable = false,
+                    BaseType = "bool"
+                };
+            case SyntaxKind.NullLiteralExpression:
+                return new PrimitiveTypeDef
+                {
+                    Raw = literalExpressionSyntax.Token.ValueText,
+                    IsNullable = true,
+                    BaseType = "null"
+                };
+        }
+        return null;
+    }
+}