Commit 13806679 authored by Nikolai Kosjar's avatar Nikolai Kosjar

C++: Introduce PointerDeclarationFormatter

For a given AST, CppRefactoringFile and Overview this will create a
ChangeSet for rewriting the pointer or reference declaration according
to the Overview.

Task-number: QTCREATORBUG-6169

Change-Id: If6f824c1ea5e9f53a11a58ec8b6d696d01f0723e
Reviewed-by: default avatarErik Verbruggen <erik.verbruggen@digia.com>
parent fa7ab13f
......@@ -181,6 +181,13 @@ void Bind::operator()(DeclarationAST *ast, Scope *scope)
(void) switchScope(previousScope);
}
void Bind::operator()(StatementAST *ast, Scope *scope)
{
Scope *previousScope = switchScope(scope);
statement(ast);
(void) switchScope(previousScope);
}
FullySpecifiedType Bind::operator()(ExpressionAST *ast, Scope *scope)
{
Scope *previousScope = switchScope(scope);
......
......@@ -34,6 +34,7 @@ public:
void operator()(TranslationUnitAST *ast, Namespace *globalNamespace);
void operator()(DeclarationAST *ast, Scope *scope);
void operator()(StatementAST *ast, Scope *scope);
FullySpecifiedType operator()(ExpressionAST *ast, Scope *scope);
FullySpecifiedType operator()(NewTypeIdAST *ast, Scope *scope);
......
......@@ -595,6 +595,8 @@ void Document::check(CheckMode mode)
if (TranslationUnitAST *ast = _translationUnit->ast()->asTranslationUnit())
semantic(ast, _globalNamespace);
else if (StatementAST *ast = _translationUnit->ast()->asStatement())
semantic(ast, _globalNamespace);
else if (ExpressionAST *ast = _translationUnit->ast()->asExpression())
semantic(ast, _globalNamespace);
else if (DeclarationAST *ast = translationUnit()->ast()->asDeclaration())
......
......@@ -49,9 +49,6 @@ namespace CPlusPlus {
class CPLUSPLUS_EXPORT Overview
{
Overview(const Overview &other);
void operator =(const Overview &other);
public:
Overview();
......
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#include "cpppointerdeclarationformatter.h"
#include <AST.h>
#include <QTextCursor>
#define DEBUG_OUTPUT 0
#define CHECK_RV(cond, err, r) if (!(cond)) { if (DEBUG_OUTPUT) qDebug() << (err); return r; }
#define CHECK_R(cond, err) if (!(cond)) { if (DEBUG_OUTPUT) qDebug() << (err); return; }
#define CHECK_C(cond, err) if (!(cond)) { if (DEBUG_OUTPUT) qDebug() << (err); continue; }
using namespace CppTools;
/*!
\brief Skip not type relevant specifiers and return the index of the
first specifier token which is not followed by __attribute__
((T___ATTRIBUTE__)).
This is used to get 'correct' start of the activation range in
simple declarations.
Consider these cases:
static char *s = 0;
typedef char *s cp;
__attribute__((visibility("default"))) char *f();
For all cases we want to skip all the not type relevant specifer
(since these are not part of the type and thus are not rewritten).
\param list The specifier list to iterate
\param translationUnit The TranslationUnit
\param endToken Do not check further than this token
\param found Output parameter, must not be 0.
*/
static unsigned firstTypeSpecifierWithoutFollowingAttribute(
SpecifierListAST *list, TranslationUnit *translationUnit, unsigned endToken, bool *found)
{
*found = false;
if (! list || ! translationUnit || ! endToken)
return 0;
for (SpecifierListAST *it = list; it; it = it->next) {
SpecifierAST *specifier = it->value;
CHECK_RV(specifier, "No specifier", 0);
const unsigned index = specifier->firstToken();
CHECK_RV(index < endToken, "EndToken reached", 0);
const int tokenKind = translationUnit->tokenKind(index);
switch (tokenKind) {
case T_VIRTUAL:
case T_INLINE:
case T_FRIEND:
case T_REGISTER:
case T_STATIC:
case T_EXTERN:
case T_MUTABLE:
case T_TYPEDEF:
case T_CONSTEXPR:
case T___ATTRIBUTE__:
continue;
default:
// Check if attributes follow
for (unsigned i = index; i <= endToken; ++i) {
const int tokenKind = translationUnit->tokenKind(i);
if (tokenKind == T___ATTRIBUTE__)
return 0;
}
*found = true;
return index;
}
}
return 0;
}
PointerDeclarationFormatter::PointerDeclarationFormatter(
const CppRefactoringFilePtr refactoringFile,
const Overview &overview,
CursorHandling cursorHandling)
: ASTVisitor(refactoringFile->cppDocument()->translationUnit())
, m_cppRefactoringFile(refactoringFile)
, m_overview(overview)
, m_cursorHandling(cursorHandling)
{}
/*!
Handle
(1) Simple declarations like in "char *s, *t, *int foo();"
(2) Return types of function declarations.
*/
bool PointerDeclarationFormatter::visit(SimpleDeclarationAST *ast)
{
CHECK_RV(ast, "Invalid AST", true);
DeclaratorListAST *declaratorList = ast->declarator_list;
CHECK_RV(declaratorList, "No declarator list", true);
DeclaratorAST *firstDeclarator = declaratorList->value;
CHECK_RV(firstDeclarator, "No declarator", true);
CHECK_RV(ast->symbols, "No Symbols", true);
CHECK_RV(ast->symbols->value, "No Symbol", true);
List<Symbol *> *sit = ast->symbols;
DeclaratorListAST *dit = declaratorList;
for (; sit && dit; sit = sit->next, dit = dit->next) {
DeclaratorAST *declarator = dit->value;
Symbol *symbol = sit->value;
const bool isFirstDeclarator = declarator == firstDeclarator;
// If were not handling the first declarator, we need to remove
// characters from the beginning since our rewritten declaration
// will contain all type specifiers.
int charactersToRemove = 0;
if (! isFirstDeclarator) {
const int startAST = m_cppRefactoringFile->startOf(ast);
const int startFirstDeclarator = m_cppRefactoringFile->startOf(firstDeclarator);
CHECK_RV(startAST < startFirstDeclarator, "No specifier", true);
charactersToRemove = startFirstDeclarator - startAST;
}
// Specify activation range
int lastActivationToken = 0;
Range range;
// (2) Handle function declaration's return type
if (symbol->type()->asFunctionType()) {
PostfixDeclaratorListAST *pfDeclaratorList = declarator->postfix_declarator_list;
CHECK_RV(pfDeclaratorList, "No postfix declarator list", true);
PostfixDeclaratorAST *pfDeclarator = pfDeclaratorList->value;
CHECK_RV(pfDeclarator, "No postfix declarator", true);
FunctionDeclaratorAST *functionDeclarator = pfDeclarator->asFunctionDeclarator();
CHECK_RV(functionDeclarator, "No function declarator", true);
// End the activation range before the '(' token.
lastActivationToken = functionDeclarator->lparen_token - 1;
SpecifierListAST *specifierList = isFirstDeclarator
? ast->decl_specifier_list
: declarator->attribute_list;
unsigned firstActivationToken = 0;
bool foundBegin = false;
firstActivationToken = firstTypeSpecifierWithoutFollowingAttribute(
specifierList,
m_cppRefactoringFile->cppDocument()->translationUnit(),
lastActivationToken,
&foundBegin);
if (! foundBegin) {
CHECK_RV(! isFirstDeclarator, "Declaration without attributes not supported", true);
firstActivationToken = declarator->firstToken();
}
range.start = m_cppRefactoringFile->startOf(firstActivationToken);
// (1) Handle 'normal' declarations.
} else {
if (isFirstDeclarator) {
bool foundBegin = false;
unsigned firstActivationToken = firstTypeSpecifierWithoutFollowingAttribute(
ast->decl_specifier_list,
m_cppRefactoringFile->cppDocument()->translationUnit(),
declarator->firstToken(),
&foundBegin);
CHECK_RV(foundBegin, "Declaration without attributes not supported", true);
range.start = m_cppRefactoringFile->startOf(firstActivationToken);
} else {
range.start = m_cppRefactoringFile->startOf(declarator);
}
lastActivationToken = declarator->equal_token
? declarator->equal_token - 1
: declarator->lastToken() - 1;
}
range.end = m_cppRefactoringFile->endOf(lastActivationToken);
checkAndRewrite(symbol, range, charactersToRemove);
}
return true;
}
/*! Handle return types of function definitions */
bool PointerDeclarationFormatter::visit(FunctionDefinitionAST *ast)
{
DeclaratorAST *declarator = ast->declarator;
CHECK_RV(declarator, "No declarator", true);
CHECK_RV(declarator->ptr_operator_list, "No Pointer or references", true);
Symbol *symbol = ast->symbol;
PostfixDeclaratorListAST *pfDeclaratorList = declarator->postfix_declarator_list;
CHECK_RV(pfDeclaratorList, "No postfix declarator list", true);
PostfixDeclaratorAST *pfDeclarator = pfDeclaratorList->value;
CHECK_RV(pfDeclarator, "No postfix declarator", true);
FunctionDeclaratorAST *functionDeclarator = pfDeclarator->asFunctionDeclarator();
CHECK_RV(functionDeclarator, "No function declarator", true);
// Specify activation range
bool foundBegin = false;
const unsigned lastActivationToken = functionDeclarator->lparen_token - 1;
const unsigned firstActivationToken = firstTypeSpecifierWithoutFollowingAttribute(
ast->decl_specifier_list,
m_cppRefactoringFile->cppDocument()->translationUnit(),
lastActivationToken,
&foundBegin);
CHECK_RV(foundBegin, "Declaration without attributes not supported", true);
Range range(m_cppRefactoringFile->startOf(firstActivationToken),
m_cppRefactoringFile->endOf(lastActivationToken));
checkAndRewrite(symbol, range);
return true;
}
/*! Handle parameters in function declarations and definitions */
bool PointerDeclarationFormatter::visit(ParameterDeclarationAST *ast)
{
DeclaratorAST *declarator = ast->declarator;
CHECK_RV(declarator, "No declarator", true);
CHECK_RV(declarator->ptr_operator_list, "No Pointer or references", true);
Symbol *symbol = ast->symbol;
// Specify activation range
const int lastActivationToken = ast->equal_token
? ast->equal_token - 1
: ast->lastToken() - 1;
Range range(m_cppRefactoringFile->startOf(ast),
m_cppRefactoringFile->endOf(lastActivationToken));
checkAndRewrite(symbol, range);
return true;
}
/*! Handle declaration in foreach statement */
bool PointerDeclarationFormatter::visit(ForeachStatementAST *ast)
{
DeclaratorAST *declarator = ast->declarator;
CHECK_RV(declarator, "No declarator", true);
CHECK_RV(declarator->ptr_operator_list, "No Pointer or references", true);
CHECK_RV(ast->type_specifier_list, "No type specifier", true);
SpecifierAST *firstSpecifier = ast->type_specifier_list->value;
CHECK_RV(firstSpecifier, "No first type specifier", true);
CHECK_RV(ast->symbol, "No symbol", true);
Symbol *symbol = ast->symbol->memberAt(0);
// Specify activation range
const int lastActivationToken = declarator->equal_token
? declarator->equal_token - 1
: declarator->lastToken() - 1;
Range range(m_cppRefactoringFile->startOf(firstSpecifier),
m_cppRefactoringFile->endOf(lastActivationToken));
checkAndRewrite(symbol, range);
return true;
}
bool PointerDeclarationFormatter::visit(IfStatementAST *ast)
{
processIfWhileForStatement(ast->condition, ast->symbol);
return true;
}
bool PointerDeclarationFormatter::visit(WhileStatementAST *ast)
{
processIfWhileForStatement(ast->condition, ast->symbol);
return true;
}
bool PointerDeclarationFormatter::visit(ForStatementAST *ast)
{
processIfWhileForStatement(ast->condition, ast->symbol);
return true;
}
/*! Handle declaration in if, while and for statements */
void PointerDeclarationFormatter::processIfWhileForStatement(ExpressionAST *expression,
Symbol *statementSymbol)
{
CHECK_R(expression, "No expression");
CHECK_R(statementSymbol, "No symbol");
ConditionAST *condition = expression->asCondition();
CHECK_R(condition, "No condition");
DeclaratorAST *declarator = condition->declarator;
CHECK_R(declarator, "No declarator");
CHECK_R(declarator->ptr_operator_list, "No Pointer or references");
CHECK_R(declarator->equal_token, "No equal token");
Block *block = statementSymbol->asBlock();
CHECK_R(block, "No block");
CHECK_R(block->memberCount() > 0, "No block members");
// Get the right symbol
//
// This is especially important for e.g.
//
// for (char *s = 0; char *t = 0;) {}
//
// The declaration for 's' will be handled in visit(SimpleDeclarationAST *ast),
// so handle declaration for 't' here.
Scope::iterator it = block->lastMember() - 1;
Symbol *symbol = *it;
if (symbol && symbol->asScope()) { // True if there is a "{ ... }" following.
--it;
symbol = *it;
}
// Specify activation range
Range range(m_cppRefactoringFile->startOf(condition),
m_cppRefactoringFile->endOf(declarator->equal_token - 1));
checkAndRewrite(symbol, range);
}
/*!
\brief Do some further checks and rewrite the symbol's type and
name into the given range
\param symbol the symbol to be rewritten
\param range the substitution range in the file
*/
void PointerDeclarationFormatter::checkAndRewrite(Symbol *symbol, Range range,
unsigned charactersToRemove)
{
CHECK_R(range.start >= 0 && range.end > 0, "Range invalid");
CHECK_R(range.start < range.end, "Range invalid");
CHECK_R(symbol, "No symbol");
// Check range with respect to cursor position / selection
if (m_cursorHandling == RespectCursor) {
const QTextCursor cursor = m_cppRefactoringFile->cursor();
if (cursor.hasSelection()) {
CHECK_R(cursor.selectionStart() <= range.start, "Change not in selection range");
CHECK_R(range.end <= cursor.selectionEnd(), "Change not in selection range");
} else {
CHECK_R(range.start <= cursor.selectionStart(), "Cursor before activation range");
CHECK_R(cursor.selectionEnd() <= range.end, "Cursor after activation range");
}
}
FullySpecifiedType type = symbol->type();
if (Function *function = type->asFunctionType())
type = function->returnType();
// Check if pointers or references are involved
const QString originalDeclaration = m_cppRefactoringFile->textOf(range);
CHECK_R(originalDeclaration.contains(QLatin1Char('&'))
|| originalDeclaration.contains(QLatin1Char('*')), "No pointer or references");
// Does the rewritten declaration (part) differs from the original source (part)?
QString rewrittenDeclaration = rewriteDeclaration(type, symbol->name());
rewrittenDeclaration.remove(0, charactersToRemove);
CHECK_R(originalDeclaration != rewrittenDeclaration, "Rewritten is same as original");
if (DEBUG_OUTPUT) {
qDebug("Rewritten: \"%s\" --> \"%s\"", originalDeclaration.toLatin1().constData(),
rewrittenDeclaration.toLatin1().constData());
}
// Creating the replacement in the changeset may fail due to operations
// in the changeset that overlap with the current range.
//
// Consider this case:
//
// void (*foo)(char * s) = 0;
//
// First visit(SimpleDeclarationAST *ast) will be called. It creates a
// replacement that also includes the parameter.
// Next visit(ParameterDeclarationAST *ast) is called with the
// original source. It tries to create an replacement operation
// at this position and fails due to overlapping ranges (the
// simple declaration range includes parameter declaration range).
ChangeSet change(m_changeSet);
if (change.replace(range, rewrittenDeclaration))
m_changeSet = change;
else if (DEBUG_OUTPUT)
qDebug() << "Replacement operation failed";
}
/*! Rewrite/format the given type and name. */
QString PointerDeclarationFormatter::rewriteDeclaration(FullySpecifiedType type, const Name *name)
const
{
CHECK_RV(type.isValid(), "Invalid type", QString());
const char *identifier = 0;
if (const Name *declarationName = name) {
if (const Identifier *id = declarationName->identifier())
identifier = id->chars();
}
return m_overview.prettyType(type, QLatin1String(identifier));
}
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#ifndef CPPPOINTERFORMATTER_H
#define CPPPOINTERFORMATTER_H
#include "cpptools_global.h"
#include <AST.h>
#include <ASTVisitor.h>
#include <Overview.h>
#include <Symbols.h>
#include <cpptools/cpprefactoringchanges.h>
#include <utils/changeset.h>
namespace CppTools {
using namespace CPlusPlus;
using namespace CppTools;
using Utils::ChangeSet;
typedef Utils::ChangeSet::Range Range;
/*!
\class CppTools::PointerDeclarationFormatter
\brief Rewrite pointer or reference declarations accordingly to an Overview.
The following constructs are supported:
\list
\o Simple declarations
\o Parameters and return types of function declarations and definitions
\o Control flow statements like if, while, for, foreach
\endlist
*/
class CPPTOOLS_EXPORT PointerDeclarationFormatter: protected ASTVisitor
{
public:
/*!
\enum PointerDeclarationFormatter::CursorHandling
This simplifies the QuickFix implementation.
\value RespectCursor
Consider the cursor position / selection of the CppRefactoringFile
for rejecting edit operation candidates for the resulting ChangeSet.
If there is a selection, the range of the edit operation candidate
should be inside the selection. If there is no selection, the cursor
position should be within the range of the edit operation candidate.
\value IgnoreCursor
Cursor position or selection of the CppRefactoringFile will
_not_ be considered for aborting.
*/
enum CursorHandling { RespectCursor, IgnoreCursor };
explicit PointerDeclarationFormatter(const CppRefactoringFilePtr refactoringFile,
const Overview &overview,
CursorHandling cursorHandling = IgnoreCursor);
/*!
Returns a ChangeSet for applying the formatting changes.
The ChangeSet is empty if it was not possible to rewrite anything.
*/
ChangeSet format(AST *ast)
{
if (ast)
accept(ast);
return m_changeSet;
}
protected:
bool visit(SimpleDeclarationAST *ast);
bool visit(FunctionDefinitionAST *ast);
bool visit(ParameterDeclarationAST *ast);
bool visit(IfStatementAST *ast);
bool visit(WhileStatementAST *ast);
bool visit(ForStatementAST *ast);
bool visit(ForeachStatementAST *ast);
private:
void processIfWhileForStatement(ExpressionAST *expression, Symbol *symbol);
void checkAndRewrite(Symbol *symbol, Range range, unsigned charactersToRemove = 0);
QString rewriteDeclaration(FullySpecifiedType type, const Name *name) const;
const CppRefactoringFilePtr m_cppRefactoringFile;
const Overview &m_overview;
const CursorHandling m_cursorHandling;
ChangeSet m_changeSet;
};
} // namespace CppTools
#endif // CPPPOINTERFORMATTER_H
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#include "cpptoolsplugin.h"
#include <AST.h>
#include <CppDocument.h>
#include <Symbols.h>
#include <TranslationUnit.h>
#include <pp.h>
#include <cpptools/cpppointerdeclarationformatter.h>
#include <cpptools/cpprefactoringchanges.h>
#include <cpptools/cpptoolsplugin.h>
#include <texteditor/plaintexteditor.h>
#include <utils/changeset.h>
#include <utils/fileutils.h>
#include <QDebug>
#include <QDir>
#include <QTextCursor>
#include <QTextDocument>
#include <QtTest>
using namespace CPlusPlus;
using namespace CppTools;
using namespace CppTools::Internal;
using Utils::ChangeSet;
typedef Utils::ChangeSet::Range Range;
Q_DECLARE_METATYPE(Overview)
static QString stripCursor(const QString &source)
{
QString copy(source);
const int pos = copy.indexOf(QLatin1Char('@'));
if (pos != -1)
copy.remove(pos, 1);
else
qDebug() << Q_FUNC_INFO << "Warning: No cursor marker to strip.";
return copy;
}
struct TestEnvironment
{
QByteArray source;
Snapshot snapshot;
CppRefactoringFilePtr cppRefactoringFile;
TextEditor::BaseTextEditorWidget *editor;
Document::Ptr document;
QTextDocument *textDocument;
TranslationUnit *translationUnit;
Environment env;
TestEnvironment(const QByteArray &source, Document::ParseMode parseMode)
{
// Find cursor position and remove cursor marker '@'
int cursorPosition = 0;
QString sourceWithoutCursorMarker = QLatin1String(source);
const int pos = sourceWithoutCursorMarker.indexOf(QLatin1Char('@'));
if (pos != -1) {
sourceWithoutCursorMarker.remove(pos, 1);
cursorPosition = pos;
}
// Write source to temprorary file
const QString filePath = QDir::tempPath() + QLatin1String("/file.h");
document = Document::create(filePath);
Utils::FileSaver documentSaver(document->fileName());
documentSaver.write(sourceWithoutCursorMarker.toLatin1());
documentSaver.finalize();
// Preprocess source
Preprocessor preprocess(0, &env);
const QByteArray preprocessedSource = preprocess.run(filePath, sourceWithoutCursorMarker);