feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Merge remote-tracking branch 'origin/3.6'

Browse Source 
Conflicts:
	qtcreator.pri
	qtcreator.qbs

Change-Id: Ifbe181e86c161e082cc9a69a4bc7bd399f34ff47
This commit is contained in:
Oswald Buddenhagen
2016-01-04 14:11:07 +01:00
parent dbc49a32b8 f4545031f9
commit 5a7d3e78db
24 changed files with 3104 additions and 991 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3594
share/qtcreator/translations/qtcreator_pl.ts
View File

File diff suppressed because it is too large Load Diff

51
src/libs/clangbackendipc/codecompletionchunk.cpp
View File

@@ -37,17 +37,12 @@
namespace ClangBackEnd {
CodeCompletionChunk::CodeCompletionChunk()
: kind_(Invalid)
{
}
CodeCompletionChunk::CodeCompletionChunk(CodeCompletionChunk::Kind kind,
const Utf8String &text,
const CodeCompletionChunks &optionalChunks)
bool isOptional)
: text_(text),
optionalChunks_(optionalChunks),
kind_(kind)
kind_(kind),
isOptional_(isOptional)
{
}
@@ -61,23 +56,21 @@ const Utf8String &CodeCompletionChunk::text() const
return text_;
}
const CodeCompletionChunks &CodeCompletionChunk::optionalChunks() const
bool CodeCompletionChunk::isOptional() const
{
return optionalChunks_;
return isOptional_;
}
quint32 &CodeCompletionChunk::kindAsInt()
quint8 &CodeCompletionChunk::kindAsInt()
{
return reinterpret_cast<quint32&>(kind_);
return reinterpret_cast<quint8&>(kind_);
}
QDataStream &operator<<(QDataStream &out, const CodeCompletionChunk &chunk)
{
out << chunk.kind_;
out << quint8(chunk.kind_);
out << chunk.text_;
if (chunk.kind() == CodeCompletionChunk::Optional)
out << chunk.optionalChunks_;
out << chunk.isOptional_;
return out;
}
@@ -86,9 +79,7 @@ QDataStream &operator>>(QDataStream &in, CodeCompletionChunk &chunk)
{
in >> chunk.kindAsInt();
in >> chunk.text_;
if (chunk.kind_ == CodeCompletionChunk::Optional)
in >> chunk.optionalChunks_;
in >> chunk.isOptional_;
return in;
}
@@ -97,7 +88,7 @@ bool operator==(const CodeCompletionChunk &first, const CodeCompletionChunk &sec
{
return first.kind() == second.kind()
&& first.text() == second.text()
&& first.optionalChunks() == second.optionalChunks();
&& first.isOptional() == second.isOptional();
}
static const char *completionChunkKindToString(CodeCompletionChunk::Kind kind)
@@ -136,8 +127,8 @@ QDebug operator<<(QDebug debug, const CodeCompletionChunk &chunk)
debug.nospace() << completionChunkKindToString(chunk.kind()) << ", ";
debug.nospace() << chunk.text();
if (chunk.kind() == CodeCompletionChunk::Optional)
debug.nospace() << ", " << chunk.optionalChunks();
if (chunk.isOptional())
debug.nospace() << ", optional";
debug.nospace() << ")";
@@ -150,20 +141,8 @@ void PrintTo(const CodeCompletionChunk &chunk, ::std::ostream* os)
*os << completionChunkKindToString(chunk.kind()) << ", ";
*os << chunk.text().constData();
if (chunk.kind() == CodeCompletionChunk::Optional) {
const auto optionalChunks = chunk.optionalChunks();
*os << ", {";
for (auto optionalChunkPosition = optionalChunks.cbegin();
optionalChunkPosition != optionalChunks.cend();
++optionalChunkPosition) {
PrintTo(*optionalChunkPosition, os);
if (std::next(optionalChunkPosition) != optionalChunks.cend())
*os << ", ";
}
*os << "}";
}
if (chunk.isOptional())
*os << ", optional";
*os << "}";
}

16
src/libs/clangbackendipc/codecompletionchunk.h
View File

@@ -49,7 +49,7 @@ class CMBIPC_EXPORT CodeCompletionChunk
friend CMBIPC_EXPORT bool operator==(const CodeCompletionChunk &first, const CodeCompletionChunk &second);
public:
enum Kind : quint32 {
enum Kind : quint8 {
Optional,
TypedText,
Text,
@@ -71,25 +71,25 @@ public:
Equal,
HorizontalSpace,
VerticalSpace,
Invalid = 255};
Invalid = 255
};
CodeCompletionChunk();
CodeCompletionChunk() = default;
CodeCompletionChunk(Kind kind,
const Utf8String &text,
const CodeCompletionChunks &optionalChunks = CodeCompletionChunks());
bool isOptional = false);
Kind kind() const;
const Utf8String &text() const;
const CodeCompletionChunks &optionalChunks() const;
bool isOptional() const;
private:
quint32 &kindAsInt();
quint8 &kindAsInt();
private:
Utf8String text_;
CodeCompletionChunks optionalChunks_;
Kind kind_ = Invalid;
bool isOptional_ = false;
};
CMBIPC_EXPORT QDataStream &operator<<(QDataStream &out, const CodeCompletionChunk &chunk);

4
src/libs/qmljs/qmljstypedescriptionreader.cpp
View File

