Add inspection for redundant overrides that only calls the super method

So #KT-19428 Fixed

idea/testData/inspectionsLocal/redundantOverride/.inspection

@@ -0,0 +1 @@
+org.jetbrains.kotlin.idea.inspections.KotlinRedundantOverrideInspection

idea/testData/inspectionsLocal/redundantOverride/annotated.kt

@@ -0,0 +1,15 @@
+// PROBLEM: none
+@Target(AnnotationTarget.FUNCTION)
+annotation class Annotation
+
+open class Foo {
+    open fun simple() {
+    }
+}
+
+class Bar : Foo() {
+    @Annotation override <caret>fun simple() {
+        super.simple()
+    }
+}
+

idea/testData/inspectionsLocal/redundantOverride/arguments.kt

@@ -0,0 +1,10 @@
+open class Foo {
+    open fun arguments(arg1: Int, arg2: Long) {
+    }
+}
+
+class Bar : Foo() {
+    override <caret>fun arguments(arg1: Int, arg2: Long) {
+        super.arguments(arg1, arg2)
+    }
+}

idea/testData/inspectionsLocal/redundantOverride/arguments.kt.after

@@ -0,0 +1,7 @@
+open class Foo {
+    open fun arguments(arg1: Int, arg2: Long) {
+    }
+}
+
+class Bar : Foo() {
+}

idea/testData/inspectionsLocal/redundantOverride/argumentsReplaced.kt

@@ -0,0 +1,11 @@
+// PROBLEM: none
+open class Foo {
+    open fun arguments(arg1: Int, arg2: Int) {
+    }
+}
+
+class Bar : Foo() {
+    override <caret>fun arguments(arg1: Int, arg2: Int) {
+        super.arguments(arg2, arg1)
+    }
+}

idea/testData/inspectionsLocal/redundantOverride/basic.kt

@@ -0,0 +1,10 @@
+open class Foo {
+    open fun simple() {
+    }
+}
+
+class Bar : Foo() {
+    override <caret>fun simple() {
+        super.simple()
+    }
+}

idea/testData/inspectionsLocal/redundantOverride/basic.kt.after

@@ -0,0 +1,7 @@
+open class Foo {
+    open fun simple() {
+    }
+}
+
+class Bar : Foo() {
+}

idea/testData/inspectionsLocal/redundantOverride/callDifferentSuperMethod.kt

@@ -0,0 +1,15 @@
+// PROBLEM: none
+
+open class Foo {
+    open fun simple() {
+    }
+
+    open fun callDifferentSuperMethod() {
+    }
+}
+
+class Bar : Foo() {
+    override <caret>fun callDifferentSuperMethod() {
+        super.simple()
+    }
+}

idea/testData/inspectionsLocal/redundantOverride/notCallSuper.kt

@@ -0,0 +1,12 @@
+// PROBLEM: none
+
+open class Foo {
+    open fun simple() {
+    }
+}
+
+class Bar : Foo() {
+    override <caret>fun simple() {
+        1 + 1;
+    }
+}

idea/testData/inspectionsLocal/redundantOverride/overrideModifireFinal.kt

@@ -0,0 +1,13 @@
+// PROBLEM: none
+
+open class Foo {
+    open fun simple() {
+    }
+}
+
+class Bar : Foo() {
+    final override <caret>fun simple() {
+        super.simple()
+    }
+}
+

idea/testData/inspectionsLocal/redundantOverride/overrideModifireVisibility.kt

@@ -0,0 +1,13 @@
+// PROBLEM: none
+
+open class Foo {
+    protected open fun simple() {
+    }
+}
+
+class Bar : Foo() {
+    public override <caret>fun simple() {
+        super.simple()
+    }
+}
+

idea/testData/inspectionsLocal/redundantOverride/singleExpressionFunction.kt

@@ -0,0 +1,8 @@
+open class Foo {
+    open fun singleExpression() {
+    }
+}
+
+class Bar : Foo() {
+    override <caret>fun singleExpression() = super.singleExpression()
+}

idea/testData/inspectionsLocal/redundantOverride/singleExpressionFunction.kt.after

@@ -0,0 +1,7 @@
+open class Foo {
+    open fun singleExpression() {
+    }
+}
+
+class Bar : Foo() {
+}

idea/testData/inspectionsLocal/redundantOverride/useGenericsSuper.kt

@@ -0,0 +1,14 @@
+// PROBLEM: none
+
+interface First {
+    fun foo() = 2
+}
+interface Second {
+    fun foo() = 3
+}
+
+class Diamond : First, Second {
+    override <caret>fun foo(): Int {
+        return super<First>.foo()
+    }
+}