shiboken: Fix visibility of members of the generator classes

Make visibility more restricted by moving definitions to the
private/protected section.
Remove virtual from Generator::moduleName() since it is not overridden.

Change-Id: I6b43f9679741fa8a5c453b339d9bb4228d74c04c
Reviewed-by: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>
Reviewed-by: Christian Tismer <tismer@stackless.com>

3 files changed, 172 insertions, 169 deletions

diff --git a/sources/shiboken2/generator/generator.h b/sources/shiboken2/generator/generator.h
index 6028afa64..ac6009d73 100644
--- a/sources/shiboken2/generator/generator.h
+++ b/sources/shiboken2/generator/generator.h
@@ -174,6 +174,66 @@ public:
     /// Returns the classes used to generate the binding code.
     AbstractMetaClassList classes() const;
 
+    /// Returns the output directory
+    QString outputDirectory() const;
+
+    /// Set the output directory
+    void setOutputDirectory(const QString &outDir);
+
+    /**
+     *   Start the code generation, be sure to call setClasses before callign this method.
+     *   For each class it creates a QTextStream, call the write method with the current
+     *   class and the associated text stream, then write the text stream contents if needed.
+     *   \see #write
+     */
+    bool generate();
+
+    /// Returns the license comment to be prepended to each source file generated.
+    QString licenseComment() const;
+
+    /// Sets the license comment to be prepended to each source file generated.
+    void setLicenseComment(const QString &licenseComment);
+
+    /// Returns the generator's name. Used for cosmetic purposes.
+    virtual const char* name() const = 0;
+
+    /**
+     *  Retrieves the name of the currently processed module.
+     *  While package name is a complete package idetification, e.g. 'PySide.QtCore',
+     *  a module name represents the last part of the package, e.g. 'QtCore'.
+     *  If the target language separates the modules with characters other than
+     *  dots ('.') the generator subclass must overload this method.
+     *  \return a string representing the last part of a package name
+     */
+    QString moduleName() const;
+
+    /**
+     *   Retrieves a list of constructors used in implicit conversions
+     *   available on the given type. The TypeEntry must be a value-type
+     *   or else it will return an empty list.
+     *   \param type a TypeEntry that is expected to be a value-type
+     *   \return a list of constructors that could be used as implicit converters
+     */
+    AbstractMetaFunctionList implicitConversions(const TypeEntry* type) const;
+
+    /// Convenience function for implicitConversions(const TypeEntry* type).
+    AbstractMetaFunctionList implicitConversions(const AbstractMetaType* metaType) const;
+
+    /// Check if type is a pointer.
+    static bool isPointer(const AbstractMetaType* type);
+
+    /// Tells if the type or class is an Object (or QObject) Type.
+    static bool isObjectType(const TypeEntry* type);
+    static bool isObjectType(const ComplexTypeEntry* type);
+    static bool isObjectType(const AbstractMetaType* metaType);
+    static bool isObjectType(const AbstractMetaClass* metaClass);
+
+    /// Returns true if the type is a C string (const char*).
+    static bool isCString(const AbstractMetaType* type);
+    /// Returns true if the type is a void pointer.
+    static bool isVoidPointer(const AbstractMetaType* type);
+
+protected:
     /// Returns the classes, topologically ordered, used to generate the binding code.
     ///
     /// The classes are ordered such that derived classes appear later in the list than
@@ -204,21 +264,6 @@ public:
     /// Returns an AbstractMetaEnum for a given AbstractMetaType that holds an EnumTypeEntry, or NULL if not found.
     const AbstractMetaEnum* findAbstractMetaEnum(const AbstractMetaType* metaType) const;
 
-    /// Returns the output directory
-    QString outputDirectory() const;
-
-    /// Set the output directory
-    void setOutputDirectory(const QString &outDir);
-
-    /**
-    *   Start the code generation, be sure to call setClasses before callign this method.
-    *   For each class it creates a QTextStream, call the write method with the current
-    *   class and the associated text stream, then write the text stream contents if needed.
-    *   \see #write
-    */
-    bool generate();
-
-
     /// Generates a file for given AbstractMetaClass or AbstractMetaType (smart pointer case).
     bool generateFileForContext(GeneratorContext &context);
 
@@ -226,9 +271,6 @@ public:
     QString getFileNameBaseForSmartPointer(const AbstractMetaType *smartPointerType,
                                            const AbstractMetaClass *smartPointerClass) const;
 
