[rpms/kdevelop-python] f44: Support Python 3.9

[Jan Grulich <jgrulich@redhat.com>]

A new commit has been pushed.

Repo   : rpms/kdevelop-python
Branch : f44
Commit : ca94903e7ae1bcf493bbbc1b1ebffccd45c98540
Author : Jan Grulich <jgrulich@redhat.com>
Date   : 2020-08-24T13:48:53+02:00
Stats  : +497/-5 in 2 file(s)
URL    : https://src.fedoraproject.org/rpms/kdevelop-python/c/ca94903e7ae1bcf493bbbc1b1ebffccd45c98540?branch=f44

Log:
Support Python 3.9

---
diff --git a/kdevelop-python-39.patch b/kdevelop-python-39.patch
new file mode 100644
index 0000000..fe1ab5a
--- /dev/null
+++ b/kdevelop-python-39.patch
@@ -0,0 +1,487 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index af025cd3..9d851659 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -31,7 +31,7 @@ add_definitions( -DTRANSLATION_DOMAIN=\"kdevpython\" )
+ 
+ # CMake looks for exactly the specified version first and ignores newer versions.
+ # To avoid that, start looking for the newest supported version and work down.
+-set(Python_ADDITIONAL_VERSIONS 3.8 3.7 3.6 3.5 3.4)
++set(Python_ADDITIONAL_VERSIONS 3.9 3.8 3.7 3.6 3.5 3.4)
+ foreach(_PYTHON_V ${Python_ADDITIONAL_VERSIONS})
+     find_package(PythonInterp ${_PYTHON_V})
+     if ( PYTHONINTERP_FOUND )
+@@ -49,7 +49,7 @@ if ( PYTHONINTERP_FOUND AND PYTHON_VERSION_STRING VERSION_GREATER "3.4" )
+ endif()
+ 
+ if ( NOT PYTHONLIBS_FOUND OR PYTHONLIBS_VERSION_STRING VERSION_LESS "3.4.3" )
+-    message(FATAL_ERROR "Python >= 3.4.3 but < 3.9 with --enable-shared is required to build kdev-python")
++    message(FATAL_ERROR "Python >= 3.4.3 but < 3.10 with --enable-shared is required to build kdev-python")
+ endif()
+ 
+ configure_file(kdevpythonversion.h.cmake "${CMAKE_CURRENT_BINARY_DIR}/kdevpythonversion.h" @ONLY)
+diff --git a/duchain/declarationbuilder.cpp b/duchain/declarationbuilder.cpp
+index 61e144c5..b588226a 100644
+--- a/duchain/declarationbuilder.cpp
++++ b/duchain/declarationbuilder.cpp
+@@ -1139,9 +1139,9 @@ void DeclarationBuilder::assignToSubscript(SubscriptAst* subscript, const Declar
+     }
+     auto map = MapType::Ptr::dynamicCast(list);
+     if ( map ) {
+-        if ( subscript->slice && subscript->slice->astType == Ast::IndexAstType ) {
++        if ( subscript->slice && subscript->slice->astType != Ast::SliceAstType) {
+             ExpressionVisitor keyVisitor(currentContext());
+-            keyVisitor.visitNode(static_cast<IndexAst*>(subscript->slice)->value);
++            keyVisitor.visitNode(subscript->slice);
+             AbstractType::Ptr key = keyVisitor.lastType();
+             if ( key ) {
+                 map->addKeyType<Python::UnsureType>(key);
+diff --git a/duchain/expressionvisitor.cpp b/duchain/expressionvisitor.cpp
+index 055c5b49..3185ea80 100644
+--- a/duchain/expressionvisitor.cpp
++++ b/duchain/expressionvisitor.cpp
+@@ -365,7 +365,7 @@ void ExpressionVisitor::visitSubscript(SubscriptAst* node)
+                 continue;
+             }
+         }
+-        if ( (node->slice->astType != Ast::IndexAstType) && type.cast<ListType>() ) {
++        if ( (node->slice->astType == Ast::SliceAstType) && type.cast<ListType>() ) {
+             if ( type.cast<MapType>() ) {
+                 continue; // Can't slice dicts.
+             }
+@@ -373,7 +373,7 @@ void ExpressionVisitor::visitSubscript(SubscriptAst* node)
+             result = Helper::mergeTypes(result, type);
+         }
+         else if ( const auto& indexed = type.cast<IndexedContainer>() ) {
+-            long sliceIndex = integerValue(static_cast<IndexAst*>(node->slice)->value, indexed->typesCount());
++            long sliceIndex = integerValue(node->slice, indexed->typesCount());
+             if ( 0 <= sliceIndex && sliceIndex < indexed->typesCount() ) {
+                 result = Helper::mergeTypes(result, indexed->typeAt(sliceIndex).abstractType());
+                 continue;
+diff --git a/duchain/tests/pyduchaintest.cpp b/duchain/tests/pyduchaintest.cpp
+index 17ba34e5..04d9164d 100644
+--- a/duchain/tests/pyduchaintest.cpp
++++ b/duchain/tests/pyduchaintest.cpp
+@@ -438,15 +438,15 @@ void PyDUChainTest::testCrashes_data() {
+         "      \"\"\"! returnContentEqualsContentOf ! -3\"\"\"\n"
+         "e = Evil()\n"
+         "z = [e.aa(1), e.bb(2), e.cc(3)]";
++    QTest::newRow("comprehension_in_lambda") << "lambda foo: [bar for bar in foo]";
+ #if PYTHON_VERSION >= QT_VERSION_CHECK(3, 6, 0)
+     QTest::newRow("comprehension_in_fstring") <<
+         "def crash(): return f'expr={ {x: y for x, y in [(1, 2), ]}}'";
+-#endif
+-    QTest::newRow("comprehension_in_lambda") << "lambda foo: [bar for bar in foo]";
+     QTest::newRow("comprehension_in_annassign_1") << "foo: int = [x for x in (42,)][0]";
+     QTest::newRow("comprehension_in_annassign_2") << "foo: [t for t in (int,)][0] = 42";
+     QTest::newRow("lambda_in_annassign_1") << "foo: int = (lambda: 42)()";
+     QTest::newRow("lambda_in_annassign_2") << "foo: (lambda: int)() = 42";
++#endif
+     QTest::newRow("definition_in_baseclass_1") << "class Foo(lambda x: 1): pass";
+     QTest::newRow("definition_in_baseclass_2") << "class Foo([x for x in (1, 2)]): pass";
+ }
+@@ -954,10 +954,12 @@ void PyDUChainTest::testTypes_data()
+ //     QTest::newRow("class_method_self") << "class c:\n def func(checkme, arg, arg2):\n  pass\n" << "c";
+ //    QTest::newRow("funccall_dict") << "def foo(): return foo; checkme = foo();" << (uint) IntegralType::TypeFunction;
+ 
++#if PYTHON_VERSION >= QT_VERSION_CHECK(3, 6, 0)
+     // With only one subbed value we get a FormattedValue node
+     QTest::newRow("fstring_formattedvalue") << "name = 'Jim'; checkme = f'{name}'" << "str";
+     // Otherwise a JoinedString, with FormattedValues as children.
+     QTest::newRow("fstring_joinedstring") << "name = 'Jim'; checkme = f'Hello, {name}! Your name is {name}.'" << "str";
++#endif
+ 
+     QTest::newRow("tuple_simple") << "mytuple = 3, 5.5\ncheckme, foobar = mytuple" << "int";
+     QTest::newRow("tuple_simple2") << "mytuple = 3, 5.5\nfoobar, checkme = mytuple" << "float";
+@@ -1317,6 +1319,7 @@ void PyDUChainTest::testTypes_data()
+     "def foo(a, b, /, c, d):\n"
+     "    return a, b, c, d\n"
+     "checkme = foo(10, 'x', 2.3, d='y')\n" << "tuple of (int, str, float, str)";
++    QTest::newRow("fstring_self_documenting") << "checkme = f'{expr=}'" << "str";
+ #endif
+ }
+ 
+@@ -1389,7 +1392,9 @@ void PyDUChainTest::testProblemCount_data()
+     QTest::newRow("correct_return") << "def foo():\n return" << 0;
+     QTest::newRow("lambda_argument_outside") << "def bar():\n lambda foo: 3\n foo" << 1;
+     QTest::newRow("use_found_at_decl") << "foo = 3" << 0;
++#if PYTHON_VERSION >= QT_VERSION_CHECK(3, 6, 0)
+     QTest::newRow("fstring_visit_inside") << "checkme = f'{name}'" << 1;
++#endif
+ }
+ 
+ void PyDUChainTest::testImportDeclarations_data() {
+diff --git a/kdevpythonversion.h.cmake b/kdevpythonversion.h.cmake
+index 48df127b..ab789ebb 100644
+--- a/kdevpythonversion.h.cmake
++++ b/kdevpythonversion.h.cmake
+@@ -20,9 +20,15 @@
+ #ifndef KDEVPYTHON_VERSION_H
+ #define KDEVPYTHON_VERSION_H
+ 
++#define PYTHON_VERSION_MINOR @PYTHON_VERSION_MINOR@
++#define PYTHON_VERSION_MINOR_STR "@PYTHON_VERSION_MINOR@"
++
++#define PYTHON_VERSION_MAJOR @PYTHON_VERSION_MAJOR@
+ #define PYTHON_VERSION_MAJOR_STR "@PYTHON_VERSION_MAJOR@"
++
+ #define PYTHON_VERSION QT_VERSION_CHECK(@PYTHON_VERSION_MAJOR@, @PYTHON_VERSION_MINOR@, @PYTHON_VERSION_PATCH@)
+ #define PYTHON_VERSION_STR "@PYTHON_VERSION_MAJOR@.@PYTHON_VERSION_MINOR@"
++
+ #define PYTHON_EXECUTABLE "@PYTHON_EXECUTABLE@"
+ 
+ #endif
+diff --git a/parser/ast.cpp b/parser/ast.cpp
+index cd570d36..dee9365d 100644
+--- a/parser/ast.cpp
++++ b/parser/ast.cpp
+@@ -128,12 +128,7 @@ DictAst::DictAst(Ast* parent): ExpressionAst(parent, Ast::DictAstType)
+ 
+ }
+ 
+-IndexAst::IndexAst(Ast* parent): SliceAstBase(parent, Ast::IndexAstType), value(nullptr)
+-{
+-
+-}
+-
+-SliceAst::SliceAst(Ast* parent): SliceAstBase(parent, Ast::SliceAstType), lower(nullptr), upper(nullptr), step(nullptr)
++SliceAst::SliceAst(Ast* parent): ExpressionAst(parent, Ast::SliceAstType), lower(nullptr), upper(nullptr), step(nullptr)
+ {
+ 
+ }
+@@ -143,7 +138,7 @@ DictionaryComprehensionAst::DictionaryComprehensionAst(Ast* parent): ExpressionA
+     
+ }
+ 
+-EllipsisAst::EllipsisAst(Ast* parent): SliceAstBase(parent, Ast::EllipsisAstType)
++EllipsisAst::EllipsisAst(Ast* parent): ExpressionAst(parent, Ast::EllipsisAstType)
+ {
+     
+ }
+@@ -173,11 +168,6 @@ YieldFromAst::YieldFromAst(Ast* parent) : ExpressionAst(parent, Ast::YieldFromAs
+ 
+ }
+ 
+-ExtendedSliceAst::ExtendedSliceAst(Ast* parent): SliceAstBase(parent, Ast::ExtendedSliceAstType)
+-{
+-    
+-}
+-
+ ForAst::ForAst(Ast* parent): StatementAst(parent, Ast::ForAstType), target(nullptr), iterator(nullptr)
+ {
+     
+@@ -288,11 +278,6 @@ SetComprehensionAst::SetComprehensionAst(Ast* parent): ExpressionAst(parent, Ast
+     
+ }
+ 
+-SliceAstBase::SliceAstBase(Ast* parent, AstType type): Ast(parent, type)
+-{
+-    
+-}
+-
+ StatementAst::StatementAst(Ast* parent, AstType type): Ast(parent, type)
+ {
+     
+diff --git a/parser/ast.h b/parser/ast.h
+index 65fef1cd..e459a780 100644
+--- a/parser/ast.h
++++ b/parser/ast.h
+@@ -55,7 +55,6 @@ namespace Python {
+     class ExceptionHandlerAst;
+     class AliasAst;
+     class ComprehensionAst;
+-    class SliceAstBase;
+     class SliceAst;
+ }
+ 
+@@ -102,7 +101,6 @@ public:
+         NameConstantAstType,
+         CallAstType,
+         AttributeAstType,
+-        ExtendedSliceAstType,
+         DictionaryComprehensionAstType,
+         BooleanOperationAstType,
+         BinaryOperationAstType,
+@@ -127,10 +125,8 @@ public:
+         TupleAstType,
+         YieldFromAstType,
+         ComprehensionAstType,
+-
+         SliceAstType,
+         EllipsisAstType,
+-        IndexAstType,
+         AssignmentExpressionAstType,
+         LastExpressionType, // keep this at the end of the expr ast list
+ 
+@@ -681,7 +677,7 @@ class KDEVPYTHONPARSER_EXPORT SubscriptAst : public ExpressionAst {
+ public:
+     SubscriptAst(Ast* parent);
+     ExpressionAst* value;
+-    SliceAstBase* slice;
++    ExpressionAst* slice;
+     ExpressionAst::Context context;
+ };
+ 
+@@ -706,18 +702,12 @@ public:
+     ExpressionAst::Context context;
+ };
+ 
+-/** Slice classes **/
+-class KDEVPYTHONPARSER_EXPORT SliceAstBase : public Ast {
+-public:
+-    SliceAstBase(Ast* parent, AstType type);
+-};
+-
+-class KDEVPYTHONPARSER_EXPORT EllipsisAst : public SliceAstBase {
++class KDEVPYTHONPARSER_EXPORT EllipsisAst : public ExpressionAst {
+ public:
+     EllipsisAst(Ast* parent);
+ };
+ 
+-class KDEVPYTHONPARSER_EXPORT SliceAst : public SliceAstBase {
++class KDEVPYTHONPARSER_EXPORT SliceAst : public ExpressionAst {
+ public:
+     SliceAst(Ast* parent);
+     ExpressionAst* lower;
+@@ -725,17 +715,6 @@ public:
+     ExpressionAst* step;
+ };
+ 
+-class KDEVPYTHONPARSER_EXPORT ExtendedSliceAst : public SliceAstBase {
+-public:
+-    ExtendedSliceAst(Ast* parent);
+-    QList<SliceAst*> dims;
+-};
+-
+-class KDEVPYTHONPARSER_EXPORT IndexAst : public SliceAstBase {
+-public:
+-    IndexAst(Ast* parent);
+-    ExpressionAst* value;
+-};
+ 
+ /** Independent classes **/
+ 
+diff --git a/parser/astbuilder.cpp b/parser/astbuilder.cpp
+index ad2e0dce..76e652ca 100644
+--- a/parser/astbuilder.cpp
++++ b/parser/astbuilder.cpp
+@@ -104,7 +104,7 @@ CodeAst::Ptr AstBuilder::parse(const QUrl& filename, QString &contents)
+ #if PYTHON_VERSION >= QT_VERSION_CHECK(3, 8, 0)
+     PyCompilerFlags flags;
+     flags.cf_flags = PyCF_SOURCE_IS_UTF8 | PyCF_IGNORE_COOKIE | PyCF_ONLY_AST;
+-    flags.cf_feature_version = 7;
++    flags.cf_feature_version = PYTHON_VERSION_MINOR;
+ #else
+     PyCompilerFlags flags = {PyCF_SOURCE_IS_UTF8 | PyCF_IGNORE_COOKIE};
+ #endif
+diff --git a/parser/astdefaultvisitor.cpp b/parser/astdefaultvisitor.cpp
+index cdd31bbf..bf79ff52 100644
+--- a/parser/astdefaultvisitor.cpp
++++ b/parser/astdefaultvisitor.cpp
+@@ -113,11 +113,6 @@ void AstDefaultVisitor::visitDelete(DeleteAst* node)
+     visitNodeList(node->targets);
+ }
+ 
+-void AstDefaultVisitor::visitExtendedSlice(ExtendedSliceAst* node)
+-{
+-    visitNodeList(node->dims);
+-}
+-
+ void AstDefaultVisitor::visitFor(ForAst* node)
+ {
+     visitNode(node->target);
+@@ -157,11 +152,6 @@ void AstDefaultVisitor::visitImportFrom(ImportFromAst* node)
+     visitIdentifier(node->module);
+ }
+ 
+-void AstDefaultVisitor::visitIndex(IndexAst* node)
+-{
+-    visitNode(node->value);
+-}
+-
+ void AstDefaultVisitor::visitLambda(LambdaAst* node)
+ {
+     visitNode(node->arguments);
+diff --git a/parser/astdefaultvisitor.h b/parser/astdefaultvisitor.h
+index aa1f540c..85c31b46 100644
+--- a/parser/astdefaultvisitor.h
++++ b/parser/astdefaultvisitor.h
+@@ -93,8 +93,6 @@ public:
+     void visitTuple(TupleAst* node) override;
+     void visitEllipsis(EllipsisAst* node) override;
+     void visitSlice(SliceAst* node) override;
+-    void visitExtendedSlice(ExtendedSliceAst* node) override;
+-    void visitIndex(IndexAst* node) override;
+     void visitArguments(ArgumentsAst* node) override;
+     void visitArg(ArgAst* node) override;
+     void visitKeyword(KeywordAst* node) override;
+@@ -167,8 +165,6 @@ public:
+     void visitTuple(TupleAst* node) override { AstDefaultVisitor::visitTuple(node); delete node; }
+     void visitEllipsis(EllipsisAst* node) override { AstDefaultVisitor::visitEllipsis(node); delete node; }
+     void visitSlice(SliceAst* node) override { AstDefaultVisitor::visitSlice(node); delete node; }
+-    void visitExtendedSlice(ExtendedSliceAst* node) override { AstDefaultVisitor::visitExtendedSlice(node); delete node; }
+-    void visitIndex(IndexAst* node) override { AstDefaultVisitor::visitIndex(node); delete node; }
+     void visitArguments(ArgumentsAst* node) override { AstDefaultVisitor::visitArguments(node); delete node; }
+     void visitArg(ArgAst* node) override { AstDefaultVisitor::visitArg(node); delete node; }
+     void visitKeyword(KeywordAst* node) override { AstDefaultVisitor::visitKeyword(node); delete node; }
+diff --git a/parser/astvisitor.cpp b/parser/astvisitor.cpp
+index 51c5a1c5..5dc5e4ec 100644
+--- a/parser/astvisitor.cpp
++++ b/parser/astvisitor.cpp
+@@ -90,8 +90,6 @@ void AstVisitor::visitNode(Ast* node)
+         case Ast::TupleAstType:                                 this->visitTuple(static_cast<TupleAst*>(node)); break;
+         case Ast::EllipsisAstType:                              this->visitEllipsis(static_cast<EllipsisAst*>(node)); break;
+         case Ast::SliceAstType:                                 this->visitSlice(static_cast<SliceAst*>(node)); break;
+-        case Ast::ExtendedSliceAstType:                         this->visitExtendedSlice(static_cast<ExtendedSliceAst*>(node)); break;
+-        case Ast::IndexAstType:                                 this->visitIndex(static_cast<IndexAst*>(node)); break;
+         case Ast::ArgumentsAstType:                             this->visitArguments(static_cast<ArgumentsAst*>(node)); break;
+         case Ast::KeywordAstType:                               this->visitKeyword(static_cast<KeywordAst*>(node)); break;
+         case Ast::ArgAstType:                                   this->visitArg(static_cast<ArgAst*>(node)); break;
+diff --git a/parser/astvisitor.h b/parser/astvisitor.h
+index 51aa47b4..be9f759f 100644
+--- a/parser/astvisitor.h
++++ b/parser/astvisitor.h
+@@ -106,8 +106,6 @@ public:
+     virtual void visitTuple(TupleAst* node) { Q_UNUSED(node); };
+     virtual void visitEllipsis(EllipsisAst* node) { Q_UNUSED(node); };
+     virtual void visitSlice(SliceAst* node) { Q_UNUSED(node); };
+-    virtual void visitExtendedSlice(ExtendedSliceAst* node) { Q_UNUSED(node); };
+-    virtual void visitIndex(IndexAst* node) { Q_UNUSED(node); };
+     virtual void visitArguments(ArgumentsAst* node) { Q_UNUSED(node); };
+     virtual void visitKeyword(KeywordAst* node) { Q_UNUSED(node); };
+     virtual void visitArg(ArgAst* node) { Q_UNUSED(node); };
+diff --git a/parser/conversionGenerator.py b/parser/conversionGenerator.py
+index 66055953..3419b3d2 100644
+--- a/parser/conversionGenerator.py
++++ b/parser/conversionGenerator.py
+@@ -313,6 +313,8 @@ for index, lines in sorted(results.items()):
+         func = func_structure.replace('%{RULE_FOR}', index).replace('%{SWITCH_LINES}', current_switch_lines).replace('%{APPENDIX}', appendix)
+     else:
+         func = simple_func_structure.replace('%{RULE_FOR}', index).replace('%{SWITCH_LINES}', current_switch_lines)
++    if index == '_slice':
++        func = "#if PYTHON_VERSION < QT_VERSION_CHECK(3, 9, 0)\n" + func + "\n#endif\n"
+     print(func)
+ 
+ print('''};
+diff --git a/parser/generated.h b/parser/generated.h
+index e1136f84..2ba754df 100644
+--- a/parser/generated.h
++++ b/parser/generated.h
+@@ -426,6 +426,16 @@ PyObject *value = node->v.Constant.value;if (value == Py_None) {    NameConstant
+                 result = v;
+                 break;
+             }
++#endif
++#if PYTHON_VERSION >= QT_VERSION_CHECK(3, 9, 0)
++        case Slice_kind: {
++                SliceAst* v = new  SliceAst(parent());
++                nodeStack.push(v); v->lower = static_cast<ExpressionAst*>(visitNode(node->v.Slice.lower)); nodeStack.pop();
++                nodeStack.push(v); v->upper = static_cast<ExpressionAst*>(visitNode(node->v.Slice.upper)); nodeStack.pop();
++                nodeStack.push(v); v->step = static_cast<ExpressionAst*>(visitNode(node->v.Slice.step)); nodeStack.pop();
++                result = v;
++                break;
++            }
+ #endif
+         default:
+             qWarning() << "Unsupported _expr AST type: " << node->kind;
+@@ -480,12 +490,14 @@ PyObject *value = node->v.Constant.value;if (value == Py_None) {    NameConstant
+         return v;
+     }
+ 
++#if PYTHON_VERSION < QT_VERSION_CHECK(3, 9, 0)
+ 
+     Ast* visitNode(_slice* node) {
+         if ( ! node ) return nullptr;
+         bool ranges_copied = false; Q_UNUSED(ranges_copied);
+         Ast* result = nullptr;
+         switch ( node->kind ) {
++#if PYTHON_VERSION < QT_VERSION_CHECK(3, 9, 0)
+         case Slice_kind: {
+                 SliceAst* v = new  SliceAst(parent());
+                 nodeStack.push(v); v->lower = static_cast<ExpressionAst*>(visitNode(node->v.Slice.lower)); nodeStack.pop();
+@@ -494,18 +506,21 @@ PyObject *value = node->v.Constant.value;if (value == Py_None) {    NameConstant
+                 result = v;
+                 break;
+             }
++#endif
++#if PYTHON_VERSION < QT_VERSION_CHECK(3, 9, 0)
+         case ExtSlice_kind: {
+-                ExtendedSliceAst* v = new  ExtendedSliceAst(parent());
+-                nodeStack.push(v); v->dims = visitNodeList<_slice, SliceAst>(node->v.ExtSlice.dims); nodeStack.pop();
++                TupleAst* v = new  TupleAst(parent());
++                nodeStack.push(v); v->elements = visitNodeList<_expr, ExpressionAst>(node->v.ExtSlice.dims); nodeStack.pop();
+                 result = v;
+                 break;
+             }
++#endif
++#if PYTHON_VERSION < QT_VERSION_CHECK(3, 9, 0)
+         case Index_kind: {
+-                IndexAst* v = new  IndexAst(parent());
+-                nodeStack.push(v); v->value = static_cast<ExpressionAst*>(visitNode(node->v.Index.value)); nodeStack.pop();
+-                result = v;
++ return visitNode(node->v.Index.value);
+                 break;
+             }
++#endif
+         default:
+             qWarning() << "Unsupported _slice AST type: " << node->kind;
+             Q_ASSERT(false);
+@@ -537,6 +552,8 @@ PyObject *value = node->v.Constant.value;if (value == Py_None) {    NameConstant
+         return result;
+     }
+ 
++#endif
++
+ 
+     Ast* visitNode(_stmt* node) {
+         if ( ! node ) return nullptr;
+diff --git a/parser/python38.sdef b/parser/python39.sdef
+similarity index 96%
+rename from parser/python38.sdef
+rename to parser/python39.sdef
+index 30d9f95a..6b9b8b37 100644
+--- a/parser/python38.sdef
++++ b/parser/python39.sdef
+@@ -129,10 +129,11 @@ else {
+     Q_ASSERT(false);
+ };;
+ RULE_FOR _expr;KIND NamedExpr_kind;ACTIONS create|AssignmentExpressionAst set|target->ExpressionAst,target set|value->ExpressionAst,value;SINCE 3.8;;
++RULE_FOR _expr;KIND Slice_kind;ACTIONS create|SliceAst set|lower->ExpressionAst,lower set|upper->ExpressionAst,upper set|step->ExpressionAst,step;SINCE 3.9;;
+ 
+-RULE_FOR _slice;KIND Slice_kind;ACTIONS create|SliceAst set|lower->ExpressionAst,lower set|upper->ExpressionAst,upper set|step->ExpressionAst,step;;
+-RULE_FOR _slice;KIND ExtSlice_kind;ACTIONS create|ExtendedSliceAst set|dims=>SliceAst,dims;;
+-RULE_FOR _slice;KIND Index_kind;ACTIONS create|IndexAst set|value->ExpressionAst,value;;
++RULE_FOR _slice;KIND Slice_kind;ACTIONS create|SliceAst set|lower->ExpressionAst,lower set|upper->ExpressionAst,upper set|step->ExpressionAst,step;BEFORE 3.9;;
++RULE_FOR _slice;KIND ExtSlice_kind;ACTIONS create|TupleAst set|elements=>ExpressionAst,dims;BEFORE 3.9;;
++RULE_FOR _slice;KIND Index_kind;ACTIONS;BEFORE 3.9;CODE return visitNode(node->v.Index.value);;
+ 
+ 
+ RULE_FOR _comprehension;KIND any;ACTIONS create|ComprehensionAst set|target->ExpressionAst,target set|iterator->ExpressionAst,iter set|conditions=>ExpressionAst,ifs;;
+diff --git a/parser/rangefixvisitor.cpp b/parser/rangefixvisitor.cpp
+index c7804d3e..c70ed181 100644
+--- a/parser/rangefixvisitor.cpp
++++ b/parser/rangefixvisitor.cpp
+@@ -70,6 +70,11 @@ void RangeFixVisitor::visitNode(Ast* node) {
+     }
+ };
+ 
++void RangeFixVisitor::visitCode(CodeAst* node) {
++    node->startLine = node->startCol = 0;
++    AstDefaultVisitor::visitCode(node);
++}
++
+ void RangeFixVisitor::visitFunctionDefinition(FunctionDefinitionAst* node) {
+     cutDefinitionPreamble(node->name, node->async ? "asyncdef" : "def");
+     AstDefaultVisitor::visitFunctionDefinition(node);
+diff --git a/parser/rangefixvisitor.h b/parser/rangefixvisitor.h
+index 30ca5927..fac49e0c 100644
+--- a/parser/rangefixvisitor.h
++++ b/parser/rangefixvisitor.h
+@@ -37,6 +37,7 @@ class KDEVPYTHONPARSER_NO_EXPORT RangeFixVisitor : public AstDefaultVisitor {
+ public:
+     RangeFixVisitor(const QString& contents) : lines(contents.split('\n')) {};
+     void visitNode(Ast* node) override;
++    void visitCode(Python::CodeAst* node) override;
+     void visitFunctionDefinition(FunctionDefinitionAst* node) override;
+     void visitClassDefinition(ClassDefinitionAst* node) override;
+     void visitAttribute(AttributeAst* node) override;

diff --git a/kdevelop-python.spec b/kdevelop-python.spec
index 6dacd99..d533d1f 100644
--- a/kdevelop-python.spec
+++ b/kdevelop-python.spec
@@ -1,14 +1,10 @@
 %undefine __cmake_in_source_build
-# This package depends on automagic byte compilation
-# https://fedoraproject.org/wiki/Changes/No_more_automagic_Python_bytecompilation_phase_2
-%global _python_bytecompile_extra 1
-
 
 Name:       kdevelop-python
 Version:    5.5.2
 %global py3_suffix -py3
 %global py3_tag .py3
-Release:    3%{?dist}
+Release:    4%{?dist}
 License:    GPLv2
 Source0:    http://download.kde.org/stable/kdevelop/%{version}/src/kdev-python-%{version}.tar.xz
 
@@ -27,6 +23,9 @@ Patch1:     kdev-python-1.7.0-py3-doc-syntax.patch
 # Fix syntax error due to async being a reserved keyword in python3.7
 Patch2:     kdev-python_async.patch
 
+# Python 3.9 support
+Patch3:     kdevelop-python-39.patch
+
 Summary:    Python 3 Plugin for KDevelop
 URL:        https://www.kdevelop.org/
 
@@ -68,11 +67,14 @@ Python 3 language support for the KDevelop Integrated Development Environment.
 %patch1 -p1
 # async
 %patch2 -p1
+# Python 3.9
+%patch3 -p1
 
 %build
 %{cmake_kf5}
 %cmake_build
 
+%py_byte_compile %{__python3} %{buildroot}%{_datadir}/kdevpythonsupport
 
 %install
 %cmake_install
@@ -99,6 +101,9 @@ rm -f %{buildroot}%{_datadir}/kdevpythonsupport/documentation_files/PyKDE4/parse
 %{_datadir}/metainfo/org.kde.kdev-python.metainfo.xml
 
 %changelog
+* Mon Aug 24 2020 Jan Grulich <jgrulich@redhat.com> - 5.5.2-4
+- Support Python 3.9
+
 * Sat Aug 01 2020 Fedora Release Engineering <releng@fedoraproject.org> - 5.5.2-3
 - Second attempt - Rebuilt for
   https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild