allow expansion of string.format arguments by fmt

Author: CppCXY

EmmyLua/CodeAnalysis/Compilation/Analyzer/DeclarationAnalyzer/AttachDeclarationAnalyzer.cs

@@ -77,7 +77,7 @@ private void AnalyzeGeneralDeclaration(LuaSyntaxElement attachedElement, List<Lu
             if (nameTypeDefine is { Name.RepresentText: { } name } &&
                 declarations.FirstOrDefault() is { } firstDeclaration)
             {
-                firstDeclaration.Info = firstDeclaration.Info with { DeclarationType = new LuaNamedType(name) };
+                firstDeclaration.Info = firstDeclaration.Info with { DeclarationType = LuaNamedType.Create(name) };
                 return;
             }
 

EmmyLua/CodeAnalysis/Compilation/Infer/GenericInfer.cs

@@ -1,4 +1,6 @@
-using EmmyLua.CodeAnalysis.Compilation.Search;
+using EmmyLua.CodeAnalysis.Common;
+using EmmyLua.CodeAnalysis.Compilation.Declaration;
+using EmmyLua.CodeAnalysis.Compilation.Search;
 using EmmyLua.CodeAnalysis.Compilation.Type;
 using EmmyLua.CodeAnalysis.Syntax.Node.SyntaxNodes;
 
@@ -12,19 +14,42 @@ public static void InferByExpr(
         TypeSubstitution substitution,
         SearchContext context)
     {
-        if (type is LuaTemplateType templateType && expr is LuaLiteralExprSyntax
-            {
-                Literal: LuaStringToken { } stringToken
-            })
+        if (SpecialInferByExpr(type, expr, substitution, context))
         {
-            substitution.Add(templateType.TemplateName, new LuaNamedType(templateType.PrefixName + stringToken.Value));
             return;
         }
 
         var exprType = context.InferAndUnwrap(expr);
         InferByType(type, exprType, substitution, context);
     }
 
+    private static bool SpecialInferByExpr(
+        LuaType type,
+        LuaExprSyntax expr,
+        TypeSubstitution substitution,
+        SearchContext context)
+    {
+        if (type is LuaTemplateType templateType && expr is LuaLiteralExprSyntax
+            {
+                Literal: LuaStringToken { } stringToken1
+            })
+        {
+            substitution.Add(templateType.TemplateName, new LuaNamedType(templateType.PrefixName + stringToken1.Value));
+            return true;
+        }
+
+        if (type is LuaGenericType { Name: "strFmt" } genericType && expr is LuaLiteralExprSyntax
+            {
+                Literal: LuaStringToken { } stringToken2
+            })
+        {
+            StrFmtInstantiateByString(genericType, stringToken2.Value, substitution, context);
+            return true;
+        }
+
+        return false;
+    }
+
     public static void InferByExpandTypeAndExprs(
         LuaExpandType expandType,
         IEnumerable<LuaExprSyntax> expr,
@@ -320,4 +345,70 @@ private static void TupleTypeInstantiateByType(
             }
         }
     }
+
+    private static void StrFmtInstantiateByString(
+        LuaGenericType genericType,
+        string fmt,
+        TypeSubstitution substitution,
+        SearchContext context)
+    {
+        var firstTemp = genericType.GenericArgs.FirstOrDefault();
+        if (firstTemp is not LuaNamedType templateName)
+        {
+            return;
+        }
+
+        var spreadParameter = new List<IDeclaration>();
+        for(var i = 0; i < fmt.Length; i++)
+        {
+            var ch = fmt[i];
+            if (fmt[i] == '%')
+            {
+                if (i + 1 < fmt.Length)
+                {
+                    var nextCh = fmt[i + 1];
+                    if (nextCh == '%')
+                    {
+                        i++;
+                    }
+                    else
+                    {
+                        var index = i + 1;
+                        while (index < fmt.Length && char.IsDigit(fmt[index]))
+                        {
+                            index++;
+                        }
+
+                        if (index < fmt.Length)
+                        {
+                            var type = fmt[index];
+                            if (type is 's' or 'q')
+                            {
+                                spreadParameter.Add(new LuaDeclaration(
+                                    $"%{type}",
+                                    new VirtualInfo(Builtin.Any)
+                                    ));
+                            }
+                            else if (type is 'c' or 'd' or 'i' or 'u' or 'x' or 'X' or 'o')
+                            {
+                                spreadParameter.Add(new LuaDeclaration(
+                                    $"%{type}",
+                                    new VirtualInfo(Builtin.Integer)
+                                    ));
+                            }
+                            else if (type is 'A' or 'a' or 'E' or 'e' or 'f' or 'G' or 'g')
+                            {
+                                spreadParameter.Add(new LuaDeclaration(
+                                    $"%{type}",
+                                    new VirtualInfo(Builtin.Number)
+                                    ));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        substitution.AddSpreadParameter(templateName.Name, spreadParameter);
+    }
 }

EmmyLua/CodeAnalysis/Compilation/Type/LuaTypes.cs

@@ -53,6 +53,17 @@ public class LuaNamedType(
     LuaTypeAttribute attribute = LuaTypeAttribute.HasMember | LuaTypeAttribute.CanCall | LuaTypeAttribute.CanIndex)
     : LuaType(attribute), IEquatable<LuaNamedType>
 {
+    public static LuaNamedType Create(string name, LuaTypeAttribute attribute = LuaTypeAttribute.HasMember | LuaTypeAttribute.CanCall | LuaTypeAttribute.CanIndex)
+    {
+        var buildType = Builtin.FromName(name);
+        if (buildType is not null)
+        {
+            return buildType;
+        }
+
+        return new LuaNamedType(name, attribute);
+    }
+
     public string Name { get; } = name;
 
     public NamedTypeKind GetTypeKind(SearchContext context)

EmmyLua/Resources/std/string.lua

@@ -83,6 +83,10 @@ function string.dump(func, strip) end
 ---@return number, number, string
 function string.find(s, pattern, init, plain) end
 
+--- a built-in type
+--- represents a format string
+---@class strFmt<T> : string
+
 ---
 --- Returns a formatted version of its variable number of arguments following
 --- the description given in its first argument (which must be a string). The
@@ -112,10 +116,12 @@ function string.find(s, pattern, init, plain) end
 --- converted to one following the same rules of `tostring`. If the option
 --- has any modifier (flags, width, length), the string argument should not
 --- contain embedded zeros.
----@param formatstring string
----@param ... any
+---@generic T
+---@param fmt strFmt<T>
+---@param ... T...
 ---@return string
-function string.format(formatstring, ...) end
+---@nodiscard
+function string.format(fmt, ...) end
 
 ---
 --- Returns an iterator function that, each time it is called, returns the