-    /// Returns the generator's name. Used for cosmetic purposes.
-    virtual const char* name() const = 0;
-
     /// Returns true if the generator should generate any code for the TypeEntry.
     bool shouldGenerateTypeEntry(const TypeEntry*) const;
 
@@ -267,56 +309,10 @@ public:
     void replaceTemplateVariables(QString &code, const AbstractMetaFunction *func);
 
     /**
-    *   Returns the license comment to be prepended to each source file generated.
-    */
-    QString licenseComment() const;
-
-    /**
-    *   Sets the license comment to be prepended to each source file generated.
-    */
-    void setLicenseComment(const QString &licenseComment);
-
-    /**
      *   Returns the package name.
      */
     QString packageName() const;
 
-    /**
-     *  Retrieves the name of the currently processed module.
-     *  While package name is a complete package idetification, e.g. 'PySide.QtCore',
-     *  a module name represents the last part of the package, e.g. 'QtCore'.
-     *  If the target language separates the modules with characters other than
-     *  dots ('.') the generator subclass must overload this method.
-     *  \return a string representing the last part of a package name
-     */
-    virtual QString moduleName() const;
-
-    /**
-     *   Retrieves a list of constructors used in implicit conversions
-     *   available on the given type. The TypeEntry must be a value-type
-     *   or else it will return an empty list.
-     *   \param type a TypeEntry that is expected to be a value-type
-     *   \return a list of constructors that could be used as implicit converters
-     */
-    AbstractMetaFunctionList implicitConversions(const TypeEntry* type) const;
-
-    /// Convenience function for implicitConversions(const TypeEntry* type).
-    AbstractMetaFunctionList implicitConversions(const AbstractMetaType* metaType) const;
-
-    /// Check if type is a pointer.
-    static bool isPointer(const AbstractMetaType* type);
-
-    /// Tells if the type or class is an Object (or QObject) Type.
-    static bool isObjectType(const TypeEntry* type);
-    static bool isObjectType(const ComplexTypeEntry* type);
-    static bool isObjectType(const AbstractMetaType* metaType);
-    static bool isObjectType(const AbstractMetaClass* metaClass);
-
-    /// Returns true if the type is a C string (const char*).
-    static bool isCString(const AbstractMetaType* type);
-    /// Returns true if the type is a void pointer.
-    static bool isVoidPointer(const AbstractMetaType* type);
-
     // Returns the full name of the type.
     QString getFullTypeName(const TypeEntry* type) const;
     QString getFullTypeName(const AbstractMetaType* type) const;
@@ -338,7 +334,6 @@ public:
     QString minimalConstructor(const AbstractMetaType* type) const;
     QString minimalConstructor(const AbstractMetaClass* metaClass) const;
 
-protected:
     /**
      *   Returns the file name used to write the binding code of an AbstractMetaClass/Type.
      *   \param context the GeneratorContext which contains an AbstractMetaClass or AbstractMetaType
diff --git a/sources/shiboken2/generator/qtdoc/qtdocgenerator.h b/sources/shiboken2/generator/qtdoc/qtdocgenerator.h
index 978668c4c..5545de9a9 100644
--- a/sources/shiboken2/generator/qtdoc/qtdocgenerator.h
+++ b/sources/shiboken2/generator/qtdoc/qtdocgenerator.h
@@ -224,9 +224,8 @@ public:
         return m_codeSnippetDirs;
     }
 
-    bool shouldGenerate(const AbstractMetaClass *) const override;
-
 protected:
+    bool shouldGenerate(const AbstractMetaClass *) const override;
     QString fileNameSuffix() const override;
     QString fileNameForContext(GeneratorContext &context) const override;
     void generateClass(QTextStream &s, GeneratorContext &classContext) override;
diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.h b/sources/shiboken2/generator/shiboken2/shibokengenerator.h
index d2ae55926..3be69c651 100644
--- a/sources/shiboken2/generator/shiboken2/shibokengenerator.h
+++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.h
@@ -71,61 +71,20 @@ class ShibokenGenerator : public Generator
 {
 public:
     ShibokenGenerator();
-    virtual ~ShibokenGenerator();
+    ~ShibokenGenerator() override;
 
-    QString translateTypeForWrapperMethod(const AbstractMetaType* cType,
-                                          const AbstractMetaClass* context, Options opt = NoOption) const;
-
-    /**
-    *   Returns a map with all functions grouped, the function name is used as key.
-    *   Example of return value: { "foo" -> ["foo(int)", "foo(int, long)], "bar" -> "bar(double)"}
-    *   \param scope Where to search for functions, null means all global functions.
-    */
-    QMap<QString, AbstractMetaFunctionList> getFunctionGroups(const AbstractMetaClass* scope = 0);
+    const char *name() const override { return "Shiboken"; }
 
     /**
-    *   Returns all different inherited overloads of func.
-    *   The function can be called multiple times without duplication.
-    *   \param func the metafunction to be searched in subclasses.
-    *   \param seen the function's minimal signatures already seen.
-    */
-    AbstractMetaFunctionList getInheritedOverloads(const AbstractMetaFunction *func, QSet<QString> *seen);
+     * Helper function to find for argument default value
+     */
+    static QString getDefaultValue(const AbstractMetaFunction* func, const AbstractMetaArgument* arg);
 
