organizing metadata: removed lambda_base.

neeraj31285 · neeraj31285 · commit eadead6a670b · 2025-11-18T22:49:38.000+05:30
diff --git a/ReflectionTemplateLib/rtl/detail/inc/FunctionCaller.hpp b/ReflectionTemplateLib/rtl/detail/inc/FunctionCaller.hpp
@@ -48,41 +48,41 @@ namespace rtl::detail
     template<class return_t> requires (member_kind == member::None && std::is_same_v<return_t, rtl::Return>)
     inline constexpr function<Return(args_t...)> HopFunction<member_kind, args_t...>::returnT() const
     {
-        function<Return(traits::normal_sign_t<args_t>...)> erasedFn;
-        initHopper(erasedFn);
-        return erasedFn;
+        function<Return(traits::normal_sign_t<args_t>...)> fn;
+        initHopper(fn);
+        return fn;
     }
 
 
     template<member member_kind, class ...args_t>
     template<class return_t> requires (member_kind == member::Static && std::is_same_v<return_t, rtl::Return>)
     inline constexpr const static_method<Return(args_t...)> HopFunction<member_kind, args_t...>::returnT() const
     {
-        static_method<Return(traits::normal_sign_t<args_t>...)> erasedFn;
-        initHopper(erasedFn);
-        return erasedFn;
+        static_method<Return(traits::normal_sign_t<args_t>...)> mth;
+        initHopper(mth);
+        return mth;
     }
 
