QmlJS indenter: Move reusable code to qmljs lib.

Change-Id: I5ab50b586109a9736cda48245807571ce10dfb5b
Reviewed-by: Fawzi Mohamed <fawzi.mohamed@nokia.com>

src/libs/qmljs/qmljscodeformatter.cpp

@@ -989,3 +989,320 @@ void CodeFormatter::dump() const
     }
     qDebug() << "Current indent depth:" << m_indentDepth;
 }
+
+QtStyleCodeFormatter::QtStyleCodeFormatter()
+    : m_indentSize(4)
+{}
+
+void QtStyleCodeFormatter::setIndentSize(int size)
+{
+    m_indentSize = size;
+}
+
+void QtStyleCodeFormatter::onEnter(int newState, int *indentDepth, int *savedIndentDepth) const
+{
+    const State &parentState = state();
+    const Token &tk = currentToken();
+    const int tokenPosition = column(tk.begin());
+    const bool firstToken = (tokenIndex() == 0);
+    const bool lastToken = (tokenIndex() == tokenCount() - 1);
+
+    switch (newState) {
+    case objectdefinition_open: {
+        // special case for things like "gradient: Gradient {"
+        if (parentState.type == binding_assignment)
+            *savedIndentDepth = state(1).savedIndentDepth;
+
+        if (firstToken)
+            *savedIndentDepth = tokenPosition;
+
+        *indentDepth = *savedIndentDepth + m_indentSize;
+        break;
+    }
+
+    case binding_or_objectdefinition:
+        if (firstToken)
+            *indentDepth = *savedIndentDepth = tokenPosition;
+        break;
+
+    case binding_assignment:
+    case objectliteral_assignment:
+        if (lastToken)
+            *indentDepth = *savedIndentDepth + 4;
+        else
+            *indentDepth = column(tokenAt(tokenIndex() + 1).begin());
+        break;
+
+    case expression_or_objectdefinition:
+        *indentDepth = tokenPosition;
+        break;
+
+    case expression_or_label:
+        if (*indentDepth == tokenPosition)
+            *indentDepth += 2*m_indentSize;
+        else
+            *indentDepth = tokenPosition;
+        break;
+
+    case expression:
+        if (*indentDepth == tokenPosition) {
+            // expression_or_objectdefinition doesn't want the indent
+            // expression_or_label already has it
+            if (parentState.type != expression_or_objectdefinition
+                    && parentState.type != expression_or_label
+                    && parentState.type != binding_assignment) {
+                *indentDepth += 2*m_indentSize;
+            }
+        }
+        // expression_or_objectdefinition and expression_or_label have already consumed the first token
+        else if (parentState.type != expression_or_objectdefinition
+                 && parentState.type != expression_or_label) {
+            *indentDepth = tokenPosition;
+        }
+        break;
+
+    case expression_maybe_continuation:
+        // set indent depth to indent we'd get if the expression ended here
+        for (int i = 1; state(i).type != topmost_intro; ++i) {
+            const int type = state(i).type;
+            if (isExpressionEndState(type) && !isBracelessState(type)) {
+                *indentDepth = state(i - 1).savedIndentDepth;
+                break;
+            }
+        }
+        break;
+
+    case bracket_open:
+        if (parentState.type == expression && state(1).type == binding_assignment) {
+            *savedIndentDepth = state(2).savedIndentDepth;
+            *indentDepth = *savedIndentDepth + m_indentSize;
+        } else if (parentState.type == objectliteral_assignment) {
+            *savedIndentDepth = parentState.savedIndentDepth;
+            *indentDepth = *savedIndentDepth + m_indentSize;
+        } else if (!lastToken) {
+            *indentDepth = tokenPosition + 1;
+        } else {
+            *indentDepth = *savedIndentDepth + m_indentSize;
+        }
+        break;
+
+    case function_start:
+        if (parentState.type == expression) {
+            // undo the continuation indent of the expression
+            *indentDepth = parentState.savedIndentDepth;
+            *savedIndentDepth = *indentDepth;
+        }
+        break;
+
+    case do_statement_while_paren_open:
+    case statement_with_condition_paren_open:
+    case signal_arglist_open:
+    case function_arglist_open:
+    case paren_open:
+    case condition_paren_open:
+        if (!lastToken)
+            *indentDepth = tokenPosition + 1;
+        else
+            *indentDepth += m_indentSize;
+        break;
+
+    case ternary_op:
+        if (!lastToken)
+            *indentDepth = tokenPosition + tk.length + 1;
+        else
+            *indentDepth += m_indentSize;
+        break;
+
+    case jsblock_open:
+        // closing brace should be aligned to case
+        if (parentState.type == case_cont) {
+            *savedIndentDepth = parentState.savedIndentDepth;
+            break;
+        }
+        // fallthrough
+    case substatement_open:
+        // special case for "foo: {" and "property int foo: {"
+        if (parentState.type == binding_assignment)
+            *savedIndentDepth = state(1).savedIndentDepth;
+        *indentDepth = *savedIndentDepth + m_indentSize;
+        break;
+
+    case substatement:
+        *indentDepth += m_indentSize;
+        break;
+
+    case objectliteral_open:
+        if (parentState.type == expression
+                || parentState.type == objectliteral_assignment) {
+            // undo the continuation indent of the expression
+            if (state(1).type == expression_or_label)
+                *indentDepth = state(1).savedIndentDepth;
+            else
+                *indentDepth = parentState.savedIndentDepth;
+            *savedIndentDepth = *indentDepth;
+        }
+        *indentDepth += m_indentSize;
+        break;
+
+
+    case statement_with_condition:
+    case statement_with_block:
+    case if_statement:
+    case do_statement:
+    case switch_statement:
+        if (firstToken || parentState.type == binding_assignment)
+            *savedIndentDepth = tokenPosition;
+        // ### continuation
+        *indentDepth = *savedIndentDepth; // + 2*m_indentSize;
+        // special case for 'else if'
+        if (!firstToken
+                && newState == if_statement
+                && parentState.type == substatement
+                && state(1).type == else_clause) {
+            *indentDepth = state(1).savedIndentDepth;
+            *savedIndentDepth = *indentDepth;
+        }
+        break;
+
+    case maybe_else: {
+        // set indent to outermost braceless savedIndent
+        int outermostBraceless = 0;
+        while (isBracelessState(state(outermostBraceless + 1).type))
+            ++outermostBraceless;
+        *indentDepth = state(outermostBraceless).savedIndentDepth;
+        // this is where the else should go, if one appears - aligned to if_statement
+        *savedIndentDepth = state().savedIndentDepth;
+        break;
+    }
+
+    case condition_open:
+        // fixed extra indent when continuing 'if (', but not for 'else if ('
+        if (tokenPosition <= *indentDepth + m_indentSize)
+            *indentDepth += 2*m_indentSize;
+        else
+            *indentDepth = tokenPosition + 1;
+        break;
+
+    case case_start:
+        *savedIndentDepth = tokenPosition;
+        break;
+
+    case case_cont:
+        *indentDepth += m_indentSize;
+        break;
+
+    case multiline_comment_start:
+        *indentDepth = tokenPosition + 2;
+        break;
+
+    case multiline_comment_cont:
+        *indentDepth = tokenPosition;
+        break;
+    }
+}
+
+void QtStyleCodeFormatter::adjustIndent(const QList<Token> &tokens, int lexerState, int *indentDepth) const
+{
+    Q_UNUSED(lexerState)
+
+    State topState = state();
+    State previousState = state(1);
+
+    // keep user-adjusted indent in multiline comments
+    if (topState.type == multiline_comment_start
+            || topState.type == multiline_comment_cont) {
+        if (!tokens.isEmpty()) {
+            *indentDepth = column(tokens.at(0).begin());
+            return;
+        }
+    }
+
+    const int kind = extendedTokenKind(tokenAt(0));
+    switch (kind) {
+    case LeftBrace:
+        if (topState.type == substatement
+                || topState.type == binding_assignment
+                || topState.type == case_cont) {
+            *indentDepth = topState.savedIndentDepth;
+        }
+        break;
+    case RightBrace: {
+        if (topState.type == jsblock_open && previousState.type == case_cont) {
+            *indentDepth = previousState.savedIndentDepth;
+            break;
+        }
+        for (int i = 0; state(i).type != topmost_intro; ++i) {
+            const int type = state(i).type;
+            if (type == objectdefinition_open
+                    || type == jsblock_open
+                    || type == substatement_open
+                    || type == objectliteral_open) {
+                *indentDepth = state(i).savedIndentDepth;
+                break;
+            }
+        }
+        break;
+    }
+    case RightBracket:
+        for (int i = 0; state(i).type != topmost_intro; ++i) {
+            const int type = state(i).type;
+            if (type == bracket_open) {
+                *indentDepth = state(i).savedIndentDepth;
+                break;
+            }
+        }
+        break;
+
+    case LeftBracket:
+    case LeftParenthesis:
+    case Delimiter:
+        if (topState.type == expression_maybe_continuation)
+            *indentDepth = topState.savedIndentDepth;
+        break;
+
+    case Else:
+        if (topState.type == maybe_else) {
+            *indentDepth = topState.savedIndentDepth;
+        } else if (topState.type == expression_maybe_continuation) {
+            bool hasElse = false;
+            for (int i = 1; state(i).type != topmost_intro; ++i) {
+                const int type = state(i).type;
+                if (type == else_clause)
+                    hasElse = true;
+                if (type == if_statement) {
+                    if (hasElse) {
+                        hasElse = false;
+                    } else {
+                        *indentDepth = state(i).savedIndentDepth;
+                        break;
+                    }
+                }
+            }
+        }
+        break;
+
+    case Colon:
+        if (topState.type == ternary_op) {
+            *indentDepth -= 2;
+        }
+        break;
+
+    case Question:
+        if (topState.type == expression_maybe_continuation)
+            *indentDepth = topState.savedIndentDepth;
+        break;
+
+    case Default:
+    case Case:
+        for (int i = 0; state(i).type != topmost_intro; ++i) {
+            const int type = state(i).type;
+            if (type == switch_statement || type == case_cont) {
+                *indentDepth = state(i).savedIndentDepth;
+                break;
+            } else if (type == topmost_intro) {
+                break;
+            }
+        }
+        break;
+    }
+}