-    /**
-    *   Returns all different inherited overloads of func, and includes func as well.
-    *   The function can be called multiple times without duplication.
-    *   \param func the metafunction to be searched in subclasses.
-    *   \param seen the function's minimal signatures already seen.
-    */
-    AbstractMetaFunctionList getFunctionAndInheritedOverloads(const AbstractMetaFunction *func, QSet<QString> *seen);
+    /// Returns a list of all ancestor classes for the given class.
+    AbstractMetaClassList getAllAncestors(const AbstractMetaClass* metaClass) const;
 
-    /**
-    *   Returns all overloads for a function named \p functionName.
-    *   \param scope scope used to search for overloads.
-    *   \param functionName the function name.
-    */
-    AbstractMetaFunctionList getFunctionOverloads(const AbstractMetaClass* scope, const QString& functionName);
-    /**
-     *   Write a function argument in the C++ in the text stream \p s.
-     *   This function just call \code s << argumentString(); \endcode
-     *   \param s text stream used to write the output.
-     *   \param func the current metafunction.
-     *   \param argument metaargument information to be parsed.
-     *   \param options some extra options.
-     */
-    void writeArgument(QTextStream &s,
-                       const AbstractMetaFunction* func,
-                       const AbstractMetaArgument* argument,
-                       Options options = NoOption) const;
-    /**
-     *   Create a QString in the C++ format to an function argument.
-     *   \param func the current metafunction.
-     *   \param argument metaargument information to be parsed.
-     *   \param options some extra options.
-     */
-    QString argumentString(const AbstractMetaFunction* func,
-                           const AbstractMetaArgument* argument,
-                           Options options = NoOption) const;
+protected:
+    bool doSetup() override;
 
     void writeArgumentNames(QTextStream &s,
                             const AbstractMetaFunction* func,
@@ -141,14 +100,21 @@ public:
     void writeFunctionArguments(QTextStream &s,
                                 const AbstractMetaFunction* func,
                                 Options options = NoOption) const override;
-    QString functionReturnType(const AbstractMetaFunction* func, Options options = NoOption) const;
 
-    /// Utility function for writeCodeSnips.
-    typedef QPair<const AbstractMetaArgument*, QString> ArgumentVarReplacementPair;
-    typedef QVector<ArgumentVarReplacementPair> ArgumentVarReplacementList;
-    ArgumentVarReplacementList getArgumentReplacement(const AbstractMetaFunction* func,
-                                                      bool usePyArgs, TypeSystem::Language language,
-                                                      const AbstractMetaArgument* lastArg);
+    /**
+     *   Returns a map with all functions grouped, the function name is used as key.
+     *   Example of return value: { "foo" -> ["foo(int)", "foo(int, long)], "bar" -> "bar(double)"}
+     *   \param scope Where to search for functions, null means all global functions.
+     */
+    QMap<QString, AbstractMetaFunctionList> getFunctionGroups(const AbstractMetaClass* scope = 0);
+
+    /**
+     *   Returns all different inherited overloads of func, and includes func as well.
+     *   The function can be called multiple times without duplication.
+     *   \param func the metafunction to be searched in subclasses.
+     *   \param seen the function's minimal signatures already seen.
+     */
+    AbstractMetaFunctionList getFunctionAndInheritedOverloads(const AbstractMetaFunction *func, QSet<QString> *seen);
 
     /// Write user's custom code snippets at class or module level.
     void writeCodeSnips(QTextStream& s,
@@ -164,33 +130,9 @@ public:
                         const AbstractMetaFunction* func,
                         const AbstractMetaArgument* lastArg = 0);
 
-    /// Returns a string with the user's custom code snippets that comply with \p position and \p language.
-    QString getCodeSnippets(const QVector<CodeSnip> & codeSnips, TypeSystem::CodeSnipPosition position, TypeSystem::Language language);
-
     /// Replaces variables for the user's custom code at global or class level.
     void processCodeSnip(QString& code, const AbstractMetaClass* context = 0);
 
-    /// Replaces the %CONVERTTOPYTHON type system variable.
-    inline void replaceConvertToPythonTypeSystemVariable(QString& code)
-    {
-        replaceConverterTypeSystemVariable(TypeSystemToPythonFunction, code);
-    }
-    /// Replaces the %CONVERTTOCPP type system variable.
-    inline void replaceConvertToCppTypeSystemVariable(QString& code)
-    {
-        replaceConverterTypeSystemVariable(TypeSystemToCppFunction, code);
-    }
-    /// Replaces the %ISCONVERTIBLE type system variable.
-    inline void replaceIsConvertibleToCppTypeSystemVariable(QString& code)
-    {
-        replaceConverterTypeSystemVariable(TypeSystemIsConvertibleFunction, code);
-    }
-    /// Replaces the %CHECKTYPE type system variable.
-    inline void replaceTypeCheckTypeSystemVariable(QString& code)
-    {
-        replaceConverterTypeSystemVariable(TypeSystemCheckFunction, code);
-    }
-
     /**
      *   Verifies if any of the function's code injections of the "native"
      *   type needs the type system variable "%PYSELF".
@@ -259,9 +201,6 @@ public:
     /// Returns a list of parent classes for a given class.
     AbstractMetaClassList getBaseClasses(const AbstractMetaClass* metaClass) const;
 
-    /// Returns a list of all ancestor classes for the given class.
-    AbstractMetaClassList getAllAncestors(const AbstractMetaClass* metaClass) const;
-
     const AbstractMetaClass* getMultipleInheritingClass(const AbstractMetaClass* metaClass);
 
     void writeToPythonConversion(QTextStream& s, const AbstractMetaType* type,
@@ -460,25 +399,12 @@ public:
     void writeMinimalConstructorExpression(QTextStream& s, const AbstractMetaType* type, const QString& defaultCtor = QString());
     void writeMinimalConstructorExpression(QTextStream& s, const TypeEntry* type, const QString& defaultCtor = QString());
 
-    /**
-     * Helper function to find for argument default value
-     */
-    static QString getDefaultValue(const AbstractMetaFunction* func, const AbstractMetaArgument* arg);
-protected:
-    bool doSetup() override;
     void collectContainerTypesFromConverterMacros(const QString& code, bool toPythonMacro);
     // verify whether the class is copyable
     bool isCopyable(const AbstractMetaClass* metaClass);
 
-    static QHash<QString, QString> m_pythonPrimitiveTypeName;
-    static QHash<QString, QString> m_pythonOperators;
-    static QHash<QString, QString> m_formatUnits;
-    static QHash<QString, QString> m_tpFuncs;
-    static QStringList m_knownPythonTypes;
-
     void clearTpFuncs();
 
-    const char* name() const { return "Shiboken"; }
 
     /// Initializes correspondences between primitive and Python types.
     static void initPrimitiveTypesCorrespondences();
@@ -502,14 +428,76 @@ protected:
     /// Returns a list of converters for the non wrapper types of the current module.
     QVector<const CustomConversion *> getPrimitiveCustomConversions();
 
-    /// Return a prefix with '_' suitable for names in C++
-    QString moduleCppPrefix(const QString& moduleName = QString()) const;
-
     /// Returns true if the Python wrapper for the received OverloadData must accept a list of arguments.
     static bool pythonFunctionWrapperUsesListOfArguments(const OverloadData& overloadData);
 
     Indentor INDENT;
 
+    static QString msgCouldNotFindMinimalConstructor(const QString &where, const QString &type);
+
+    static QHash<QString, QString> m_pythonPrimitiveTypeName;
+    static QHash<QString, QString> m_pythonOperators;
+    static QHash<QString, QString> m_formatUnits;
+    static QHash<QString, QString> m_tpFuncs;
+    static QStringList m_knownPythonTypes;
+
+private:
+    QString translateTypeForWrapperMethod(const AbstractMetaType* cType,
+                                          const AbstractMetaClass* context,
+                                          Options opt = NoOption) const;
+
+    /**
+     *   Returns all different inherited overloads of func.
+     *   The function can be called multiple times without duplication.
+     *   \param func the metafunction to be searched in subclasses.
+     *   \param seen the function's minimal signatures already seen.
+     */
+    AbstractMetaFunctionList getInheritedOverloads(const AbstractMetaFunction *func,
+                                                   QSet<QString> *seen);
+
+    /**
+     *   Returns all overloads for a function named \p functionName.
+     *   \param scope scope used to search for overloads.
+     *   \param functionName the function name.
+     */
+    AbstractMetaFunctionList getFunctionOverloads(const AbstractMetaClass* scope,
+                                                  const QString& functionName);
+    /**
+     *   Write a function argument in the C++ in the text stream \p s.
+     *   This function just call \code s << argumentString(); \endcode
+     *   \param s text stream used to write the output.
+     *   \param func the current metafunction.
+     *   \param argument metaargument information to be parsed.
+     *   \param options some extra options.
+     */
+    void writeArgument(QTextStream &s,
+                       const AbstractMetaFunction* func,
+                       const AbstractMetaArgument* argument,
+                       Options options = NoOption) const;
+    /**
+     *   Create a QString in the C++ format to an function argument.
+     *   \param func the current metafunction.
+     *   \param argument metaargument information to be parsed.
+     *   \param options some extra options.
+     */
+    QString argumentString(const AbstractMetaFunction* func,
+                           const AbstractMetaArgument* argument,
+                           Options options = NoOption) const;
+
+    QString functionReturnType(const AbstractMetaFunction* func, Options options = NoOption) const;
+
+    /// Utility function for writeCodeSnips.
+    typedef QPair<const AbstractMetaArgument*, QString> ArgumentVarReplacementPair;
+    typedef QVector<ArgumentVarReplacementPair> ArgumentVarReplacementList;
+    ArgumentVarReplacementList getArgumentReplacement(const AbstractMetaFunction* func,
+                                                      bool usePyArgs, TypeSystem::Language language,
+                                                      const AbstractMetaArgument* lastArg);
+
+    /// Returns a string with the user's custom code snippets that comply with \p position and \p language.
+    QString getCodeSnippets(const QVector<CodeSnip> & codeSnips,
+                            TypeSystem::CodeSnipPosition position,
+                            TypeSystem::Language language);
+
     enum TypeSystemConverterVariable {
         TypeSystemCheckFunction = 0,
         TypeSystemIsConvertibleFunction,
@@ -519,9 +507,30 @@ protected:
     };
     void replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString& code);
 
