C++: Add support of ref-qualifier for functions.

Now the ref-qualifier (& or &&) of the function declaration
is propagated to GUI. For example,  'Refactor' -> 'Add Definition'
preserves the ref-qualifier.

Change-Id: I8ac4e1cad4e44985e94230aabbd9858a7e929fee
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
Reviewed-by: Orgad Shaneh <orgads@gmail.com>

src/libs/3rdparty/cplusplus/Bind.cpp

@@ -3255,6 +3255,14 @@ bool Bind::visit(FunctionDeclaratorAST *ast)
     fun->setOverride(type.isOverride());
     fun->setFinal(type.isFinal());
 
+    // propagate ref-qualifier
+    if (ast->ref_qualifier_token) {
+        const Kind kind = tokenAt(ast->ref_qualifier_token).kind();
+        CPP_CHECK(kind == T_AMPER || kind == T_AMPER_AMPER); // & or && are only allowed
+        fun->setRefQualifier(kind == T_AMPER ? Function::LvalueRefQualifier :
+                                               Function::RvalueRefQualifier);
+    }
+
     this->exceptionSpecification(ast->exception_specification, type);
     if (ast->as_cpp_initializer != 0) {
         fun->setAmbiguous(true);

src/libs/3rdparty/cplusplus/Symbols.cpp

@@ -367,6 +367,12 @@ bool Function::isPureVirtual() const
 void Function::setPureVirtual(bool isPureVirtual)
 { f._isPureVirtual = isPureVirtual; }
 
+Function::RefQualifier Function::refQualifier() const
+{ return static_cast<RefQualifier>(f._refQualifier); }
+
+void Function::setRefQualifier(Function::RefQualifier refQualifier)
+{ f._refQualifier = refQualifier; }
+
 bool Function::isAmbiguous() const
 { return f._isAmbiguous; }
 

src/libs/3rdparty/cplusplus/Symbols.h

@@ -298,6 +298,12 @@ public:
         InvokableMethod
     };
 
+    enum RefQualifier {
+        NoRefQualifier, // a function declared w/o & and && => *this may be lvalue or rvalue
+        LvalueRefQualifier, // a function declared with & => *this is lvalue
+        RvalueRefQualifier // a function declared with && => *this is rvalue
+    };
+
 public:
     Function(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name);
     Function(Clone *clone, Subst *subst, Function *original);
@@ -344,6 +350,9 @@ public:
     bool isPureVirtual() const;
     void setPureVirtual(bool isPureVirtual);
 
+    RefQualifier refQualifier() const;
+    void setRefQualifier(RefQualifier refQualifier);
+
     bool isSignatureEqualTo(const Function *other, Matcher *matcher = 0) const;
 
     bool isAmbiguous() const; // internal
@@ -384,6 +393,7 @@ private:
         unsigned _isVolatile: 1;
         unsigned _isAmbiguous: 1;
         unsigned _methodKey: 3;
+        unsigned _refQualifier: 2;
     };
     union {
         unsigned _flags;