[unity] 修复: 在AddRefType中的循环引用和GenericArguments丢失 (Tencent#176)

* [unity] 修复: 在AddRefType中的循环引用和GenericArguments丢失 * Add files via upload * Add files via upload
FishOrBear · Mar 15, 2021 · 3944c73 · 3944c73
1 parent 3eb2b79
commit 3944c73
Showing 1 changed file with 28 additions and 26 deletions.
diff --git a/unity/Assets/Puerts/Src/Editor/Generator.cs b/unity/Assets/Puerts/Src/Editor/Generator.cs
@@ -219,17 +219,17 @@ static MethodGenInfo ToMethodGenInfo(Type type, bool isCtor, List<MethodBase> ov
             {
                 ret.AddRange(ToOverloadGenInfo(iBase));
             }
-            if (type.IsValueType && isCtor)//值类型添加无参构造
-            {
-                if (!overloads.Exists(m => m.GetParameters().Length == 0))
-                {
-                    ret.Add(new OverloadGenInfo()
-                    {
-                        ParameterInfos = new ParameterGenInfo[] { },
-                        TypeName = type.GetFriendlyName(),
-                        IsVoid = false
-                    });
-                }
+            if (type.IsValueType && isCtor)//值类型添加无参构造
+            {
+                if (!overloads.Exists(m => m.GetParameters().Length == 0))
+                {
+                    ret.Add(new OverloadGenInfo()
+                    {
+                        ParameterInfos = new ParameterGenInfo[] { },
+                        TypeName = type.GetFriendlyName(),
+                        IsVoid = false
+                    });
+                }
             }
             var result = new MethodGenInfo()
             {
@@ -758,21 +758,22 @@ static bool isFiltered(MemberInfo mb)
             return false;
         }
 
-        static void AddRefType(HashSet<Type> refTypes, Type type)
+        static void AddRefType(HashSet<Type> workTypes, HashSet<Type> refTypes, Type type)
         {
+            if(workTypes.Contains(type)) return;
+            workTypes.Add(type);
+
             var rawType = GetRawType(type);
-
-			//移动到此处进行判断, 避免递归进入死循环
-            if (refTypes.Contains(rawType) || type.IsPointer || rawType.IsPointer) return;
-
+
             if (type.IsGenericType)
             {
                 foreach (var gt in type.GetGenericArguments())
                 {
-                    AddRefType(refTypes, gt);
+                    AddRefType(workTypes, refTypes, gt);
                 }
             }
 
+            if (refTypes.Contains(rawType) || type.IsPointer || rawType.IsPointer) return;
             if (!rawType.IsGenericParameter)
             {
                 refTypes.Add(rawType);
@@ -781,17 +782,17 @@ static void AddRefType(HashSet<Type> refTypes, Type type)
             if (IsDelegate(type) && type != typeof(Delegate) && type != typeof(MulticastDelegate))
             {
                 MethodInfo delegateMethod = type.GetMethod("Invoke");
-                AddRefType(refTypes, delegateMethod.ReturnType);
+                AddRefType(workTypes, refTypes, delegateMethod.ReturnType);
                 foreach (var pinfo in delegateMethod.GetParameters())
                 {
-                    AddRefType(refTypes, pinfo.ParameterType);
+                    AddRefType(workTypes, refTypes, pinfo.ParameterType);
                 }
             }
 
             var baseType = type.BaseType;
             while (baseType != null)
             {
-                AddRefType(refTypes, baseType);
+                AddRefType(workTypes, refTypes, baseType);
                 baseType = baseType.BaseType;
             }
 
@@ -894,36 +895,37 @@ static TypingGenInfo ToTypingGenInfo(IEnumerable<Type> types)
         {
             HashSet<Type> genTypeSet = new HashSet<Type>();
 
+            HashSet<Type> workTypes = new HashSet<Type>();
             HashSet<Type> refTypes = new HashSet<Type>();
 
             foreach (var type in types)
             {
-                AddRefType(refTypes, type);
+                AddRefType(workTypes, refTypes, type);
                 var defType = type.IsGenericType ? type.GetGenericTypeDefinition() : type;
                 if (!genTypeSet.Contains(defType)) genTypeSet.Add(defType);
                 foreach (var field in type.GetFields(Flags))
                 {
-                    AddRefType(refTypes, field.FieldType);
+                    AddRefType(workTypes, refTypes, field.FieldType);
                 }
 
                 foreach(var method in type.GetMethods(Flags))
                 {
-                    AddRefType(refTypes, method.ReturnType);
+                    AddRefType(workTypes, refTypes, method.ReturnType);
                     foreach(var pinfo in method.GetParameters())
                     {
-                        AddRefType(refTypes, pinfo.ParameterType);
+                        AddRefType(workTypes, refTypes, pinfo.ParameterType);
                     }
                 }
                 foreach(var constructor in type.GetConstructors())
                 {
                     foreach (var pinfo in constructor.GetParameters())
                     {
-                        AddRefType(refTypes, pinfo.ParameterType);
+                        AddRefType(workTypes, refTypes, pinfo.ParameterType);
                     }
                 }
             }
 
-            if (!genTypeSet.Contains(typeof(Array)) && !refTypes.Contains(typeof(Array))) AddRefType(refTypes, typeof(Array));
+            if (!genTypeSet.Contains(typeof(Array)) && !refTypes.Contains(typeof(Array))) AddRefType(workTypes, refTypes, typeof(Array));
 
             var tsTypeGenInfos = new Dictionary<string, TsTypeGenInfo>();
             foreach (var t in refTypes.Distinct())