diff --git a/coreapi/help/doc/sphinx/class_page.mustache b/coreapi/help/doc/sphinx/class_page.mustache index 4714039a3..fe747bf4e 100644 --- a/coreapi/help/doc/sphinx/class_page.mustache +++ b/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}} diff --git a/coreapi/help/doc/sphinx/enums_page.mustache b/coreapi/help/doc/sphinx/enums_page.mustache index fd013094a..59a171992 100644 --- a/coreapi/help/doc/sphinx/enums_page.mustache +++ b/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}} diff --git a/coreapi/help/doc/sphinx/gendoc.py b/coreapi/help/doc/sphinx/gendoc.py index 569e816e3..a575bcb3d 100755 --- a/coreapi/help/doc/sphinx/gendoc.py +++ b/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) diff --git a/tools/abstractapi.py b/tools/abstractapi.py index 99b2b8ddc..be6c1559b 100644 --- a/tools/abstractapi.py +++ b/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' 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 '' + ) diff --git a/tools/metadoc.py b/tools/metadoc.py index 2d4a214aa..e739b318b 100644 --- a/tools/metadoc.py +++ b/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):