Fix references

coreapi/help/doc/sphinx/class_page.mustache

@@ -1,13 +1,13 @@
+{{#hasNamespaceDeclarator}}
+.. {{#write_declarator}}namespace{{/write_declarator}}:: {{{namespace}}}
+	{{#isJava}}
+	:noindex:
+	{{/isJava}}
+{{/hasNamespaceDeclarator}}
+
 {{#make_chapter}}{{{className}}} class{{/make_chapter}}
 
-{{#isNotJava}}
-.. {{#write_declarator}}class{{/write_declarator}}:: {{{fullClassName}}}
-{{/isNotJava}}
-{{#isJava}}
-.. java:package:: {{{namespace}}}
-
-.. java:type:: public interface {{{className}}};
-{{/isJava}}
+.. {{#write_declarator}}class{{/write_declarator}}:: {{{classDeclaration}}}
 	
 	{{#briefDoc}}
 	{{#lines}}
@@ -24,6 +24,14 @@
 	{{{selector}}}
 
 
+{{#hasNamespaceDeclarator}}
+.. {{#write_declarator}}namespace{{/write_declarator}}:: {{{fullClassName}}}
+	{{#isJava}}
+	:noindex:
+	{{/isJava}}
+{{/hasNamespaceDeclarator}}
+
+
 Summary
 =======
 
@@ -63,6 +71,9 @@ Properties
 
 {{#hasNamespaceDeclarator}}
 .. {{#write_declarator}}namespace{{/write_declarator}}:: {{{fullClassName}}}
+	{{#isJava}}
+	:noindex:
+	{{/isJava}}
 {{/hasNamespaceDeclarator}}
 
 {{#getter}}
@@ -110,6 +121,9 @@ Public methods
 
 {{#hasNamespaceDeclarator}}
 .. {{#write_declarator}}namespace{{/write_declarator}}:: {{{fullClassName}}}
+	{{#isJava}}
+	:noindex:
+	{{/isJava}}
 {{/hasNamespaceDeclarator}}
 
 {{#methods}}
@@ -138,6 +152,9 @@ Class methods
 
 {{#hasNamespaceDeclarator}}
 .. {{#write_declarator}}namespace{{/write_declarator}}:: {{{fullClassName}}}
+	{{#isJava}}
+	:noindex:
+	{{/isJava}}
 {{/hasNamespaceDeclarator}}
 
 {{#classMethods}}

coreapi/help/doc/sphinx/enums_page.mustache

@@ -1,7 +1,19 @@
+{{#namespace}}
+.. {{#write_declarator}}namespace{{/write_declarator}}:: {{{namespace}}}
+	{{#isJava}}
+	:noindex:
+	{{/isJava}}
+{{/namespace}}
+
 {{#enums}}
 {{{sectionName}}}
 
-.. {{#write_declarator}}enum{{/write_declarator}}:: {{{fullName}}}
+{{#isNotJava}}
+	.. {{#write_declarator}}enum{{/write_declarator}}:: {{{fullName}}}
+{{/isNotJava}}
+{{#isJava}}
+.. java:type:: public enum {{{name}}};
+{{/isJava}}
 	
 	{{#briefDesc}}
 	{{#lines}}
@@ -11,10 +23,7 @@
 	
 	{{{selector}}}
 	
-	{{#hasNamespaceDeclarator}}
-	.. {{#write_declarator}}namespace{{/write_declarator}}:: {{{namespace}}}
-	{{/hasNamespaceDeclarator}}
-	
+	{{#isNotJava}}
 	{{#enumerators}}
 	.. {{#write_declarator}}enumerator{{/write_declarator}}:: {{{name}}}{{#value}} = {{{value}}}{{/value}}
 		
@@ -27,4 +36,5 @@
 		{{{selector}}}
 	
 	{{/enumerators}}
+	{{/isNotJava}}
 {{/enums}}

coreapi/help/doc/sphinx/gendoc.py

@@ -162,6 +162,14 @@ class SphinxPage(object):
 	@property
 	def docTranslator(self):
 		return self.lang.docTranslator
+
+	@property
+	def isJava(self):
+		return self.lang.langCode == 'Java'
+
+	@property
+	def isNotJava(self):
+		return not self.isJava
 	
 	def make_chapter(self):
 		return lambda text: RstTools.make_chapter(pystache.render(text, self))
@@ -193,9 +201,7 @@ class SphinxPage(object):
 				link = lang.displayName
 			else:
 				link = ref.translate(lang.docTranslator, label=lang.displayName)
-			
 			links.append(link)
-		
 		return ' '.join(links)
 	
 	@staticmethod
@@ -213,9 +219,10 @@ class IndexPage(SphinxPage):
 
 
 class EnumsPage(SphinxPage):
-	def __init__(self, lang, langs, enums):
+	def __init__(self, lang, langs, api):
 		SphinxPage.__init__(self, lang, langs, 'enums.rst')
-		self._translate_enums(enums)
+		self.namespace = api.namespace.name.translate(lang.nameTranslator) if lang.langCode != 'C' else None
+		self._translate_enums(api.namespace.enums)
 	
 	def _translate_enums(self, enums):
 		self.enums = []
@@ -227,7 +234,6 @@ class EnumsPage(SphinxPage):
 				'enumerators'  : self._translate_enum_values(enum),
 				'selector'    : self._make_selector(enum)
 			}
-			translatedEnum['namespace'] = self._get_translated_namespace(enum) if self.lang.langCode == 'Cpp' else translatedEnum['fullName']
 			translatedEnum['sectionName'] = RstTools.make_section(translatedEnum['name'])
 			self.enums.append(translatedEnum)
 	
@@ -249,7 +255,8 @@ class ClassPage(SphinxPage):
 	def __init__(self, _class, lang, langs):
 		filename = SphinxPage._classname_to_filename(_class.name)
 		SphinxPage.__init__(self, lang, langs, filename)
-		self.namespace = self._get_translated_namespace(_class)
+		namespace = _class.find_first_ancestor_by_type(abstractapi.Namespace)
+		self.namespace = namespace.name.translate(self.lang.nameTranslator, recursive=True)
 		self.className = _class.name.translate(self.lang.nameTranslator)
 		self.fullClassName = _class.name.translate(self.lang.nameTranslator, recursive=True)
 		self.briefDoc = _class.briefDescription.translate(self.docTranslator)
@@ -258,6 +265,10 @@ class ClassPage(SphinxPage):
 		self.methods = self._translate_methods(_class.instanceMethods)
 		self.classMethods = self._translate_methods(_class.classMethods)
 		self.selector = self._make_selector(_class)
+
+	@property
+	def classDeclaration(self):
+		return 'public interface {0}'.format(self.className) if self.lang.langCode == 'Java' else self.className
 	
 	@property
 	def hasMethods(self):
@@ -276,11 +287,12 @@ class ClassPage(SphinxPage):
 		for property_ in properties:
 			propertyAttr = {
 				'name'         : property_.name.translate(self.lang.nameTranslator),
-				'ref_label'    : '{0}_{1}'.format(self.lang.langCode, property_.name.to_snake_case(fullName=True)),
 				'getter'       : self._translate_method(property_.getter) if property_.getter is not None else None,
 				'setter'       : self._translate_method(property_.setter) if property_.setter is not None else None
 			}
 			propertyAttr['title'] = RstTools.make_subsubsection(propertyAttr['name'])
+			propertyAttr['ref_label'] = (self.lang.langCode + '_')
+			propertyAttr['ref_label'] += (property_.getter.name.to_snake_case(fullName=True) if property_.getter is not None else property_.setter.name.to_snake_case(fullName=True))
 			translatedProperties.append(propertyAttr)
 		return translatedProperties
 	
@@ -291,18 +303,16 @@ class ClassPage(SphinxPage):
 		return translatedMethods
 	
 	def _translate_method(self, method):
-		prototypeParams = {}
-		if self.lang.langCode == 'Cpp':
-			prototypeParams['showStdNs'] = True
+		namespace = method.find_first_ancestor_by_type(abstractapi.Class)
 		methAttr = {
-			'prototype'    : method.translate_as_prototype(self.lang.langTranslator, **prototypeParams),
+			'prototype'    : method.translate_as_prototype(self.lang.langTranslator, namespace=namespace),
 			'briefDoc'     : method.briefDescription.translate(self.docTranslator),
 			'detailedDoc'  : method.detailedDescription.translate(self.docTranslator),
 			'selector'     : self._make_selector(method)
 		}
 		reference = metadoc.FunctionReference(None)
 		reference.relatedObject = method
-		methAttr['link'] = reference.translate(self.lang.docTranslator)
+		methAttr['link'] = reference.translate(self.lang.docTranslator, namespace=method.find_first_ancestor_by_type(abstractapi.Class, abstractapi.Interface))
 		return methAttr
 	
 	@property
@@ -331,14 +341,6 @@ class ClassPage(SphinxPage):
 			table.addrow([method['link'], briefDoc])
 		return table
 
-	@property
-	def isJava(self):
-		return self.lang.langCode == 'Java'
-
-	@property
-	def isNotJava(self):
-		return not self.isJava
-
 
 class DocGenerator:
 	def __init__(self, api):
@@ -357,7 +359,7 @@ class DocGenerator:
 			if not os.path.exists(directory):
 				os.mkdir(directory)
 			
-			enumsPage = EnumsPage(lang, self.languages, self.api.namespace.enums)
+			enumsPage = EnumsPage(lang, self.languages, self.api)
 			enumsPage.write(directory)
 			
 			indexPage = IndexPage(lang, self.languages)

tools/abstractapi.py

@@ -949,15 +949,12 @@ class Translator:
 		except KeyError:
 			raise ValueError("Invalid language code: '{0}'".format(langCode))
 
-	def _get_object_name(self, obj):
-		return obj.desc.name if isinstance(obj, (EnumType, ClassType)) else obj.name
-
-	def _compute_namespace_name(self, namespace, obj):
-		if namespace is not None:
-			return namespace.name if namespace is not GlobalNs else None
-		else:
-			namespace = obj.find_first_ancestor_by_type(Enum, Class, Namespace, Interface)
-			return metaname.Name.find_common_parent(self._get_object_name(obj), namespace.name)
+	@staticmethod
+	def _namespace_to_name_translator_params(namespace):
+		return {
+			'recursive': True,
+			'topAncestor': namespace.name if namespace is not None else None
+		}
 
 
 class CLikeLangTranslator(Translator):
@@ -971,8 +968,11 @@ class CLikeLangTranslator(Translator):
 		else:
 			raise TypeError('invalid enumerator value type: {0}'.format(value))
 	
-	def translate_argument(self, argument, **kargs):
-		return '{0} {1}'.format(argument.type.translate(self, **kargs), argument.name.translate(self.nameTranslator))
+	def translate_argument(self, argument, hideArgName=False, namespace=None):
+		ret = argument.type.translate(self, namespace=namespace)
+		if not hideArgName:
+			ret += (' ' + argument.name.translate(self.nameTranslator))
+		return ret
 
 
 class CLangTranslator(CLikeLangTranslator):
@@ -982,19 +982,19 @@ class CLangTranslator(CLikeLangTranslator):
 		self.falseConstantToken = 'FALSE'
 		self.trueConstantToken = 'TRUE'
 	
-	def translate_base_type(self, _type):
+	def translate_base_type(self, _type, **kargs):
 		return _type.cDecl
 	
-	def translate_enum_type(self, _type):
+	def translate_enum_type(self, _type, **kargs):
 		return _type.cDecl
 	
-	def translate_class_type(self, _type):
+	def translate_class_type(self, _type, **kargs):
 		return _type.cDecl
 	
-	def translate_list_type(self, _type):
+	def translate_list_type(self, _type, **kargs):
 		return _type.cDecl
 	
-	def translate_enumerator_value(self, value):
+	def translate_enumerator_value(self, value, **kargs):
 		if value is None:
 			return None
 		elif isinstance(value, int):
@@ -1004,19 +1004,20 @@ class CLangTranslator(CLikeLangTranslator):
 		else:
 			raise TypeError('invalid enumerator value type: {0}'.format(value))
 	
-	def translate_method_as_prototype(self, method, **params):
+	def translate_method_as_prototype(self, method, hideArguments=False, hideArgNames=False, hideReturnType=False, stripDeclarators=False, namespace=None):
 		_class = method.find_first_ancestor_by_type(Class)
-		params = '{const}{className} *obj'.format(
-			className=_class.name.to_c(),
-			const='const ' if method.isconst else ''
-		)
-		for arg in method.args:
-			params += (', ' + arg.translate(self))
-		
-		return '{returnType} {name}({params})'.format(
-			returnType=method.returnType.translate(self),
+		params = []
+		if not hideArguments:
+			params.append('{const}{className} *obj'.format(
+				className=_class.name.to_c(),
+				const='const ' if method.isconst and not stripDeclarators else ''
+			))
+			for arg in method.args:
+				params.append(arg.translate(self, hideArgName=hideArgNames))
+		return '{returnType}{name}({params})'.format(
+			returnType=(method.returnType.translate(self) + ' ') if not hideReturnType else '',
 			name=method.name.translate(self.nameTranslator),
-			params=params
+			params=', '.join(params)
 		)
 
 
@@ -1028,7 +1029,7 @@ class CppLangTranslator(CLikeLangTranslator):
 		self.trueConstantToken = 'true'
 		self.ambigousTypes = []
 	
-	def translate_base_type(self, _type, showStdNs=True, namespace=None):
+	def translate_base_type(self, _type, namespace=None):
 		if _type.name == 'void':
 			if _type.isref:
 				return 'void *'
@@ -1058,14 +1059,11 @@ class CppLangTranslator(CLikeLangTranslator):
 		elif _type.name == 'status':
 			res = 'linphone::Status'
 		elif _type.name == 'string':
-			res = CppLangTranslator.prepend_std('string', showStdNs)
+			res = 'std::string'
 			if type(_type.parent) is Argument:
 				res += ' &'
 		elif _type.name == 'string_array':
-			res = '{0}<{1}>'.format(
-				CppLangTranslator.prepend_std('list', showStdNs),
-				CppLangTranslator.prepend_std('string', showStdNs)
-			)
+			res = 'std::list<std::string>'
 			if type(_type.parent) is Argument:
 				res += ' &'
 		else:
@@ -1085,81 +1083,50 @@ class CppLangTranslator(CLikeLangTranslator):
 			res += ' *'
 		return res
 	
-	def translate_enum_type(self, type_, showStdNs=True, namespace=None):
+	def translate_enum_type(self, type_, namespace=None):
 		if type_.desc is None:
 			raise TranslationError('{0} has not been fixed'.format(type_.name))
-		nsName = self._compute_namespace_name(namespace, type_)
-		return type_.desc.name.translate(self.nameTranslator, recursive=True, topAncestor=nsName)
+		return type_.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
 
-	def translate_class_type(self, type_, showStdNs=True, namespace=None):
+	def translate_class_type(self, type_, namespace=None):
 		if type_.desc is None:
 			raise TranslationError('{0} has not been fixed'.format(type_.name))
-		nsName = self._compute_namespace_name(namespace, type_)
-		res = type_.desc.name.translate(self.nameTranslator, recursive=True, topAncestor=nsName)
+		res = type_.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
 		
 		if type_.desc.refcountable:
 			if type_.isconst:
 				res = 'const ' + res
 			if type(type_.parent) is Argument:
-				return 'const {0}<{1}> &'.format(
-					CppLangTranslator.prepend_std('shared_ptr', showStdNs),
-					res
-				)
+				return 'const std::shared_ptr<{0}> &'.format(res)
 			else:
-				return '{0}<{1}>'.format(
-					CppLangTranslator.prepend_std('shared_ptr', showStdNs),
-					res
-				)
+				return 'std::shared_ptr<{0}>'.format(res)
 		else:
 			if type(type_.parent) is Argument:
 				return 'const {0} &'.format(res)
 			else:
 				return '{0}'.format(res)
 	
-	def translate_list_type(self, _type, showStdNs=True, namespace=None):
+	def translate_list_type(self, _type, namespace=None):
 		if _type.containedTypeDesc is None:
 			raise TranslationError('{0} has not been fixed'.format(_type.containedTypeName))
 		elif isinstance(_type.containedTypeDesc, BaseType):
 			res = _type.containedTypeDesc.translate(self)
 		else:
-			res = _type.containedTypeDesc.translate(self, showStdNs=showStdNs, namespace=namespace)
+			res = _type.containedTypeDesc.translate(self, namespace=namespace)
 			
 		if type(_type.parent) is Argument:
-			return 'const {0}<{1} > &'.format(
-				CppLangTranslator.prepend_std('list', showStdNs),
-				res
-			)
+			return 'const std::list<{0}> &'.format(res)
 		else:
-			return '{0}<{1} >'.format(
-				CppLangTranslator.prepend_std('list', showStdNs),
-				res
-			)
+			return 'std::list<{0}>'.format(res)
 	
-	def translate_method_as_prototype(self, method, showStdNs=True, namespace=None):
-		nsName = self._compute_namespace_name(namespace, method)
-		
-		argsString = ''
-		argStrings = []
-		for arg in method.args:
-			argStrings.append(arg.translate(self, showStdNs=showStdNs, namespace=namespace))
-		argsString = ', '.join(argStrings)
-		
-		return '{_return} {name}({args}){const}'.format(
-			_return=method.returnType.translate(self, ),
-			name=method.name.translate(self.nameTranslator, recursive=True, topAncestor=nsName),
-			args=argsString,
-			const=' const' if method.isconst else ''
+	def translate_method_as_prototype(self, method, hideArguments=False, hideArgNames=False, hideReturnType=False, stripDeclarators=False, namespace=None):
+		argsAsString = ', '.join([arg.translate(self, hideArgName=hideArgNames, namespace=namespace) for arg in method.args]) if not hideArguments else ''
+		return '{return_}{name}({args}){const}'.format(
+			return_=(method.returnType.translate(self, namespace=namespace) + ' ') if not hideReturnType else '',
+			name=method.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace)),
+			args=argsAsString,
+			const=' const' if method.isconst and not stripDeclarators else ''
 		)
-	
-	@staticmethod
-	def prepend_std(string, prepend):
-		return 'std::' + string if prepend else string
-
-	def _compute_namespace_name(self, namespace, obj):
-		nsName = Translator._compute_namespace_name(self, namespace, obj)
-		if self._get_object_name(obj).to_c() in self.ambigousTypes:
-			nsName = None
-		return nsName
 
 
 class JavaLangTranslator(CLikeLangTranslator):
@@ -1226,14 +1193,12 @@ class JavaLangTranslator(CLikeLangTranslator):
 		elif jni:
 			return 'jint'
 		else:
-			nsName = self._compute_namespace_name(namespace, _type)
-			return _type.desc.name.translate(self.nameTranslator, recursive=True, topAncestor=nsName)
+			return _type.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
 
 	def translate_class_type(self, _type, native=False, jni=False, isReturn=False, namespace=None):
 		if jni:
 			return 'jobject'
-		nsName = self._compute_namespace_name(namespace, _type)
-		return _type.desc.name.translate(self.nameTranslator, recursive=True, topAncestor=nsName)
+		return _type.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
 
 	def translate_list_type(self, _type, native=False, jni=False, isReturn=False, namespace=None):
 		if jni:
@@ -1259,14 +1224,18 @@ class JavaLangTranslator(CLikeLangTranslator):
 				raise Error('translation of bctbx_list_t of unknow type !')
 		return ptrtype + '[]'
 
-	def translate_argument(self, arg, native=False, jni=False):
-		return '{0} {1}'.format(arg.type.translate(self, native=native, jni=jni), arg.name.translate(self.nameTranslator))
+	def translate_argument(self, arg, native=False, jni=False, hideArgName=False, namespace=None):
+		res = arg.type.translate(self, native=native, jni=jni, namespace=None)
+		if not hideArgName:
+			res += (' ' + arg.name.translate(self.nameTranslator))
+		return res
 
-	def translate_method_as_prototype(self, method, namespace=None):
-		return 'public {returnType} {methodName}({arguments})'.format(
-			returnType=method.returnType.translate(self),
-			methodName=method.name.translate(self.nameTranslator),
-			arguments=', '.join([arg.translate(self) for arg in method.args])
+	def translate_method_as_prototype(self, method, hideArguments=False, hideArgNames=False, hideReturnType=False, stripDeclarators=False, namespace=None):
+		return '{public}{returnType}{methodName}({arguments})'.format(
+			public='public ' if not stripDeclarators else '',
+			returnType=(method.returnType.translate(self, isReturn=True, namespace=namespace) + ' ') if not hideReturnType else '',
+			methodName=method.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace)),
+			arguments=', '.join([arg.translate(self, hideArgName=hideArgNames, namespace=namespace) for arg in method.args]) if not hideArguments else ''
 		)
 
 
@@ -1277,7 +1246,7 @@ class CSharpLangTranslator(CLikeLangTranslator):
 		self.falseConstantToken = 'false'
 		self.trueConstantToken = 'true'
 	
-	def translate_base_type(self, _type, dllImport=True):
+	def translate_base_type(self, _type, dllImport=True, namespace=None):
 		if _type.name == 'void':
 				if _type.isref:
 					return 'IntPtr'
@@ -1326,16 +1295,16 @@ class CSharpLangTranslator(CLikeLangTranslator):
 		
 		return res
 	
-	def translate_enum_type(self, _type, dllImport=True):
+	def translate_enum_type(self, _type, dllImport=True, namespace=None):
 		if dllImport and type(_type.parent) is Argument:
 			return 'int'
 		else:
-			return _type.desc.name.translate(self.nameTranslator)
+			return _type.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
 	
-	def translate_class_type(self, _type, dllImport=True):
-		return "IntPtr" if dllImport else _type.desc.name.translate(self.nameTranslator)
+	def translate_class_type(self, _type, dllImport=True, namespace=None):
+		return "IntPtr" if dllImport else _type.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
 	
-	def translate_list_type(self, _type, dllImport=True):
+	def translate_list_type(self, _type, dllImport=True, namespace=None):
 		if dllImport:
 			return 'IntPtr'
 		else:
@@ -1345,7 +1314,7 @@ class CSharpLangTranslator(CLikeLangTranslator):
 				else:
 					raise TranslationError('translation of bctbx_list_t of basic C types is not supported')
 			elif type(_type.containedTypeDesc) is ClassType:
-				ptrType = _type.containedTypeDesc.desc.name.translate(self.nameTranslator)
+				ptrType = _type.containedTypeDesc.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
 				return 'IEnumerable<' + ptrType + '>'
 			else:
 				if _type.containedTypeDesc:
@@ -1353,22 +1322,17 @@ class CSharpLangTranslator(CLikeLangTranslator):
 				else:
 					raise TranslationError('translation of bctbx_list_t of unknow type !')
 	
-	def translate_argument(self, arg, dllImport=True):
+	def translate_argument(self, arg, dllImport=True, namespace=None):
 		return '{0} {1}'.format(
-			arg.type.translate(self, dllImport=dllImport),
+			arg.type.translate(self, dllImport=dllImport, namespace=None),
 			arg.name.translate(self.nameTranslator)
 		)
 	
-	def translate_method_as_prototype(self, method):
-		kargs = {
-			'static'     : 'static ' if method.type == Method.Type.Class else '',
-			'override'   : 'override ' if method.name.translate(self.nameTranslator) == 'ToString' else '',
-			'returnType' : method.returnType.translate(self, dllImport=False),
-			'name'       : method.name.translate(self.nameTranslator),
-			'args'       : ''
-		}
-		for arg in method.args:
-			if kargs['args'] != '':
-				kargs['args'] += ', '
-			kargs['args'] += arg.translate(self, dllImport=False)
-		return '{static}{override}{returnType} {name}({args})'.format(**kargs)
+	def translate_method_as_prototype(self, method, hideArguments=False, hideArgNames=False, hideReturnType=False, stripDeclarators=False, namespace=None):
+		return '{static}{override}{returnType}{name}({args})'.format(
+			static     = 'static ' if method.type == Method.Type.Class and not stripDeclarators else '',
+			override   = 'override ' if method.name.translate(self.nameTranslator) == 'ToString' and not stripDeclarators else '',
+			returnType = (method.returnType.translate(self, dllImport=False, namespace=namespace) + ' ') if not hideReturnType else '',
+			name       = method.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace)),
+			args       = ', '.join([arg.translate(self, dllImport=False, namespace=namespace) for arg in method.args]) if not hideArguments else ''
+		)

tools/metadoc.py

@@ -435,12 +435,11 @@ class Translator:
 		else:
 			if namespace is None:
 				description = ref.find_root()
-				namespaceObj = description.relatedObject.find_first_ancestor_by_type(abstractapi.Namespace, abstractapi.Class)
-				namespace = namespaceObj.name
-			if namespace.is_prefix_of(ref.relatedObject.name):
-				commonName = namespace
+				namespace = description.relatedObject.find_first_ancestor_by_type(abstractapi.Namespace, abstractapi.Class)
+			if namespace.name.is_prefix_of(ref.relatedObject.name):
+				commonName = namespace.name
 			else:
-				commonName = metaname.Name.find_common_parent(ref.relatedObject.name, namespace)
+				commonName = metaname.Name.find_common_parent(ref.relatedObject.name, namespace.name)
 		return ref.relatedObject.name.translate(self.nameTranslator, recursive=True, topAncestor=commonName)
 	
 	def translate_keyword(self, keyword):
@@ -617,15 +616,21 @@ class SphinxTranslator(Translator):
 			ref=Translator.translate_reference(self, ref, absName=True)
 		)
 
-	def translate_function_reference(self, ref, label=None, namespace=None):
-		paramTypes = []
-		if self.domain != 'c':
-			for arg in ref.relatedObject.args:
-				paramTypes.append(arg._type.translate(self.langTranslator))
+	def translate_function_reference(self, ref, label=None, useNamespace=True, namespace=None):
+		if self.domain == 'csharp':
+			refStr = ref.relatedObject.name.translate(self.nameTranslator, **abstractapi.Translator._namespace_to_name_translator_params(namespace))
+		else:
+			refStr = ref.relatedObject.translate_as_prototype(self.langTranslator,
+				hideArguments=self.domain != 'java',
+				hideArgNames=self.domain == 'java',
+				hideReturnType=True,
+				stripDeclarators=True,
+				namespace=namespace
+			)
 		return ':{tag}:`{label} <{ref}>`'.format(
 			tag=self._sphinx_ref_tag(ref),
 			label=label if label is not None else '{0}()'.format(Translator.translate_reference(self, ref, namespace=namespace)),
-			ref='{0}({1})'.format(Translator.translate_reference(self, ref, absName=True), ', '.join(paramTypes))
+			ref=refStr
 		)
 	
 	def translate_keyword(self, keyword):