@@ -120,8 +120,6 @@ void TypeDescriptionReader::readDocument(UiProgram *ast)
addError(import->versionToken, tr("Major version different from 1 not supported."));
return;
}
if (version.minorVersion() > 1)
addWarning(import->versionToken, tr("Reading only version 1.1 parts."));
if (!ast->members || !ast->members->member || ast->members->next) {
addError(SourceLocation(), tr("Expected document to contain a single object definition."));
@@ -153,8 +151,6 @@ void TypeDescriptionReader::readModule(UiObjectDefinition *ast)
typeName = toString(component->qualifiedTypeNameId);
if (!component || (typeName != QLatin1String("Component") && typeName != QLatin1String("ModuleApi"))) {
addWarning(member->firstSourceLocation(),
tr("Expected only Component and ModuleApi object definitions."));
continue;
}

2
src/libs/utils/fancylineedit.cpp
View File

@@ -103,7 +103,7 @@ public:
bool m_iconEnabled[2];
bool m_isFiltering = false;
bool m_firstChange = false;
bool m_firstChange = true;
QString m_lastFilterText;

105
src/plugins/clangcodemodel/clangcompletionchunkstotextconverter.cpp
View File

@@ -36,7 +36,8 @@
namespace ClangCodeModel {
namespace Internal {
void CompletionChunksToTextConverter::parseChunks(const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks)
void CompletionChunksToTextConverter::parseChunks(
const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks)
{
m_text.clear();
m_placeholderPositions.clear();
@@ -49,7 +50,7 @@ void CompletionChunksToTextConverter::parseChunks(const ClangBackEnd::CodeComple
m_codeCompletionChunks.cend(),
[this] (const ClangBackEnd::CodeCompletionChunk &chunk)
{
parse(chunk);
parseDependendOnTheOptionalState(chunk);
m_previousCodeCompletionChunk = chunk;
});
}
@@ -74,14 +75,15 @@ void CompletionChunksToTextConverter::setAddSpaces(bool addSpaces)
m_addSpaces = addSpaces;
}
void CompletionChunksToTextConverter::setAddExtraVerticalSpaceBetweenBraces(bool addExtraVerticalSpaceBetweenBraces)
void CompletionChunksToTextConverter::setAddExtraVerticalSpaceBetweenBraces(
bool addExtraVerticalSpaceBetweenBraces)
{
m_addExtraVerticalSpaceBetweenBraces = addExtraVerticalSpaceBetweenBraces;
}
void CompletionChunksToTextConverter::setAddHtmlTags(bool addHtmlTags)
void CompletionChunksToTextConverter::setEmphasizeOptional(bool emphasizeOptional)
{
m_addHtmlTags = addHtmlTags;
m_emphasizeOptional = emphasizeOptional;
}
void CompletionChunksToTextConverter::setAddOptional(bool addOptional)
@@ -89,6 +91,11 @@ void CompletionChunksToTextConverter::setAddOptional(bool addOptional)
m_addOptional = addOptional;
}
void CompletionChunksToTextConverter::setPlaceHolderToEmphasize(int placeHolderNumber)
{
m_placeHolderPositionToEmphasize = placeHolderNumber;
}
const QString &CompletionChunksToTextConverter::text() const
{
return m_text;
@@ -104,19 +111,27 @@ bool CompletionChunksToTextConverter::hasPlaceholderPositions() const
return m_placeholderPositions.size() > 0;
}
QString CompletionChunksToTextConverter::convertToFunctionSignature(const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks)
QString CompletionChunksToTextConverter::convertToFunctionSignature(
const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks,
int parameterToEmphasize)
{
CompletionChunksToTextConverter converter;
converter.setAddPlaceHolderText(true);
converter.setAddResultType(true);
converter.setAddOptional(true);
converter.setEmphasizeOptional(true);
converter.setAddPlaceHolderPositions(true);
converter.setPlaceHolderToEmphasize(parameterToEmphasize);
converter.parseChunks(codeCompletionChunks);
return converter.text();
}
QString CompletionChunksToTextConverter::convertToName(const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks)
QString CompletionChunksToTextConverter::convertToName(
const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks)
{
CompletionChunksToTextConverter converter;
@@ -125,14 +140,15 @@ QString CompletionChunksToTextConverter::convertToName(const ClangBackEnd::CodeC
return converter.text();
}
QString CompletionChunksToTextConverter::convertToToolTip(const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks)
QString CompletionChunksToTextConverter::convertToToolTip(
const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks)
{
CompletionChunksToTextConverter converter;
converter.setAddPlaceHolderText(true);
converter.setAddSpaces(true);
converter.setAddExtraVerticalSpaceBetweenBraces(true);
converter.setAddOptional(true);
converter.setAddHtmlTags(true);
converter.setEmphasizeOptional(true);
converter.setAddResultType(true);
converter.parseChunks(codeCompletionChunks);
@@ -140,13 +156,13 @@ QString CompletionChunksToTextConverter::convertToToolTip(const ClangBackEnd::Co
return converter.text();
}
void CompletionChunksToTextConverter::parse(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
void CompletionChunksToTextConverter::parse(
const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
{
using ClangBackEnd::CodeCompletionChunk;
switch (codeCompletionChunk.kind()) {
case CodeCompletionChunk::ResultType: parseResultType(codeCompletionChunk.text()); break;
case CodeCompletionChunk::Optional: parseOptional(codeCompletionChunk); break;
case CodeCompletionChunk::Placeholder: parsePlaceHolder(codeCompletionChunk); break;
case CodeCompletionChunk::LeftParen: parseLeftParen(codeCompletionChunk); break;
case CodeCompletionChunk::LeftBrace: parseLeftBrace(codeCompletionChunk); break;
@@ -154,10 +170,19 @@ void CompletionChunksToTextConverter::parse(const ClangBackEnd::CodeCompletionCh
}
}
void CompletionChunksToTextConverter::parseDependendOnTheOptionalState(
const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
{
wrapInCursiveTagIfOptional(codeCompletionChunk);
if (isNotOptionalOrAddOptionals(codeCompletionChunk))
parse(codeCompletionChunk);
}
void CompletionChunksToTextConverter::parseResultType(const Utf8String &resultTypeText)
{
if (m_addResultType)
m_text += resultTypeText.toString() + QChar(QChar::Space);
m_text += resultTypeText.toString().toHtmlEscaped() + QChar(QChar::Space);
}
void CompletionChunksToTextConverter::parseText(const Utf8String &text)
@@ -167,32 +192,36 @@ void CompletionChunksToTextConverter::parseText(const Utf8String &text)
m_text += QChar(QChar::Space);
}
m_text += text.toString();
m_text += text.toString().toHtmlEscaped();
}
void CompletionChunksToTextConverter::parseOptional(const ClangBackEnd::CodeCompletionChunk &optionalCodeCompletionChunk)
void CompletionChunksToTextConverter::wrapInCursiveTagIfOptional(
const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
{
if (m_addOptional) {
if (m_addHtmlTags)
if (m_emphasizeOptional) {
if (!m_previousCodeCompletionChunk.isOptional() && codeCompletionChunk.isOptional())
m_text += QStringLiteral("<i>");
m_text += convertToFunctionSignature(optionalCodeCompletionChunk.optionalChunks());
if (m_addHtmlTags)
else if (m_previousCodeCompletionChunk.isOptional() && !codeCompletionChunk.isOptional())
m_text += QStringLiteral("</i>");
}
}
}
void CompletionChunksToTextConverter::parsePlaceHolder(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
void CompletionChunksToTextConverter::parsePlaceHolder(
const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
{
if (m_addPlaceHolderText)
m_text += codeCompletionChunk.text().toString();
if (m_addPlaceHolderText) {
appendText(codeCompletionChunk.text().toString().toHtmlEscaped(),
emphasizeCurrentPlaceHolder());
}
if (m_addPlaceHolderPositions)
m_placeholderPositions.push_back(m_text.size());
}
void CompletionChunksToTextConverter::parseLeftParen(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
void CompletionChunksToTextConverter::parseLeftParen(
const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
{
if (canAddSpace())
m_text += QChar(QChar::Space);
@@ -200,7 +229,8 @@ void CompletionChunksToTextConverter::parseLeftParen(const ClangBackEnd::CodeCom
m_text += codeCompletionChunk.text().toString();
}
void CompletionChunksToTextConverter::parseLeftBrace(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
void CompletionChunksToTextConverter::parseLeftBrace(
const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
{
if (canAddSpace())
m_text += QChar(QChar::Space);
@@ -214,7 +244,8 @@ void CompletionChunksToTextConverter::addExtraVerticalSpaceBetweenBraces()
addExtraVerticalSpaceBetweenBraces(m_codeCompletionChunks.begin());
}
void CompletionChunksToTextConverter::addExtraVerticalSpaceBetweenBraces(const ClangBackEnd::CodeCompletionChunks::iterator &begin)
void CompletionChunksToTextConverter::addExtraVerticalSpaceBetweenBraces(
const ClangBackEnd::CodeCompletionChunks::iterator &begin)
{
using ClangBackEnd::CodeCompletionChunk;
@@ -256,6 +287,24 @@ void CompletionChunksToTextConverter::addExtraVerticalSpaceBetweenBraces(const C
}
}
bool CompletionChunksToTextConverter::emphasizeCurrentPlaceHolder() const
{
if (m_addPlaceHolderPositions) {
const uint currentPlaceHolderPosition = m_placeholderPositions.size() + 1;
return uint(m_placeHolderPositionToEmphasize) == currentPlaceHolderPosition;
}
return false;
}
void CompletionChunksToTextConverter::appendText(const QString &text, bool boldFormat)
{
if (boldFormat)
m_text += QStringLiteral("<b>") + text + QStringLiteral("</b>");
else
m_text += text;
}
bool CompletionChunksToTextConverter::canAddSpace() const
{
return m_addSpaces
@@ -263,6 +312,12 @@ bool CompletionChunksToTextConverter::canAddSpace() const
&& m_previousCodeCompletionChunk.kind() != ClangBackEnd::CodeCompletionChunk::RightAngle;
}
bool CompletionChunksToTextConverter::isNotOptionalOrAddOptionals(
const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk) const
{
return !codeCompletionChunk.isOptional() || m_addOptional;
}
} // namespace Internal
} // namespace ClangCodeModel

16
src/plugins/clangcodemodel/clangcompletionchunkstotextconverter.h
View File

@@ -52,40 +52,48 @@ public:
void setAddResultType(bool addResultType);
void setAddSpaces(bool addSpaces);
void setAddExtraVerticalSpaceBetweenBraces(bool addExtraVerticalSpaceBetweenBraces);
void setAddHtmlTags(bool addHtmlTags);
void setEmphasizeOptional(bool emphasizeOptional);
void setAddOptional(bool addOptional);
void setPlaceHolderToEmphasize(int placeHolderNumber);
const QString &text() const;
const std::vector<int> &placeholderPositions() const;
bool hasPlaceholderPositions() const;
static QString convertToFunctionSignature(const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks);
static QString convertToFunctionSignature(const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks,
int parameterToEmphasize = -1);
static QString convertToName(const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks);
static QString convertToToolTip(const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks);
private:
void parse(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk);
void parseDependendOnTheOptionalState(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk);
void parseResultType(const Utf8String &text);
void parseText(const Utf8String &text);
void parseOptional(const ClangBackEnd::CodeCompletionChunk &optionalCodeCompletionChunk);
void wrapInCursiveTagIfOptional(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk);
void parsePlaceHolder(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk);
void parseLeftParen(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk);
void parseLeftBrace(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk);
void addExtraVerticalSpaceBetweenBraces();
void addExtraVerticalSpaceBetweenBraces(const ClangBackEnd::CodeCompletionChunks::iterator &);
void appendText(const QString &text, bool boldFormat = false);
bool canAddSpace() const;
bool isNotOptionalOrAddOptionals(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk) const;
bool emphasizeCurrentPlaceHolder() const;
private:
std::vector<int> m_placeholderPositions;
ClangBackEnd::CodeCompletionChunks m_codeCompletionChunks;
ClangBackEnd::CodeCompletionChunk m_previousCodeCompletionChunk;
QString m_text;
int m_placeHolderPositionToEmphasize = -1;
bool m_addPlaceHolderText = false;
bool m_addPlaceHolderPositions = false;
bool m_addResultType = false;
bool m_addSpaces = false;
bool m_addExtraVerticalSpaceBetweenBraces = false;
bool m_addHtmlTags = false;
bool m_emphasizeOptional = false;
bool m_addOptional = false;
};

81
src/plugins/clangcodemodel/clangfunctionhintmodel.cpp
View File

@@ -41,7 +41,7 @@ using namespace CPlusPlus;
ClangFunctionHintModel::ClangFunctionHintModel(const ClangBackEnd::CodeCompletions &functionSymbols)
: m_functionSymbols(functionSymbols)
, m_currentArg(-1)
, m_currentArgument(-1)
{
}
@@ -56,52 +56,61 @@ int ClangFunctionHintModel::size() const
QString ClangFunctionHintModel::text(int index) const
{
#if 0
// TODO: add the boldening to the result
Overview overview;
overview.setShowReturnTypes(true);
overview.setShowArgumentNames(true);
overview.setMarkedArgument(m_currentArg + 1);
Function *f = m_functionSymbols.at(index);
const ClangBackEnd::CodeCompletionChunks chunks = m_functionSymbols.at(index).chunks();
const QString signatureWithEmphasizedCurrentParameter
= CompletionChunksToTextConverter::convertToFunctionSignature(chunks, m_currentArgument + 1);
const QString prettyMethod = overview(f->type(), f->name());
const int begin = overview.markedArgumentBegin();
const int end = overview.markedArgumentEnd();
QString hintText;
hintText += prettyMethod.left(begin).toHtmlEscaped());
hintText += "<b>";
hintText += prettyMethod.mid(begin, end - begin).toHtmlEscaped());
hintText += "</b>";
hintText += prettyMethod.mid(end).toHtmlEscaped());
return hintText;
#endif
return CompletionChunksToTextConverter::convertToFunctionSignature(m_functionSymbols.at(index).chunks());
return signatureWithEmphasizedCurrentParameter;
}
int ClangFunctionHintModel::activeArgument(const QString &prefix) const
{
int argnr = 0;
int parcount = 0;
int activeArgumentNumber = 0;
int unbalancedParens = 0; // expressions
int unbalancedBraces = 0; // initializer lists
int unbalancedBrackets = 0; // lambda-capture
int unbalancedLessGreater = 0; // template arguments
SimpleLexer tokenize;
Tokens tokens = tokenize(prefix);
for (int i = 0; i < tokens.count(); ++i) {
const Token &tk = tokens.at(i);
if (tk.is(T_LPAREN))
++parcount;
else if (tk.is(T_RPAREN))
--parcount;
else if (! parcount && tk.is(T_COMMA))
++argnr;
const Tokens tokens = tokenize(prefix);
for (const Token &token : tokens) {
if (token.is(T_LPAREN)) {
++unbalancedParens;
} else if (token.is(T_RPAREN)) {
--unbalancedParens;
} else if (token.is(T_LBRACE)) {
++unbalancedBraces;
} else if (token.is(T_RBRACE)) {
--unbalancedBraces;
} else if (token.is(T_LBRACKET)) {
++unbalancedBrackets;
} else if (token.is(T_RBRACKET)) {
--unbalancedBrackets;
} else if (token.is(T_LESS)) {
++unbalancedLessGreater;
} else if (token.is(T_GREATER)) {
--unbalancedLessGreater;
} else if (!unbalancedParens
&& !unbalancedBraces
&& !unbalancedBrackets
&& !unbalancedLessGreater
&& token.is(T_COMMA)) {
++activeArgumentNumber;
}
}
if (parcount < 0)
if (unbalancedParens < 0
|| unbalancedBraces < 0
|| unbalancedBrackets < 0
|| unbalancedLessGreater < 0) {
return -1;
}
if (argnr != m_currentArg)
m_currentArg = argnr;
if (activeArgumentNumber != m_currentArgument)
m_currentArgument = activeArgumentNumber;
return argnr;
return activeArgumentNumber;
}
} // namespace Internal

2
src/plugins/clangcodemodel/clangfunctionhintmodel.h
View File

@@ -50,7 +50,7 @@ public:
private:
ClangBackEnd::CodeCompletions m_functionSymbols;
mutable int m_currentArg;
mutable int m_currentArgument;
};
} // namespace Internal

10
src/plugins/clangcodemodel/test/clangcodecompletion_test.cpp
View File

@@ -914,11 +914,11 @@ void ClangCodeCompletionTest::testCompleteFunctions()
QVERIFY(hasItem(t.proposal, "void f()"));
QVERIFY(hasItem(t.proposal, "void f(int a)"));
QVERIFY(hasItem(t.proposal, "void f(const QString &s)"));
QVERIFY(hasItem(t.proposal, "void f(char c, int optional)")); // TODO: No default argument?
QVERIFY(hasItem(t.proposal, "void f(char c, int optional1, int optional2)")); // TODO: No default argument?
QVERIFY(hasItem(t.proposal, "void f(const TType<QString> *t)"));
QVERIFY(hasItem(t.proposal, "TType<QString> f(bool)"));
QVERIFY(hasItem(t.proposal, "void f(const QString &amp;s)"));
QVERIFY(hasItem(t.proposal, "void f(char c<i>, int optional</i>)")); // TODO: No default argument?
QVERIFY(hasItem(t.proposal, "void f(char c<i>, int optional1, int optional2</i>)")); // TODO: No default argument?
QVERIFY(hasItem(t.proposal, "void f(const TType&lt;QString&gt; *t)"));
QVERIFY(hasItem(t.proposal, "TType&lt;QString&gt; f(bool)"));
}
void ClangCodeCompletionTest::testCompleteConstructorAndFallbackToGlobalCompletion()

2
src/plugins/debugger/gdb/gdbengine.cpp
View File

@@ -3659,7 +3659,7 @@ void GdbEngine::handleVarAssign(const DebuggerResponse &)
void GdbEngine::assignValueInDebugger(WatchItem *item,
const QString &expression, const QVariant &value)
{
DebuggerCommand cmd("assignValue");
DebuggerCommand cmd("assignValue", PythonCommand);
cmd.arg("type", item->type.toHex());
cmd.arg("expr", expression.toLatin1().toHex());
cmd.arg("value", value.toString().toLatin1().toHex());

5
src/plugins/help/textbrowserhelpviewer.cpp
View File

@@ -55,6 +55,7 @@ TextBrowserHelpViewer::TextBrowserHelpViewer(QWidget *parent)
: HelpViewer(parent)
, m_textBrowser(new TextBrowserHelpWidget(this))
{
m_textBrowser->setOpenLinks(false);
QVBoxLayout *layout = new QVBoxLayout;
setLayout(layout);
layout->setContentsMargins(0, 0, 0, 0);
@@ -68,6 +69,8 @@ TextBrowserHelpViewer::TextBrowserHelpViewer(QWidget *parent)
p.setColor(QPalette::Text, Qt::black);
setPalette(p);
connect(m_textBrowser, &TextBrowserHelpWidget::anchorClicked,
this, &TextBrowserHelpViewer::setSource);
connect(m_textBrowser, SIGNAL(sourceChanged(QUrl)), this, SIGNAL(titleChanged()));
connect(m_textBrowser, SIGNAL(forwardAvailable(bool)), this, SIGNAL(forwardAvailable(bool)));
connect(m_textBrowser, SIGNAL(backwardAvailable(bool)), this, SIGNAL(backwardAvailable(bool)));
@@ -315,7 +318,7 @@ TextBrowserHelpWidget::TextBrowserHelpWidget(TextBrowserHelpViewer *parent)
QVariant TextBrowserHelpWidget::loadResource(int type, const QUrl &name)
{
if (type < 4)
if (type < QTextDocument::UserResource)
return LocalHelpManager::helpData(name).data;
return QByteArray();
}

2
src/plugins/qmljseditor/qmljscompletionassist.cpp
View File

@@ -858,6 +858,8 @@ bool QmlJSCompletionAssistProcessor::acceptsIdleEditor() const
maybeAccept = true;
} else {
const QChar &charUnderCursor = m_interface->textDocument()->characterAt(cursorPos);
if (isValidIdentifierChar(charUnderCursor))
return false;
if (isIdentifierChar(charBeforeCursor)
&& ((charUnderCursor.isSpace()
|| charUnderCursor.isNull()

9
src/plugins/qmljseditor/qmljsreuse.cpp
View File

@@ -54,6 +54,15 @@ bool isIdentifierChar(const QChar &c, bool atStart, bool acceptDollar)
}
}
bool isValidFirstIdentifierChar(const QChar &ch) {
return ch.isLetter() || ch == QLatin1Char('_') || ch.isHighSurrogate()
|| ch.isLowSurrogate();
}
bool isValidIdentifierChar(const QChar &ch) {
return isValidFirstIdentifierChar(ch) || ch.isNumber();
}
bool isDelimiterChar(const QChar &c)
{
switch (c.unicode()) {

2
src/plugins/qmljseditor/qmljsreuse.h
View File

@@ -42,6 +42,8 @@ namespace QmlJSEditor {
namespace Internal {
bool isIdentifierChar(const QChar &c, bool atStart = false, bool acceptDollar = true);
bool isValidFirstIdentifierChar(const QChar &c);
bool isValidIdentifierChar(const QChar &c);
bool isDelimiterChar(const QChar &c);
bool isActivationChar(const QChar &c);

3
src/plugins/qnx/qnxsettingswidget.cpp
View File

@@ -171,7 +171,7 @@ void QnxSettingsWidget::populateConfigsCombo()
void QnxSettingsWidget::setConfigState(QnxConfiguration *config,
QnxSettingsWidget::State state)
{
QnxSettingsWidget::State stateToRemove;
QnxSettingsWidget::State stateToRemove = QnxSettingsWidget::Activated;
switch (state) {
case QnxSettingsWidget::Added :
stateToRemove = QnxSettingsWidget::Removed;
@@ -184,6 +184,7 @@ void QnxSettingsWidget::setConfigState(QnxConfiguration *config,
break;
case QnxSettingsWidget::Deactivated:
stateToRemove = QnxSettingsWidget::Activated;
break;
}
foreach (const ConfigState &configState, m_changedConfigs) {

3
src/shared/proparser/qmakeevaluator.h
View File

@@ -38,7 +38,6 @@
#include "qmakeparser.h"
#include "ioutils.h"
#include <qiodevice.h>
#include <qlist.h>
#include <qlinkedlist.h>
#include <qmap.h>
@@ -49,6 +48,8 @@
#include <qshareddata.h>
#ifndef QT_BOOTSTRAPPED
# include <qprocess.h>
#else
# include <qiodevice.h>
#endif
#ifdef PROEVALUATOR_THREAD_SAFE
# include <qmutex.h>

20
src/tools/clangbackend/ipcsource/codecompletionchunkconverter.cpp
View File

@@ -42,15 +42,14 @@ void CodeCompletionChunkConverter::extractCompletionChunks(CXCompletionString co
for (uint chunkIndex = 0; chunkIndex < completionChunkCount; ++chunkIndex) {
const CodeCompletionChunk::Kind kind = chunkKind(completionString, chunkIndex);
if (kind == CodeCompletionChunk::Optional)
chunks.append(CodeCompletionChunk(kind,
chunkText(completionString, chunkIndex),
optionalChunks(completionString, chunkIndex)));
else
if (kind == CodeCompletionChunk::Optional) {
extractOptionalCompletionChunks(clang_getCompletionChunkCompletionString(completionString, chunkIndex));
} else {
chunks.append(CodeCompletionChunk(kind,
chunkText(completionString, chunkIndex)));
}
}
}
void CodeCompletionChunkConverter::extractOptionalCompletionChunks(CXCompletionString completionString)
{
@@ -62,7 +61,7 @@ void CodeCompletionChunkConverter::extractOptionalCompletionChunks(CXCompletionS
if (kind == CodeCompletionChunk::Optional)
extractOptionalCompletionChunks(clang_getCompletionChunkCompletionString(completionString, chunkIndex));
else
chunks.append(CodeCompletionChunk(kind, chunkText(completionString, chunkIndex)));
chunks.append(CodeCompletionChunk(kind, chunkText(completionString, chunkIndex), true));
}
}
@@ -85,14 +84,5 @@ Utf8String CodeCompletionChunkConverter::chunkText(CXCompletionString completion
return ClangString(clang_getCompletionChunkText(completionString, chunkIndex));
}
CodeCompletionChunks CodeCompletionChunkConverter::optionalChunks(CXCompletionString completionString, uint chunkIndex)
{
CodeCompletionChunkConverter converter;
converter.extractOptionalCompletionChunks(clang_getCompletionChunkCompletionString(completionString, chunkIndex));
return converter.chunks;
}
} // namespace ClangBackEnd

1
src/tools/clangbackend/ipcsource/codecompletionchunkconverter.h
View File

@@ -47,7 +47,6 @@ public:
static Utf8String chunkText(CXCompletionString completionString, uint chunkIndex);
private:
CodeCompletionChunks optionalChunks(CXCompletionString completionString, uint chunkIndex);
static CodeCompletionChunk::Kind chunkKind(CXCompletionString completionString, uint chunkIndex);
void extractCompletionChunks(CXCompletionString completionString);
void extractOptionalCompletionChunks(CXCompletionString completionString);

1
src/tools/clangbackend/ipcsource/highlightinginformation.cpp
View File

@@ -201,6 +201,7 @@ HighlightingType HighlightingInformation::identifierKind(const Cursor &cursor) c
case CXCursor_TemplateTemplateParameter:
case CXCursor_UnionDecl:
case CXCursor_StructDecl:
case CXCursor_OverloadedDeclRef:
case CXCursor_TemplateRef:
case CXCursor_Namespace:
case CXCursor_NamespaceRef:

9
tests/unit/unittest/codecompletionsextractortest.cpp
View File

@@ -630,11 +630,10 @@ TEST_F(CodeCompletionsExtractor, CompletionChunksFunctionWithOptionalChunks)
{CodeCompletionChunk::TypedText, Utf8StringLiteral("FunctionWithOptional")},
{CodeCompletionChunk::LeftParen, Utf8StringLiteral("(")},
{CodeCompletionChunk::Placeholder, Utf8StringLiteral("int x")},
{CodeCompletionChunk::Optional, Utf8String(), CodeCompletionChunks({
{CodeCompletionChunk::Comma, Utf8StringLiteral(", ")},
{CodeCompletionChunk::Placeholder, Utf8StringLiteral("char y")},
{CodeCompletionChunk::Comma, Utf8StringLiteral(", ")},
{CodeCompletionChunk::Placeholder, Utf8StringLiteral("int z")}})},
{CodeCompletionChunk::Comma, Utf8StringLiteral(", "), true},
{CodeCompletionChunk::Placeholder, Utf8StringLiteral("char y"), true},
{CodeCompletionChunk::Comma, Utf8StringLiteral(", "), true},
{CodeCompletionChunk::Placeholder, Utf8StringLiteral("int z"), true},
{CodeCompletionChunk::RightParen, Utf8StringLiteral(")")}})));
}

119
tests/unit/unittest/completionchunkstotextconvertertest.cpp
View File

@@ -50,6 +50,7 @@ protected:
protected:
Converter converter;
CodeCompletionChunk integerResultType{CodeCompletionChunk::ResultType, Utf8StringLiteral("int")};
CodeCompletionChunk templateResultType{CodeCompletionChunk::ResultType, Utf8StringLiteral("Foo<int>")};
CodeCompletionChunk enumerationResultType{CodeCompletionChunk::ResultType, Utf8StringLiteral("Enumeration")};
CodeCompletionChunk functionName{CodeCompletionChunk::TypedText, Utf8StringLiteral("Function")};
CodeCompletionChunk variableName{CodeCompletionChunk::TypedText, Utf8StringLiteral("Variable")};
@@ -63,6 +64,7 @@ protected:
CodeCompletionChunk functionArgumentX{CodeCompletionChunk::Placeholder, Utf8StringLiteral("char x")};
CodeCompletionChunk functionArgumentY{CodeCompletionChunk::Placeholder, Utf8StringLiteral("int y")};
CodeCompletionChunk functionArgumentZ{CodeCompletionChunk::Placeholder, Utf8StringLiteral("int z")};
CodeCompletionChunk functionArgumentTemplate{CodeCompletionChunk::Placeholder, Utf8StringLiteral("const Foo<int> &foo")};
CodeCompletionChunk switchName{CodeCompletionChunk::TypedText, Utf8StringLiteral("switch")};
CodeCompletionChunk condition{CodeCompletionChunk::Placeholder, Utf8StringLiteral("condition")};
CodeCompletionChunk leftBrace{CodeCompletionChunk::LeftBrace, Utf8StringLiteral("{")};
@@ -80,10 +82,12 @@ protected:
CodeCompletionChunk elseName{CodeCompletionChunk::TypedText, Utf8StringLiteral("else")};
CodeCompletionChunk ifName{CodeCompletionChunk::TypedText, Utf8StringLiteral("if")};
CodeCompletionChunk horizontalSpace{CodeCompletionChunk::HorizontalSpace, Utf8StringLiteral(" ")};
CodeCompletionChunk optional{CodeCompletionChunk::Optional, Utf8String(), {comma, functionArgumentY, comma, functionArgumentZ}};
CodeCompletionChunk enableIfT{CodeCompletionChunk::TypedText, Utf8StringLiteral("enable_if_t")};
CodeCompletionChunk enableIfTCondition{CodeCompletionChunk::Placeholder, Utf8StringLiteral("_Cond")};
CodeCompletionChunk enableIfTType{CodeCompletionChunk::Placeholder, Utf8StringLiteral("_Tp")};
CodeCompletionChunk optionalEnableIfTType{CodeCompletionChunk::Placeholder, Utf8StringLiteral("_Tp"), true};
CodeCompletionChunk optionalComma{CodeCompletionChunk::Comma, Utf8StringLiteral(", "), true};
CodeCompletionChunk optionalFunctionArgumentY{CodeCompletionChunk::Placeholder, Utf8StringLiteral("int y"), true};
CodeCompletionChunk optionalFunctionArgumentZ{CodeCompletionChunk::Placeholder, Utf8StringLiteral("int z"), true};
};
TEST_F(CompletionChunksToTextConverter, ParseIsClearingText)
@@ -117,9 +121,111 @@ TEST_F(CompletionChunksToTextConverter, ConvertFunctionWithParameters)
ASSERT_THAT(converter.text(), QStringLiteral("int Function(char x)"));
}
TEST_F(CompletionChunksToTextConverter, ConvertToFunctionSignatureWithOneArgument)
{
CodeCompletionChunks completionChunks({integerResultType,
functionName,
leftParen,
functionArgumentX,
rightParen});
using ClangCodeModel::Internal::CompletionChunksToTextConverter;
ASSERT_THAT(converter.convertToFunctionSignature(completionChunks),
QStringLiteral("int Function(char x)"));
}
TEST_F(CompletionChunksToTextConverter, ConvertToFunctionSignatureWithOneParameterThatIsActive)
{
CodeCompletionChunks completionChunks({integerResultType,
functionName,
leftParen,
functionArgumentX,
rightParen});
ASSERT_THAT(converter.convertToFunctionSignature(completionChunks, 1),
QStringLiteral("int Function(<b>char x</b>)"));
}
TEST_F(CompletionChunksToTextConverter, ConvertToFunctionSignatureWithOneParameterAndInInvalidActiveParameter)
{
CodeCompletionChunks completionChunks({integerResultType,
functionName,
leftParen,
functionArgumentX,
rightParen});
ASSERT_THAT(converter.convertToFunctionSignature(completionChunks, -1),
QStringLiteral("int Function(char x)"));
}
TEST_F(CompletionChunksToTextConverter, ConvertToFunctionSignatureWithTwoParametersWhereOneIsActive)
{
CodeCompletionChunks completionChunks({integerResultType,
functionName,
leftParen,
functionArgumentX,
comma,
functionArgumentY,
rightParen});
ASSERT_THAT(converter.convertToFunctionSignature(completionChunks, 2),
QStringLiteral("int Function(char x, <b>int y</b>)"));
}
TEST_F(CompletionChunksToTextConverter, ConvertToFunctionSignatureWithTwoParametersWhereOneIsOptionalAndActive)
{
CodeCompletionChunks completionChunks({integerResultType,
functionName,
leftParen,
functionArgumentX,
optionalComma,
optionalFunctionArgumentY,
rightParen});
ASSERT_THAT(converter.convertToFunctionSignature(completionChunks, 2),
QStringLiteral("int Function(char x<i>, <b>int y</b></i>)"));
}
TEST_F(CompletionChunksToTextConverter, ConvertToFunctionSignatureWithTemplateReturnType)
{
CodeCompletionChunks completionChunks({templateResultType,
functionName,
leftParen,
functionArgumentX,
rightParen});
using ClangCodeModel::Internal::CompletionChunksToTextConverter;
ASSERT_THAT(CompletionChunksToTextConverter::convertToFunctionSignature(completionChunks),
QStringLiteral("Foo&lt;int&gt; Function(char x)"));
}
TEST_F(CompletionChunksToTextConverter, ConvertToFunctionSignatureWithTemplateArgument)
{
CodeCompletionChunks completionChunks({integerResultType,
functionName,
leftParen,
functionArgumentTemplate,
rightParen});
using ClangCodeModel::Internal::CompletionChunksToTextConverter;
ASSERT_THAT(CompletionChunksToTextConverter::convertToFunctionSignature(completionChunks),
QStringLiteral("int Function(const Foo&lt;int&gt; &amp;foo)"));
}
TEST_F(CompletionChunksToTextConverter, ConvertFunctionWithOptionalParameter)
{
CodeCompletionChunks completionChunks({integerResultType, functionName, leftParen, functionArgumentX, optional,rightParen});
CodeCompletionChunks completionChunks({integerResultType,
functionName,
leftParen,
functionArgumentX,
optionalComma,
optionalFunctionArgumentY,
optionalComma,
optionalFunctionArgumentZ,
rightParen});
ASSERT_THAT(Converter::convertToToolTip(completionChunks),
QStringLiteral("int Function (char x<i>, int y, int z</i>)"));
@@ -204,7 +310,7 @@ TEST_F(CompletionChunksToTextConverter, const_cast)
converter.parseChunks(completionChunks);
ASSERT_THAT(converter.text(), QStringLiteral("const_cast<>()"));
ASSERT_THAT(converter.text(), QStringLiteral("const_cast&lt;&gt;()"));
}
TEST_F(CompletionChunksToTextConverter, Throw)
@@ -239,13 +345,14 @@ TEST_F(CompletionChunksToTextConverter, EnableIfT)
CodeCompletionChunks completionChunks({enableIfT,
leftAngle,
enableIfTCondition,
CodeCompletionChunk(CodeCompletionChunk::Optional, Utf8String(), {comma, enableIfTType}),
optionalComma,
optionalEnableIfTType,
rightAngle});
setupConverterForKeywords();
converter.parseChunks(completionChunks);
ASSERT_THAT(converter.text(), QStringLiteral("enable_if_t<>"));
ASSERT_THAT(converter.text(), QStringLiteral("enable_if_t&lt;&gt;"));
}
void CompletionChunksToTextConverter::setupConverterForKeywords()

2
tests/unit/unittest/data/highlightinginformations.cpp
View File

@@ -162,7 +162,7 @@ struct StructInNameSpace {};
}
namespace NameSpaceAlias = NameSpace;
using NameSpace::StructInNameSpace;
NameSpace::StructInNameSpace foo6;
class BaseClass {

14
tests/unit/unittest/highlightinginformationstest.cpp
View File

@@ -462,6 +462,13 @@ TEST_F(HighlightingInformations, NameSpaceAlias)
ASSERT_THAT(infos[1], HasType(HighlightingType::Type));
}
TEST_F(HighlightingInformations, UsingStructInNameSpace)
{
const auto infos = translationUnit.highlightingInformationsInRange(sourceRange(165, 36));
ASSERT_THAT(infos[3], HasType(HighlightingType::Type));
}
TEST_F(HighlightingInformations, NameSpaceReference)
{
const auto infos = translationUnit.highlightingInformationsInRange(sourceRange(166, 35));
@@ -469,6 +476,13 @@ TEST_F(HighlightingInformations, NameSpaceReference)
ASSERT_THAT(infos[0], HasType(HighlightingType::Type));
}
TEST_F(HighlightingInformations, StructInNameSpaceReference)
{
const auto infos = translationUnit.highlightingInformationsInRange(sourceRange(166, 35));
ASSERT_THAT(infos[2], HasType(HighlightingType::Type));
}
TEST_F(HighlightingInformations, VirtualFunction)
{
const auto infos = translationUnit.highlightingInformationsInRange(sourceRange(170, 35));