src/libs/qmljs/qmljscodeformatter.h

@@ -315,6 +315,21 @@ private:
     int m_tabSize;
 };
 
+class QMLJS_EXPORT QtStyleCodeFormatter : public CodeFormatter
+{
+public:
+    QtStyleCodeFormatter();
+
+    void setIndentSize(int size);
+
+protected:
+    virtual void onEnter(int newState, int *indentDepth, int *savedIndentDepth) const;
+    virtual void adjustIndent(const QList<QmlJS::Token> &tokens, int lexerState, int *indentDepth) const;
+
+private:
+    int m_indentSize;
+};
+
 } // namespace QmlJS
 
 #endif // QMLJSCODEFORMATTER_H

src/plugins/qmljseditor/qmljseditor.cpp

@@ -1486,7 +1486,7 @@ void QmlJSTextEditorWidget::unCommentSelection()
 
 void QmlJSTextEditorWidget::setTabSettings(const TextEditor::TabSettings &ts)
 {
-    QmlJSTools::QtStyleCodeFormatter formatter(ts);
+    QmlJSTools::CreatorCodeFormatter formatter(ts);
     formatter.invalidateCache(document());
 
     TextEditor::BaseTextEditorWidget::setTabSettings(ts);

src/plugins/qmljstools/qmljscodestylesettingspage.cpp

@@ -148,7 +148,7 @@ void QmlJSCodeStylePreferencesWidget::updatePreview()
             ? m_preferences->currentTabSettings()
             : TextEditorSettings::instance()->codeStyle()->tabSettings();
     m_ui->previewTextEdit->setTabSettings(ts);
-    QtStyleCodeFormatter formatter(ts);
+    CreatorCodeFormatter formatter(ts);
     formatter.invalidateCache(doc);
 
     QTextBlock block = doc->firstBlock();

src/plugins/qmljstools/qmljsindenter.cpp

@@ -66,7 +66,7 @@ void Indenter::indentBlock(QTextDocument *doc,
 {
     Q_UNUSED(doc)
 
-    QmlJSTools::QtStyleCodeFormatter codeFormatter(tabSettings);
+    QmlJSTools::CreatorCodeFormatter codeFormatter(tabSettings);
 
     codeFormatter.updateStateUntil(block);
     const int depth = codeFormatter.indentFor(block);
@@ -84,6 +84,6 @@ void Indenter::indentBlock(QTextDocument *doc,
 
 void Indenter::invalidateCache(QTextDocument *doc)
 {
-    QmlJSTools::QtStyleCodeFormatter codeFormatter;
+    QmlJSTools::CreatorCodeFormatter codeFormatter;
     codeFormatter.invalidateCache(doc);
 }

src/plugins/qmljstools/qmljsqtstylecodeformatter.cpp

@@ -40,23 +40,17 @@ using namespace QmlJS;
 using namespace QmlJSTools;
 using namespace TextEditor;
 
-QtStyleCodeFormatter::QtStyleCodeFormatter()
+CreatorCodeFormatter::CreatorCodeFormatter()
-    : m_indentSize(4)
 {
 }
 
-QtStyleCodeFormatter::QtStyleCodeFormatter(const TextEditor::TabSettings &tabSettings)
+CreatorCodeFormatter::CreatorCodeFormatter(const TextEditor::TabSettings &tabSettings)
-    : m_indentSize(tabSettings.m_indentSize)
 {
     setTabSize(tabSettings.m_tabSize);
+    setIndentSize(tabSettings.m_indentSize);
 }
 
-void QtStyleCodeFormatter::setIndentSize(int size)
+void CreatorCodeFormatter::saveBlockData(QTextBlock *block, const BlockData &data) const
-{
-    m_indentSize = size;
-}
-
-void QtStyleCodeFormatter::saveBlockData(QTextBlock *block, const BlockData &data) const
 {
     TextBlockUserData *userData = BaseTextDocumentLayout::userData(*block);
     QmlJSCodeFormatterData *cppData = static_cast<QmlJSCodeFormatterData *>(userData->codeFormatterData());
@@ -67,7 +61,7 @@ void QtStyleCodeFormatter::saveBlockData(QTextBlock *block, const BlockData &dat
     cppData->m_data = data;
 }
 
-bool QtStyleCodeFormatter::loadBlockData(const QTextBlock &block, BlockData *data) const
+bool CreatorCodeFormatter::loadBlockData(const QTextBlock &block, BlockData *data) const
 {
     TextBlockUserData *userData = BaseTextDocumentLayout::testUserData(block);
     if (!userData)
@@ -80,320 +74,12 @@ bool QtStyleCodeFormatter::loadBlockData(const QTextBlock &block, BlockData *dat
     return true;
 }
 
-void QtStyleCodeFormatter::saveLexerState(QTextBlock *block, int state) const
+void CreatorCodeFormatter::saveLexerState(QTextBlock *block, int state) const
 {
     BaseTextDocumentLayout::setLexerState(*block, state);
 }
 
-int QtStyleCodeFormatter::loadLexerState(const QTextBlock &block) const
+int CreatorCodeFormatter::loadLexerState(const QTextBlock &block) const
 {
     return BaseTextDocumentLayout::lexerState(block);
 }
-
-void QtStyleCodeFormatter::onEnter(int newState, int *indentDepth, int *savedIndentDepth) const
-{
-    const State &parentState = state();
-    const Token &tk = currentToken();
-    const int tokenPosition = column(tk.begin());
-    const bool firstToken = (tokenIndex() == 0);
-    const bool lastToken = (tokenIndex() == tokenCount() - 1);
-
-    switch (newState) {
-    case objectdefinition_open: {
-        // special case for things like "gradient: Gradient {"
-        if (parentState.type == binding_assignment)
-            *savedIndentDepth = state(1).savedIndentDepth;
-
-        if (firstToken)
-            *savedIndentDepth = tokenPosition;
-
-        *indentDepth = *savedIndentDepth + m_indentSize;
-        break;
-    }
-
-    case binding_or_objectdefinition:
-        if (firstToken)
-            *indentDepth = *savedIndentDepth = tokenPosition;
-        break;
-
-    case binding_assignment:
-    case objectliteral_assignment:
-        if (lastToken)
-            *indentDepth = *savedIndentDepth + 4;
-        else
-            *indentDepth = column(tokenAt(tokenIndex() + 1).begin());
-        break;
-
-    case expression_or_objectdefinition:
-        *indentDepth = tokenPosition;
-        break;
-
-    case expression_or_label:
-        if (*indentDepth == tokenPosition)
-            *indentDepth += 2*m_indentSize;
-        else
-            *indentDepth = tokenPosition;
-        break;
-
-    case expression:
-        if (*indentDepth == tokenPosition) {
-            // expression_or_objectdefinition doesn't want the indent
-            // expression_or_label already has it
-            if (parentState.type != expression_or_objectdefinition
-                    && parentState.type != expression_or_label
-                    && parentState.type != binding_assignment) {
-                *indentDepth += 2*m_indentSize;
-            }
-        }
-        // expression_or_objectdefinition and expression_or_label have already consumed the first token
-        else if (parentState.type != expression_or_objectdefinition
-                 && parentState.type != expression_or_label) {
-            *indentDepth = tokenPosition;
-        }
-        break;
-
-    case expression_maybe_continuation:
-        // set indent depth to indent we'd get if the expression ended here
-        for (int i = 1; state(i).type != topmost_intro; ++i) {
-            const int type = state(i).type;
-            if (isExpressionEndState(type) && !isBracelessState(type)) {
-                *indentDepth = state(i - 1).savedIndentDepth;
-                break;
-            }
-        }
-        break;
-
-    case bracket_open:
-        if (parentState.type == expression && state(1).type == binding_assignment) {
-            *savedIndentDepth = state(2).savedIndentDepth;
-            *indentDepth = *savedIndentDepth + m_indentSize;
-        } else if (parentState.type == objectliteral_assignment) {
-            *savedIndentDepth = parentState.savedIndentDepth;
-            *indentDepth = *savedIndentDepth + m_indentSize;
-        } else if (!lastToken) {
-            *indentDepth = tokenPosition + 1;
-        } else {
-            *indentDepth = *savedIndentDepth + m_indentSize;
-        }
-        break;
-
-    case function_start:
-        if (parentState.type == expression) {
-            // undo the continuation indent of the expression
-            *indentDepth = parentState.savedIndentDepth;
-            *savedIndentDepth = *indentDepth;
-        }
-        break;
-
-    case do_statement_while_paren_open:
-    case statement_with_condition_paren_open:
-    case signal_arglist_open:
-    case function_arglist_open:
-    case paren_open:
-    case condition_paren_open:
-        if (!lastToken)
-            *indentDepth = tokenPosition + 1;
-        else
-            *indentDepth += m_indentSize;
-        break;
-
-    case ternary_op:
-        if (!lastToken)
-            *indentDepth = tokenPosition + tk.length + 1;
-        else
-            *indentDepth += m_indentSize;
-        break;
-
-    case jsblock_open:
-        // closing brace should be aligned to case
-        if (parentState.type == case_cont) {
-            *savedIndentDepth = parentState.savedIndentDepth;
-            break;
-        }
-        // fallthrough
-    case substatement_open:
-        // special case for "foo: {" and "property int foo: {"
-        if (parentState.type == binding_assignment)
-            *savedIndentDepth = state(1).savedIndentDepth;
-        *indentDepth = *savedIndentDepth + m_indentSize;
-        break;
-
-    case substatement:
-        *indentDepth += m_indentSize;
-        break;
-
-    case objectliteral_open:
-        if (parentState.type == expression
-                || parentState.type == objectliteral_assignment) {
-            // undo the continuation indent of the expression
-            if (state(1).type == expression_or_label)
-                *indentDepth = state(1).savedIndentDepth;
-            else
-                *indentDepth = parentState.savedIndentDepth;
-            *savedIndentDepth = *indentDepth;
-        }
-        *indentDepth += m_indentSize;
-        break;
-
-
-    case statement_with_condition:
-    case statement_with_block:
-    case if_statement:
-    case do_statement:
-    case switch_statement:
-        if (firstToken || parentState.type == binding_assignment)
-            *savedIndentDepth = tokenPosition;
-        // ### continuation
-        *indentDepth = *savedIndentDepth; // + 2*m_indentSize;
-        // special case for 'else if'
-        if (!firstToken
-                && newState == if_statement
-                && parentState.type == substatement
-                && state(1).type == else_clause) {
-            *indentDepth = state(1).savedIndentDepth;
-            *savedIndentDepth = *indentDepth;
-        }
-        break;
-
-    case maybe_else: {
-        // set indent to outermost braceless savedIndent
-        int outermostBraceless = 0;
-        while (isBracelessState(state(outermostBraceless + 1).type))
-            ++outermostBraceless;
-        *indentDepth = state(outermostBraceless).savedIndentDepth;
-        // this is where the else should go, if one appears - aligned to if_statement
-        *savedIndentDepth = state().savedIndentDepth;
-        break;
-    }
-
-    case condition_open:
-        // fixed extra indent when continuing 'if (', but not for 'else if ('
-        if (tokenPosition <= *indentDepth + m_indentSize)
-            *indentDepth += 2*m_indentSize;
-        else
-            *indentDepth = tokenPosition + 1;
-        break;
-
-    case case_start:
-        *savedIndentDepth = tokenPosition;
-        break;
-
-    case case_cont:
-        *indentDepth += m_indentSize;
-        break;
-
-    case multiline_comment_start:
-        *indentDepth = tokenPosition + 2;
-        break;
-
-    case multiline_comment_cont:
-        *indentDepth = tokenPosition;
-        break;
-    }
-}
-
-void QtStyleCodeFormatter::adjustIndent(const QList<Token> &tokens, int lexerState, int *indentDepth) const
-{
-    Q_UNUSED(lexerState)
-
-    State topState = state();
-    State previousState = state(1);
-
-    // keep user-adjusted indent in multiline comments
-    if (topState.type == multiline_comment_start
-            || topState.type == multiline_comment_cont) {
-        if (!tokens.isEmpty()) {
-            *indentDepth = column(tokens.at(0).begin());
-            return;
-        }
-    }
-
-    const int kind = extendedTokenKind(tokenAt(0));
-    switch (kind) {
-    case LeftBrace:
-        if (topState.type == substatement
-                || topState.type == binding_assignment
-                || topState.type == case_cont) {
-            *indentDepth = topState.savedIndentDepth;
-        }
-        break;
-    case RightBrace: {
-        if (topState.type == jsblock_open && previousState.type == case_cont) {
-            *indentDepth = previousState.savedIndentDepth;
-            break;
-        }
-        for (int i = 0; state(i).type != topmost_intro; ++i) {
-            const int type = state(i).type;
-            if (type == objectdefinition_open
-                    || type == jsblock_open
-                    || type == substatement_open
-                    || type == objectliteral_open) {
-                *indentDepth = state(i).savedIndentDepth;
-                break;
-            }
-        }
-        break;
-    }
-    case RightBracket:
-        for (int i = 0; state(i).type != topmost_intro; ++i) {
-            const int type = state(i).type;
-            if (type == bracket_open) {
-                *indentDepth = state(i).savedIndentDepth;
-                break;
-            }
-        }
-        break;
-
-    case LeftBracket:
-    case LeftParenthesis:
-    case Delimiter:
-        if (topState.type == expression_maybe_continuation)
-            *indentDepth = topState.savedIndentDepth;
-        break;
-
-    case Else:
-        if (topState.type == maybe_else) {
-            *indentDepth = topState.savedIndentDepth;
-        } else if (topState.type == expression_maybe_continuation) {
-            bool hasElse = false;
-            for (int i = 1; state(i).type != topmost_intro; ++i) {
-                const int type = state(i).type;
-                if (type == else_clause)
-                    hasElse = true;
-                if (type == if_statement) {
-                    if (hasElse) {
-                        hasElse = false;
-                    } else {
-                        *indentDepth = state(i).savedIndentDepth;
-                        break;
-                    }
-                }
-            }
-        }
-        break;
-
-    case Colon:
-        if (topState.type == ternary_op) {
-            *indentDepth -= 2;
-        }
-        break;
-
-    case Question:
-        if (topState.type == expression_maybe_continuation)
-            *indentDepth = topState.savedIndentDepth;
-        break;
-
-    case Default:
-    case Case:
-        for (int i = 0; state(i).type != topmost_intro; ++i) {
-            const int type = state(i).type;
-            if (type == switch_statement || type == case_cont) {
-                *indentDepth = state(i).savedIndentDepth;
-                break;
-            } else if (type == topmost_intro) {
-                break;
-            }
-        }
-        break;
-    }
-}

src/plugins/qmljstools/qmljsqtstylecodeformatter.h

@@ -44,18 +44,13 @@ namespace TextEditor {
 
 namespace QmlJSTools {
 
-class QMLJSTOOLS_EXPORT QtStyleCodeFormatter : public QmlJS::CodeFormatter
+class QMLJSTOOLS_EXPORT CreatorCodeFormatter : public QmlJS::QtStyleCodeFormatter
 {
 public:
-    QtStyleCodeFormatter();
+    CreatorCodeFormatter();
-    explicit QtStyleCodeFormatter(const TextEditor::TabSettings &tabSettings);
+    explicit CreatorCodeFormatter(const TextEditor::TabSettings &tabSettings);
-
-    void setIndentSize(int size);
 
 protected:
-    virtual void onEnter(int newState, int *indentDepth, int *savedIndentDepth) const;
-    virtual void adjustIndent(const QList<QmlJS::Token> &tokens, int lexerState, int *indentDepth) const;
-
     virtual void saveBlockData(QTextBlock *block, const BlockData &data) const;
     virtual bool loadBlockData(const QTextBlock &block, BlockData *data) const;
 
@@ -63,8 +58,6 @@ protected:
     virtual int loadLexerState(const QTextBlock &block) const;
 
 private:
-    int m_indentSize;
-
     class QmlJSCodeFormatterData: public TextEditor::CodeFormatterData
     {
     public:

src/plugins/qmljstools/qmljsrefactoringchanges.cpp

@@ -65,7 +65,7 @@ public:
 
         const TextEditor::TabSettings &tabSettings =
             ProjectExplorer::actualTabSettings(fileName, textEditor);
-        QtStyleCodeFormatter codeFormatter(tabSettings);
+        CreatorCodeFormatter codeFormatter(tabSettings);
         codeFormatter.updateStateUntil(block);
 
         do {

tests/auto/qml/qmleditor/qmlcodeformatter/tst_qmlcodeformatter.cpp

@@ -135,7 +135,7 @@ void checkIndent(QList<Line> data, int style = 0)
 
     QString text = concatLines(data);
     QTextDocument document(text);
-    QtStyleCodeFormatter formatter;
+    CreatorCodeFormatter formatter;
 
     int i = 0;
     foreach (const Line &l, data) {