-    static QString msgCouldNotFindMinimalConstructor(const QString &where, const QString &type);
+    /// Replaces the %CONVERTTOPYTHON type system variable.
+    inline void replaceConvertToPythonTypeSystemVariable(QString& code)
+    {
+        replaceConverterTypeSystemVariable(TypeSystemToPythonFunction, code);
+    }
+    /// Replaces the %CONVERTTOCPP type system variable.
+    inline void replaceConvertToCppTypeSystemVariable(QString& code)
+    {
+        replaceConverterTypeSystemVariable(TypeSystemToCppFunction, code);
+    }
+    /// Replaces the %ISCONVERTIBLE type system variable.
+    inline void replaceIsConvertibleToCppTypeSystemVariable(QString& code)
+    {
+        replaceConverterTypeSystemVariable(TypeSystemIsConvertibleFunction, code);
+    }
+    /// Replaces the %CHECKTYPE type system variable.
+    inline void replaceTypeCheckTypeSystemVariable(QString& code)
+    {
+        replaceConverterTypeSystemVariable(TypeSystemCheckFunction, code);
+    }
+
+    /// Return a prefix with '_' suitable for names in C++
+    QString moduleCppPrefix(const QString& moduleName = QString()) const;
 
-private:
     bool m_useCtorHeuristic = false;
     bool m_userReturnValueHeuristic = false;
     bool m_usePySideExtensions = false;