1 /* 2 * Copyright 2020 Google LLC 3 * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 // WITH_RUNTIME 19 // TEST PROCESSOR: OverrideeProcessor 20 // EXPECTED: 21 // NoOverride: 22 // NoOverride.propInParam -> null 23 // NoOverride.prop -> null 24 // NoOverride.func(param:Int) -> null 25 // Subject: 26 // Companion.companionMethod() -> null 27 // Subject.notOverridingProp -> null 28 // Subject.overriddenBaseProp -> Base.overriddenBaseProp 29 // Subject.overriddenAbstractBaseProp -> Base.overriddenAbstractBaseProp 30 // Subject.openGrandBaseProp -> GrandBase.openGrandBaseProp 31 // Subject.abstractGrandBaseProp -> GrandBase.abstractGrandBaseProp 32 // Subject.overriddenGrandBaseProp -> Base.overriddenGrandBaseProp 33 // Subject.overriddenAbstractGrandBaseProp -> Base.overriddenAbstractGrandBaseProp 34 // Subject.openFun() -> Base.openFun() 35 // Subject.abstractFun() -> Base.abstractFun() 36 // Subject.openFunWithGenericArg(t:String) -> Base.openFunWithGenericArg(t:T) 37 // Subject.abstractFunWithGenericArg(t:String) -> Base.abstractFunWithGenericArg(t:T) 38 // Subject.nonOverridingMethod() -> null 39 // Subject.overriddenGrandBaseFun() -> Base.overriddenGrandBaseFun() 40 // Subject.overriddenAbstractGrandBaseFun() -> Base.overriddenAbstractGrandBaseFun() 41 // Subject.openGrandBaseFun() -> GrandBase.openGrandBaseFun() 42 // Subject.abstractGrandBaseFun() -> GrandBase.abstractGrandBaseFun() 43 // JavaSubject.Subject: 44 // Subject.openFun() -> Base.openFun() 45 // Subject.abstractFun() -> Base.abstractFun() 46 // Subject.openFunWithGenericArg(t:String) -> Base.openFunWithGenericArg(t:T) 47 // Subject.abstractFunWithGenericArg(t:String) -> Base.abstractFunWithGenericArg(t:T) 48 // Subject.nonOverridingMethod() -> null 49 // Subject.overriddenGrandBaseFun() -> Base.overriddenGrandBaseFun() 50 // Subject.overriddenAbstractGrandBaseFun() -> Base.overriddenAbstractGrandBaseFun() 51 // Subject.openGrandBaseFun() -> GrandBase.openGrandBaseFun() 52 // Subject.abstractGrandBaseFun() -> GrandBase.abstractGrandBaseFun() 53 // Subject.staticMethod() -> null 54 // lib.Subject: 55 // Companion.companionMethod() -> null 56 // Subject.abstractGrandBaseProp -> GrandBase.abstractGrandBaseProp 57 // Subject.notOverridingProp -> null 58 // Subject.openGrandBaseProp -> GrandBase.openGrandBaseProp 59 // Subject.overriddenAbstractBaseProp -> Base.overriddenAbstractBaseProp 60 // Subject.overriddenAbstractGrandBaseProp -> Base.overriddenAbstractGrandBaseProp 61 // Subject.overriddenBaseProp -> Base.overriddenBaseProp 62 // Subject.overriddenGrandBaseProp -> Base.overriddenGrandBaseProp 63 // Subject.abstractFun() -> Base.abstractFun() 64 // Subject.abstractFunWithGenericArg(t:String) -> Base.abstractFunWithGenericArg(t:T) 65 // Subject.abstractGrandBaseFun() -> GrandBase.abstractGrandBaseFun() 66 // Subject.nonOverridingMethod() -> null 67 // Subject.openFun() -> Base.openFun() 68 // Subject.openFunWithGenericArg(t:String) -> Base.openFunWithGenericArg(t:T) 69 // Subject.openGrandBaseFun() -> GrandBase.openGrandBaseFun() 70 // Subject.overriddenAbstractGrandBaseFun() -> Base.overriddenAbstractGrandBaseFun() 71 // Subject.overriddenGrandBaseFun() -> Base.overriddenGrandBaseFun() 72 // ConflictingSubject1: 73 // ConflictingSubject1.absFoo() -> MyInterface.absFoo() 74 // ConflictingSubject2: 75 // ConflictingSubject2.absFoo() -> MyAbstract.absFoo() 76 // ConflictingSubject3: 77 // ConflictingSubject3.absFoo() -> MyInterface.absFoo() 78 // ConflictingSubject4: 79 // ConflictingSubject4.absFoo() -> MyInterface2.absFoo() 80 // OverrideOrder1: 81 // OverrideOrder1.foo() -> GrandBaseInterface2.foo() 82 // OverrideOrder2: 83 // OverrideOrder2.foo() -> GrandBaseInterface1.foo() 84 // JavaAccessorImpl: 85 // JavaAccessorImpl.getX() -> KtInterfaceWithProperty.x 86 // JavaAccessorImpl.getY() -> KtInterfaceWithProperty.y 87 // JavaAccessorImpl.setY(value:Int) -> KtInterfaceWithProperty.y 88 // JavaAnno: 89 // JavaAnno.intParam() -> null 90 // JavaAnnos: 91 // JavaAnnos.value() -> null 92 // PrimaryConstructorOverride: 93 // PrimaryConstructorOverride.x -> KtInterfaceWithProperty.x 94 // PrimaryConstructorOverride.y -> KtInterfaceWithProperty.y 95 // END 96 // MODULE: lib 97 // FILE: lib.kt 98 package lib; 99 abstract class GrandBase { 100 open var openGrandBaseProp: Int = 0 101 abstract var abstractGrandBaseProp: Int 102 open var overriddenGrandBaseProp: Int = 0 103 abstract var overriddenAbstractGrandBaseProp: Int openGrandBaseFunnull104 open fun openGrandBaseFun() {} abstractGrandBaseFunnull105 abstract fun abstractGrandBaseFun() 106 open fun overriddenGrandBaseFun() {} overriddenAbstractGrandBaseFunnull107 abstract fun overriddenAbstractGrandBaseFun() 108 } 109 abstract class Base<T> : GrandBase() { 110 open var overriddenBaseProp: Int = 0 111 abstract var overriddenAbstractBaseProp: Int 112 override var overriddenGrandBaseProp:Int = 0 113 override var overriddenAbstractGrandBaseProp: Int = 0 114 open fun openFun() {} 115 abstract fun abstractFun():Unit 116 open fun openFunWithGenericArg(t:T):T = TODO() 117 abstract fun abstractFunWithGenericArg(t:T):T 118 override open fun overriddenGrandBaseFun() {} 119 override open fun overriddenAbstractGrandBaseFun() {} 120 } 121 122 abstract class Subject: Base<String>() { 123 var notOverridingProp: Int = 0 124 override open var overriddenBaseProp: Int = 0 125 override var overriddenAbstractBaseProp: Int = 0 126 override open var openGrandBaseProp: Int = 0 127 override var abstractGrandBaseProp: Int = 0 128 override var overriddenGrandBaseProp:Int = 0 129 override var overriddenAbstractGrandBaseProp: Int = 0 openFunnull130 override fun openFun() {} abstractFunnull131 override fun abstractFun() {} openFunWithGenericArgnull132 override fun openFunWithGenericArg(t:String):String = TODO() 133 override fun abstractFunWithGenericArg(t:String):String = TODO() 134 fun nonOverridingMethod(): String =TODO() 135 override fun overriddenGrandBaseFun() {} overriddenAbstractGrandBaseFunnull136 override fun overriddenAbstractGrandBaseFun() {} openGrandBaseFunnull137 override fun openGrandBaseFun() {} abstractGrandBaseFunnull138 override fun abstractGrandBaseFun() {} 139 companion object { companionMethodnull140 fun companionMethod(): String =TODO() 141 } 142 } 143 // MODULE: main(lib) 144 // FILE: a.kt 145 class NoOverride(val propInParam: Int) { 146 val prop: Int 147 fun func(val param: Int) { 148 149 } 150 } 151 152 interface KtInterfaceWithProperty { 153 val x:Int 154 var y:Int 155 } 156 157 interface Intermediate: KtInterfaceWithProperty 158 159 class PrimaryConstructorOverride(override val x: Int): Intermediate { 160 override val y: Int = 1 161 } 162 163 abstract class GrandBase { 164 open var openGrandBaseProp: Int = 0 165 abstract var abstractGrandBaseProp: Int = 0 166 open var overriddenGrandBaseProp: Int = 0 167 abstract var overriddenAbstractGrandBaseProp: Int = 0 openGrandBaseFunnull168 open fun openGrandBaseFun() {} abstractGrandBaseFunnull169 abstract fun abstractGrandBaseFun() 170 open fun overriddenGrandBaseFun() {} overriddenAbstractGrandBaseFunnull171 abstract fun overriddenAbstractGrandBaseFun() 172 } 173 abstract class Base<T> : GrandBase() { 174 open var overriddenBaseProp: Int = 0 175 var overriddenAbstractBaseProp: Int = 0 176 override var overriddenGrandBaseProp:Int = 0 177 override var overriddenAbstractGrandBaseProp: Int = 0 178 open fun openFun() {} 179 abstract fun abstractFun():Unit 180 open fun openFunWithGenericArg(t:T):T = TODO() 181 abstract fun abstractFunWithGenericArg(t:T):T 182 override open fun overriddenGrandBaseFun() {} 183 override open fun overriddenAbstractGrandBaseFun() {} 184 } 185 186 abstract class Subject: Base<String>() { 187 var notOverridingProp: Int = 0 188 override open var overriddenBaseProp: Int = 0 189 override var overriddenAbstractBaseProp: Int = 0 190 override open var openGrandBaseProp: Int = 0 191 override var abstractGrandBaseProp: Int = 0 192 override var overriddenGrandBaseProp:Int = 0 193 override var overriddenAbstractGrandBaseProp: Int = 0 openFunnull194 override fun openFun() {} abstractFunnull195 override fun abstractFun() {} openFunWithGenericArgnull196 override fun openFunWithGenericArg(t:String):String = TODO() 197 override fun abstractFunWithGenericArg(t:String):String = TODO() 198 fun nonOverridingMethod(): String =TODO() 199 override fun overriddenGrandBaseFun() {} overriddenAbstractGrandBaseFunnull200 override fun overriddenAbstractGrandBaseFun() {} openGrandBaseFunnull201 override fun openGrandBaseFun() {} abstractGrandBaseFunnull202 override fun abstractGrandBaseFun() {} 203 companion object { companionMethodnull204 fun companionMethod(): String =TODO() 205 } 206 } 207 208 // FILE: conflictingOverrides.kt 209 interface MyInterface { 210 fun absFoo(): Unit 211 } 212 213 interface MyInterface2 { absFoonull214 fun absFoo(): Unit 215 } 216 217 abstract class MyAbstract: MyInterface { 218 override fun absFoo(): Unit {val a = 1} 219 } 220 221 class ConflictingSubject1: MyInterface, MyAbstract() { absFoonull222 override fun absFoo(): Unit = TODO() 223 } 224 225 class ConflictingSubject2: MyAbstract(), MyInterface { 226 override fun absFoo(): Unit = TODO() 227 } 228 229 class ConflictingSubject3: MyInterface, MyInterface2 { absFoonull230 override fun absFoo(): Unit = TODO() 231 } 232 233 class ConflictingSubject4: MyInterface2, MyInterface { 234 override fun absFoo(): Unit = TODO() 235 } 236 237 // FILE: overrideOrder.kt 238 interface GrandBaseInterface1 { foonull239 fun foo(): Unit 240 } 241 242 interface GrandBaseInterface2 { 243 fun foo(): Unit 244 } 245 246 interface BaseInterface1 : GrandBaseInterface1 { 247 } 248 249 interface BaseInterface2 : GrandBaseInterface2 { 250 } 251 252 class OverrideOrder1 : BaseInterface1, GrandBaseInterface2 { foonull253 override fun foo() = TODO() 254 } 255 class OverrideOrder2 : BaseInterface2, GrandBaseInterface1 { 256 override fun foo() = TODO() 257 } 258 259 // FILE: JavaSubject.java 260 public class JavaSubject { 261 static abstract class GrandBase { 262 void openGrandBaseFun() {} 263 abstract void abstractGrandBaseFun(); 264 void overriddenGrandBaseFun() {} 265 abstract void overriddenAbstractGrandBaseFun(); 266 } 267 static abstract class Base<T> extends GrandBase { 268 void openFun() {} 269 abstract void abstractFun(); 270 T openFunWithGenericArg(T t) { 271 return null; 272 } 273 abstract T abstractFunWithGenericArg(T t); 274 void overriddenGrandBaseFun() {} 275 void overriddenAbstractGrandBaseFun() {} 276 } 277 278 static abstract class Subject extends Base<String> { 279 void openFun() {} 280 void abstractFun() {} 281 String openFunWithGenericArg(String t) { 282 return null; 283 } 284 String abstractFunWithGenericArg(String t) { 285 return null; 286 } 287 String nonOverridingMethod() { 288 return null; 289 } 290 void overriddenGrandBaseFun() {} 291 void overriddenAbstractGrandBaseFun() {} 292 void openGrandBaseFun() {} 293 void abstractGrandBaseFun() {} <lambda>null294 static String staticMethod() { 295 return null; 296 } 297 } 298 } 299 300 // FILE: JavaImpl.java 301 class JavaAccessorImpl implements KtInterfaceWithProperty { <lambda>null302 public int getX() { 303 return 1; 304 } <lambda>null305 public int getY() { 306 return 1; 307 } 308 public void setY(int value) { 309 } 310 } 311 312 // FILE: JavaAnno.java 313 @java.lang.annotation.Repeatable(JavaAnnos.class) 314 public @interface JavaAnno { 315 int intParam(); 316 } 317 318 // FILE: JavaAnnos.java 319 public @interface JavaAnnos { 320 JavaAnno[] value(); 321 } 322