+
     template<member member_kind, class ...args_t>
     template<class return_t> requires (member_kind == member::Static && !std::is_same_v<return_t, rtl::Return>)
     inline constexpr const static_method<return_t(args_t...)> HopFunction<member_kind, args_t...>::returnT() const
     {
-        static_method<return_t(args_t...)> fn;
+        static_method<return_t(args_t...)> mth;
         if (!m_argsTfnMeta.is_empty()) 
         {
             if (m_argsTfnMeta.get_member_kind() != member::Static) {
-                fn.set_init_error(error::InvalidNonStaticMethodCaller);
+                mth.set_init_error(error::InvalidNonStaticMethodCaller);
             }
-            else if (m_argsTfnMeta.get_member_kind() == member::Static) {
-                
-                const auto retId = traits::uid<return_t>::value;
-                return m_argsTfnMeta.get_lambda()
-                                    .template to_function<args_t...>()
-                                    .template get_hopper<return_t>(retId)
-                                    .f_ptr();
+            else if (m_argsTfnMeta.get_member_kind() == member::Static &&
+                     traits::uid<return_t>::value == m_argsTfnMeta.get_return_id()) 
+            {                
+                using function_t = dispatch::function_ptr<return_t, args_t...>;
+                auto fptr = static_cast<const function_t&>(m_argsTfnMeta.get_functor()).f_ptr();
+                return static_method<return_t(args_t...)>(fptr);
             }
         }
-        return fn;
+        return mth;
     }
 
 
@@ -93,15 +93,16 @@ namespace rtl::detail
         function<return_t(args_t...)> fn;
         if (!m_argsTfnMeta.is_empty()) 
         {
-            if (m_argsTfnMeta.get_member_kind() == member::Static) {
+            if (m_argsTfnMeta.get_member_kind() == member::Static) 
+            {
                 fn.set_init_error(error::InvalidStaticMethodCaller);
             }
-            else if (m_argsTfnMeta.get_member_kind() == member::None) {
-
-                const auto retId = traits::uid<return_t>::value;
-                return m_argsTfnMeta.get_lambda()
-                                    .template to_function<args_t...>()
-                                    .template get_hopper<return_t>(retId);
+            else if (m_argsTfnMeta.get_member_kind() == member::None && 
+                     traits::uid<return_t>::value == m_argsTfnMeta.get_return_id()) 
+            {
+                using function_t = dispatch::function_ptr<return_t, args_t...>;
+                auto fptr = static_cast<const function_t&>(m_argsTfnMeta.get_functor()).f_ptr();
+                return function<return_t(args_t...)>(fptr);
             }
         }
         return fn;
@@ -170,30 +171,30 @@ namespace rtl::detail
         //initializing pos '0' with empty 'type_meta'.
         std::vector<rtl::type_meta> overloadsFnMeta = { rtl::type_meta() };
 
-        for (auto& fnMeta : m_functorsMeta)
+        for (auto& ty_meta : m_functorsMeta)
         {
-            if (argsTfnMeta.is_empty() && strictArgsId == fnMeta.get_strict_args_id()) {
-                argsTfnMeta = fnMeta;
+            if (argsTfnMeta.is_empty() && strictArgsId == ty_meta.get_strict_args_id()) {
+                argsTfnMeta = ty_meta;
             }
-            if (normalArgsId == fnMeta.get_normal_args_id())
+            if (normalArgsId == ty_meta.get_normal_args_id())
             {
-                if (normalArgsId == fnMeta.get_strict_args_id()) {
+                if (normalArgsId == ty_meta.get_strict_args_id()) {
                     // same normal & strict ids, means no refs exists in target function's signature
                     // target's function signature is call by value, always at pos '0'.
                     // if doesn't exists, this pos is occupied by an empty 'type_meta'.
-                    overloadsFnMeta[0] = fnMeta;
+                    overloadsFnMeta[0] = ty_meta;
                 }
-                else if (!fnMeta.is_any_arg_ncref()) {
+                else if (!ty_meta.is_any_arg_ncref()) {
                     // its a const-ref-overload with no non-const-ref in signature, added from pos '1' onwards.
-                    overloadsFnMeta.push_back(fnMeta);
+                    overloadsFnMeta.push_back(ty_meta);
                 }
             }
         }
 
-        for (auto& fnMeta : m_functorsMeta) {
-            if (normalArgsId == fnMeta.get_normal_args_id() && fnMeta.is_any_arg_ncref()) {
+        for (auto& ty_meta : m_functorsMeta) {
+            if (normalArgsId == ty_meta.get_normal_args_id() && ty_meta.is_any_arg_ncref()) {
                 // any remaining overload, const/non-const ref added from pos '1' onwards.
-                overloadsFnMeta.push_back(fnMeta);
+                overloadsFnMeta.push_back(ty_meta);
             }
         }
         return { argsTfnMeta, overloadsFnMeta };
diff --git a/ReflectionTemplateLib/rtl/detail/inc/MethodInvoker.hpp b/ReflectionTemplateLib/rtl/detail/inc/MethodInvoker.hpp
@@ -164,9 +164,9 @@ namespace rtl::detail
     template<class return_t> requires (!traits::type_aware_v<record_t, return_t>)
     inline constexpr const method<record_t, return_t(args_t...)> HopMethod<record_t, args_t...>::returnT() const
     {
-        method<record_t, return_t(traits::normal_sign_t<args_t>...)> erasedMth;
-        initHopper<return_t>(erasedMth);
-        return erasedMth;
+        method<record_t, return_t(traits::normal_sign_t<args_t>...)> mth;
+        initHopper<return_t>(mth);
+        return mth;
     }
 
 
@@ -180,12 +180,11 @@ namespace rtl::detail
             if (m_argsTfnMeta.get_member_kind() == member::Static) {
                 mth.set_init_error(error::InvalidStaticMethodCaller);
             }
-            else {
+            else if(traits::uid<return_t>::value == m_argsTfnMeta.get_return_id()) {
 
-                const auto retId = traits::uid<return_t>::value;
-                return m_argsTfnMeta.get_lambda()
-                                    .template to_method<record_t, args_t...>()
-                                    .template get_hopper<return_t>(retId);
+                using method_t = dispatch::method_ptr<record_t, return_t, args_t...>;
+                auto fptr = static_cast<const method_t&>(m_argsTfnMeta.get_functor()).f_ptr();
+                return method<record_t, return_t(args_t...)>(fptr);
             }
         }
         return mth;
@@ -204,37 +203,37 @@ namespace rtl::detail
         //initializing pos '0' with empty 'type_meta'.
         std::vector<type_meta> overloadsFnMeta = { type_meta() };
 
-        for (auto& fnMeta : m_functorsMeta)
+        for (auto& ty_meta : m_functorsMeta)
         {
             if constexpr (!std::is_same_v<record_t, RObject>)
             {
-                if (recordId != fnMeta.get_record_id()) {
+                if (recordId != ty_meta.get_record_id()) {
                     return { argsTfnMeta, overloadsFnMeta };
                 }
             }
 
-            if (argsTfnMeta.is_empty() && strictArgsId == fnMeta.get_strict_args_id()) {
-                argsTfnMeta = fnMeta;
+            if (argsTfnMeta.is_empty() && strictArgsId == ty_meta.get_strict_args_id()) {
+                argsTfnMeta = ty_meta;
             }
-            if (normalArgsId == fnMeta.get_normal_args_id())
+            if (normalArgsId == ty_meta.get_normal_args_id())
             {
-                if (normalArgsId == fnMeta.get_strict_args_id()) {
+                if (normalArgsId == ty_meta.get_strict_args_id()) {
                     // same normal & strict ids, means no refs exists in target function's signature
                     // target's function signature is call by value, always at pos '0'.
                     // if doesn't exists, this pos is occupied by an empty 'type_meta'.
-                    overloadsFnMeta[0] = fnMeta;
+                    overloadsFnMeta[0] = ty_meta;
                 }
-                else if (!fnMeta.is_any_arg_ncref()) {
+                else if (!ty_meta.is_any_arg_ncref()) {
                     // its a const-ref-overload with no non-const-ref in signature, added from pos '1' onwards.
-                    overloadsFnMeta.push_back(fnMeta);
+                    overloadsFnMeta.push_back(ty_meta);
                 }
             }
         }
 
-        for (auto& fnMeta : m_functorsMeta) {
-            if (recordId == fnMeta.get_record_id() &&
-                normalArgsId == fnMeta.get_normal_args_id() && fnMeta.is_any_arg_ncref()) {
-                overloadsFnMeta.push_back(fnMeta);
+        for (auto& ty_meta : m_functorsMeta) {
+            if (recordId == ty_meta.get_record_id() &&
+                normalArgsId == ty_meta.get_normal_args_id() && ty_meta.is_any_arg_ncref()) {
+                overloadsFnMeta.push_back(ty_meta);
             }
         }
         return { argsTfnMeta, overloadsFnMeta };
diff --git a/ReflectionTemplateLib/rtl/inc/type_meta.h b/ReflectionTemplateLib/rtl/inc/type_meta.h
@@ -38,6 +38,7 @@ namespace rtl
 		GETTER(std::string, _return_str, m_functor->get().m_return_str)
 		GETTER_CREF(std::vector<std::size_t>, _args_id_arr, m_functor->get().m_args_type_ids)
 		
+		GETTER(traits::uid_t, _return_id, m_functor->get().m_return_id)
 		GETTER(traits::uid_t, _record_id, m_functor->get().m_record_id)
 		GETTER(traits::uid_t, _normal_args_id, m_functor->get().m_normal_args_id)
 		GETTER(traits::uid_t, _strict_args_id, m_functor->get().m_strict_args_id)
@@ -59,18 +60,6 @@ namespace rtl
 		template<class record_t, class ...signature_t>
 		static type_meta add_constructor(std::size_t p_index);
 
-		template<class ..._signature>
-		using lambda_fn_t = dispatch::lambda_function<_signature...>;
-
-		template<class rec_t, class ..._signature>
-		using lambda_mth_t = dispatch::lambda_method<rec_t, _signature...>;
-
-		template<class ...args_t>
-		constexpr const lambda_fn_t<args_t...>* get_lambda_function(std::size_t p_args_id = 0) const;
-
-		template<class record_t, class ...args_t>
-		constexpr const lambda_mth_t<record_t, args_t...>* get_lambda_method(std::size_t p_recordId = 0, std::size_t p_args_id = 0) const;
-
 	private:
 
 		using functor_t = std::optional<std::reference_wrapper<const dispatch::functor>>;
diff --git a/ReflectionTemplateLib/rtl/inc/type_meta.hpp b/ReflectionTemplateLib/rtl/inc/type_meta.hpp
@@ -24,18 +24,6 @@
 
 namespace rtl
 {
-	template<class ...args_t>
-	inline constexpr const type_meta::lambda_fn_t<args_t...>* type_meta::get_lambda_function(std::size_t p_argsId) const
-	{
-		return m_functor->get().m_lambda->to_function<args_t...>(p_argsId);
-	}
-
-	template<class record_t, class ...args_t>
-	inline constexpr const type_meta::lambda_mth_t<record_t, args_t...>* type_meta::get_lambda_method(std::size_t p_recordId, std::size_t p_argsId) const
-	{
-		return m_functor->get().m_lambda->to_method<record_t, args_t...>(p_recordId, p_argsId);
-	}
-
 	template<class return_t, class ...signature_t>
 	inline type_meta type_meta::add_function(return_t(*p_fptr)(signature_t...), traits::uid_t p_record_uid, detail::member p_member_kind, std::size_t p_index)
 	{

Original file line number	Diff line number	Diff line change
`@@ -48,41 +48,41 @@ namespace rtl::detail`
`48`	`48`	`template<class return_t> requires (member_kind == member::None && std::is_same_v<return_t, rtl::Return>)`
`49`	`49`	`inline constexpr function<Return(args_t...)> HopFunction<member_kind, args_t...>::returnT() const`
`50`	`50`	`{`
`51`		`- function<Return(traits::normal_sign_t<args_t>...)> erasedFn;`
`52`		`- initHopper(erasedFn);`
`53`		`- return erasedFn;`
	`51`	`+ function<Return(traits::normal_sign_t<args_t>...)> fn;`
	`52`	`+ initHopper(fn);`
	`53`	`+ return fn;`
`54`	`54`	`}`
`55`	`55`
`56`	`56`
`57`	`57`	`template<member member_kind, class ...args_t>`
`58`	`58`	`template<class return_t> requires (member_kind == member::Static && std::is_same_v<return_t, rtl::Return>)`
`59`	`59`	`inline constexpr const static_method<Return(args_t...)> HopFunction<member_kind, args_t...>::returnT() const`
`60`	`60`	`{`
`61`		`- static_method<Return(traits::normal_sign_t<args_t>...)> erasedFn;`
`62`		`- initHopper(erasedFn);`
`63`		`- return erasedFn;`
	`61`	`+ static_method<Return(traits::normal_sign_t<args_t>...)> mth;`
	`62`	`+ initHopper(mth);`
	`63`	`+ return mth;`
`64`	`64`	`}`
`65`	`65`
	`66`	`+`
`66`	`67`	`template<member member_kind, class ...args_t>`
`67`	`68`	`template<class return_t> requires (member_kind == member::Static && !std::is_same_v<return_t, rtl::Return>)`
`68`	`69`	`inline constexpr const static_method<return_t(args_t...)> HopFunction<member_kind, args_t...>::returnT() const`
`69`	`70`	`{`
`70`		`- static_method<return_t(args_t...)> fn;`
	`71`	`+ static_method<return_t(args_t...)> mth;`
`71`	`72`	`if (!m_argsTfnMeta.is_empty())`
`72`	`73`	`{`
`73`	`74`	`if (m_argsTfnMeta.get_member_kind() != member::Static) {`
`74`		`- fn.set_init_error(error::InvalidNonStaticMethodCaller);`
	`75`	`+ mth.set_init_error(error::InvalidNonStaticMethodCaller);`
`75`	`76`	`}`
`76`		`- else if (m_argsTfnMeta.get_member_kind() == member::Static) {`
`77`		`-`
`78`		`- const auto retId = traits::uid<return_t>::value;`
`79`		`- return m_argsTfnMeta.get_lambda()`
`80`		`- .template to_function<args_t...>()`
`81`		`- .template get_hopper<return_t>(retId)`
`82`		`- .f_ptr();`
	`77`	`+ else if (m_argsTfnMeta.get_member_kind() == member::Static &&`
	`78`	`+ traits::uid<return_t>::value == m_argsTfnMeta.get_return_id())`
	`79`	`+ {`
	`80`	`+ using function_t = dispatch::function_ptr<return_t, args_t...>;`
	`81`	`+ auto fptr = static_cast<const function_t&>(m_argsTfnMeta.get_functor()).f_ptr();`
	`82`	`+ return static_method<return_t(args_t...)>(fptr);`
`83`	`83`	`}`
`84`	`84`	`}`
`85`		`- return fn;`
	`85`	`+ return mth;`
`86`	`86`	`}`
`87`	`87`
`88`	`88`
`@@ -93,15 +93,16 @@ namespace rtl::detail`
`93`	`93`	`function<return_t(args_t...)> fn;`
`94`	`94`	`if (!m_argsTfnMeta.is_empty())`
`95`	`95`	`{`
`96`		`- if (m_argsTfnMeta.get_member_kind() == member::Static) {`
	`96`	`+ if (m_argsTfnMeta.get_member_kind() == member::Static)`
	`97`	`+ {`
`97`	`98`	`fn.set_init_error(error::InvalidStaticMethodCaller);`
`98`	`99`	`}`
`99`		`- else if (m_argsTfnMeta.get_member_kind() == member::None) {`
`100`		`-`
`101`		`- const auto retId = traits::uid<return_t>::value;`
`102`		`- return m_argsTfnMeta.get_lambda()`
`103`		`- .template to_function<args_t...>()`
`104`		`- .template get_hopper<return_t>(retId);`
	`100`	`+ else if (m_argsTfnMeta.get_member_kind() == member::None &&`
	`101`	`+ traits::uid<return_t>::value == m_argsTfnMeta.get_return_id())`
	`102`	`+ {`
	`103`	`+ using function_t = dispatch::function_ptr<return_t, args_t...>;`
	`104`	`+ auto fptr = static_cast<const function_t&>(m_argsTfnMeta.get_functor()).f_ptr();`
	`105`	`+ return function<return_t(args_t...)>(fptr);`
`105`	`106`	`}`
`106`	`107`	`}`
`107`	`108`	`return fn;`
`@@ -170,30 +171,30 @@ namespace rtl::detail`
`170`	`171`	`//initializing pos '0' with empty 'type_meta'.`
`171`	`172`	`std::vector<rtl::type_meta> overloadsFnMeta = { rtl::type_meta() };`
`172`	`173`
`173`		`- for (auto& fnMeta : m_functorsMeta)`
	`174`	`+ for (auto& ty_meta : m_functorsMeta)`
`174`	`175`	`{`
`175`		`- if (argsTfnMeta.is_empty() && strictArgsId == fnMeta.get_strict_args_id()) {`
`176`		`- argsTfnMeta = fnMeta;`
	`176`	`+ if (argsTfnMeta.is_empty() && strictArgsId == ty_meta.get_strict_args_id()) {`
	`177`	`+ argsTfnMeta = ty_meta;`
`177`	`178`	`}`
`178`		`- if (normalArgsId == fnMeta.get_normal_args_id())`
	`179`	`+ if (normalArgsId == ty_meta.get_normal_args_id())`
`179`	`180`	`{`
`180`		`- if (normalArgsId == fnMeta.get_strict_args_id()) {`
	`181`	`+ if (normalArgsId == ty_meta.get_strict_args_id()) {`
`181`	`182`	`// same normal & strict ids, means no refs exists in target function's signature`
`182`	`183`	`// target's function signature is call by value, always at pos '0'.`
`183`	`184`	`// if doesn't exists, this pos is occupied by an empty 'type_meta'.`
`184`		`- overloadsFnMeta[0] = fnMeta;`
	`185`	`+ overloadsFnMeta[0] = ty_meta;`
`185`	`186`	`}`
`186`		`- else if (!fnMeta.is_any_arg_ncref()) {`
	`187`	`+ else if (!ty_meta.is_any_arg_ncref()) {`
`187`	`188`	`// its a const-ref-overload with no non-const-ref in signature, added from pos '1' onwards.`
`188`		`- overloadsFnMeta.push_back(fnMeta);`
	`189`	`+ overloadsFnMeta.push_back(ty_meta);`
`189`	`190`	`}`
`190`	`191`	`}`
`191`	`192`	`}`
`192`	`193`
`193`		`- for (auto& fnMeta : m_functorsMeta) {`
`194`		`- if (normalArgsId == fnMeta.get_normal_args_id() && fnMeta.is_any_arg_ncref()) {`
	`194`	`+ for (auto& ty_meta : m_functorsMeta) {`
	`195`	`+ if (normalArgsId == ty_meta.get_normal_args_id() && ty_meta.is_any_arg_ncref()) {`
`195`	`196`	`// any remaining overload, const/non-const ref added from pos '1' onwards.`
`196`		`- overloadsFnMeta.push_back(fnMeta);`
	`197`	`+ overloadsFnMeta.push_back(ty_meta);`
`197`	`198`	`}`
`198`	`199`	`}`
`199`	`200`	`return { argsTfnMeta, overloadsFnMeta };`
Original file line number	Diff line number	Diff line change
`@@ -164,9 +164,9 @@ namespace rtl::detail`
`164`	`164`	`template<class return_t> requires (!traits::type_aware_v<record_t, return_t>)`
`165`	`165`	`inline constexpr const method<record_t, return_t(args_t...)> HopMethod<record_t, args_t...>::returnT() const`
`166`	`166`	`{`
`167`		`- method<record_t, return_t(traits::normal_sign_t<args_t>...)> erasedMth;`
`168`		`- initHopper<return_t>(erasedMth);`
`169`		`- return erasedMth;`
	`167`	`+ method<record_t, return_t(traits::normal_sign_t<args_t>...)> mth;`
	`168`	`+ initHopper<return_t>(mth);`
	`169`	`+ return mth;`
`170`	`170`	`}`
`171`	`171`
`172`	`172`
`@@ -180,12 +180,11 @@ namespace rtl::detail`
`180`	`180`	`if (m_argsTfnMeta.get_member_kind() == member::Static) {`
`181`	`181`	`mth.set_init_error(error::InvalidStaticMethodCaller);`
`182`	`182`	`}`
`183`		`- else {`
	`183`	`+ else if(traits::uid<return_t>::value == m_argsTfnMeta.get_return_id()) {`
`184`	`184`
`185`		`- const auto retId = traits::uid<return_t>::value;`
`186`		`- return m_argsTfnMeta.get_lambda()`
`187`		`- .template to_method<record_t, args_t...>()`
`188`		`- .template get_hopper<return_t>(retId);`
	`185`	`+ using method_t = dispatch::method_ptr<record_t, return_t, args_t...>;`
	`186`	`+ auto fptr = static_cast<const method_t&>(m_argsTfnMeta.get_functor()).f_ptr();`
	`187`	`+ return method<record_t, return_t(args_t...)>(fptr);`
`189`	`188`	`}`
`190`	`189`	`}`
`191`	`190`	`return mth;`
`@@ -204,37 +203,37 @@ namespace rtl::detail`
`204`	`203`	`//initializing pos '0' with empty 'type_meta'.`
`205`	`204`	`std::vector<type_meta> overloadsFnMeta = { type_meta() };`
`206`	`205`
`207`		`- for (auto& fnMeta : m_functorsMeta)`
	`206`	`+ for (auto& ty_meta : m_functorsMeta)`
`208`	`207`	`{`
`209`	`208`	`if constexpr (!std::is_same_v<record_t, RObject>)`
`210`	`209`	`{`
`211`		`- if (recordId != fnMeta.get_record_id()) {`
	`210`	`+ if (recordId != ty_meta.get_record_id()) {`
`212`	`211`	`return { argsTfnMeta, overloadsFnMeta };`
`213`	`212`	`}`
`214`	`213`	`}`
`215`	`214`
`216`		`- if (argsTfnMeta.is_empty() && strictArgsId == fnMeta.get_strict_args_id()) {`
`217`		`- argsTfnMeta = fnMeta;`
	`215`	`+ if (argsTfnMeta.is_empty() && strictArgsId == ty_meta.get_strict_args_id()) {`
	`216`	`+ argsTfnMeta = ty_meta;`
`218`	`217`	`}`
`219`		`- if (normalArgsId == fnMeta.get_normal_args_id())`
	`218`	`+ if (normalArgsId == ty_meta.get_normal_args_id())`
`220`	`219`	`{`
`221`		`- if (normalArgsId == fnMeta.get_strict_args_id()) {`
	`220`	`+ if (normalArgsId == ty_meta.get_strict_args_id()) {`
`222`	`221`	`// same normal & strict ids, means no refs exists in target function's signature`
`223`	`222`	`// target's function signature is call by value, always at pos '0'.`
`224`	`223`	`// if doesn't exists, this pos is occupied by an empty 'type_meta'.`
`225`		`- overloadsFnMeta[0] = fnMeta;`
	`224`	`+ overloadsFnMeta[0] = ty_meta;`
`226`	`225`	`}`
`227`		`- else if (!fnMeta.is_any_arg_ncref()) {`
	`226`	`+ else if (!ty_meta.is_any_arg_ncref()) {`
`228`	`227`	`// its a const-ref-overload with no non-const-ref in signature, added from pos '1' onwards.`
`229`		`- overloadsFnMeta.push_back(fnMeta);`
	`228`	`+ overloadsFnMeta.push_back(ty_meta);`
`230`	`229`	`}`
`231`	`230`	`}`
`232`	`231`	`}`
`233`	`232`
`234`		`- for (auto& fnMeta : m_functorsMeta) {`
`235`		`- if (recordId == fnMeta.get_record_id() &&`
`236`		`- normalArgsId == fnMeta.get_normal_args_id() && fnMeta.is_any_arg_ncref()) {`
`237`		`- overloadsFnMeta.push_back(fnMeta);`
	`233`	`+ for (auto& ty_meta : m_functorsMeta) {`
	`234`	`+ if (recordId == ty_meta.get_record_id() &&`
	`235`	`+ normalArgsId == ty_meta.get_normal_args_id() && ty_meta.is_any_arg_ncref()) {`
	`236`	`+ overloadsFnMeta.push_back(ty_meta);`
`238`	`237`	`}`
`239`	`238`	`}`
`240`	`239`	`return { argsTfnMeta, overloadsFnMeta };`