Minor. Replace TraitImpl -> DefaultImpls, Trait -> Interface

There are still a lot of trait word entries in the source code,
only some of them got replaced here

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.kt

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.backend.common
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.backend.common.bridges.findTraitImplementation
+import org.jetbrains.kotlin.backend.common.bridges.findInterfaceImplementation
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.psi.*
@@ -105,7 +105,7 @@ object CodegenUtil {
         for (declaration in DescriptorUtils.getAllDescriptors(descriptor.defaultType.memberScope)) {
             if (declaration !is CallableMemberDescriptor) continue
 
-            val traitMember = findTraitImplementation(declaration)
+            val traitMember = findInterfaceImplementation(declaration)
             if (traitMember == null || Visibilities.isPrivate(traitMember.visibility)) continue
 
             assert(traitMember.modality !== Modality.ABSTRACT) { "Cannot delegate to abstract trait method: $declaration" }

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt

@@ -65,7 +65,7 @@ class DescriptorBasedFunctionHandle(
 
     override val isDeclaration: Boolean =
             descriptor.kind.isReal ||
-            findTraitImplementation(descriptor) != null
+            findInterfaceImplementation(descriptor) != null
 
     override val isAbstract: Boolean =
             descriptor.modality == Modality.ABSTRACT ||
@@ -88,7 +88,7 @@ class DescriptorBasedFunctionHandle(
  * trait implementation should be generated into the class containing the fake override; or null if the given function is not a fake
  * override of any trait implementation or such method was already generated into the superclass or is a method from Any.
  */
-fun findTraitImplementation(descriptor: CallableMemberDescriptor): CallableMemberDescriptor? {
+fun findInterfaceImplementation(descriptor: CallableMemberDescriptor): CallableMemberDescriptor? {
     if (descriptor.kind.isReal) return null
     if (isOrOverridesSynthesized(descriptor)) return null
 

compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java

@@ -87,7 +87,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtClassOrObject> {
             for (DeclarationDescriptor memberDescriptor : DescriptorUtils.getAllDescriptors(descriptor.getDefaultType().getMemberScope())) {
                 if (memberDescriptor instanceof CallableMemberDescriptor) {
                     CallableMemberDescriptor member = (CallableMemberDescriptor) memberDescriptor;
-                    if (!member.getKind().isReal() && ImplKt.findTraitImplementation(member) == null) {
+                    if (!member.getKind().isReal() && ImplKt.findInterfaceImplementation(member) == null) {
                         if (member instanceof FunctionDescriptor) {
                             functionCodegen.generateBridges((FunctionDescriptor) member);
                         }

compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java

@@ -377,7 +377,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         if (declaration instanceof KtClass && ((KtClass) declaration).isInterface()) {
             Type traitImplType = state.getTypeMapper().mapDefaultImpls(descriptor);
-            ClassBuilder traitImplBuilder = state.getFactory().newVisitor(JvmDeclarationOriginKt.TraitImpl(declaration, descriptor), traitImplType, declaration.getContainingFile());
+            ClassBuilder traitImplBuilder = state.getFactory().newVisitor(JvmDeclarationOriginKt.DefaultImpls(declaration, descriptor), traitImplType, declaration.getContainingFile());
             ClassContext traitImplContext = context.intoAnonymousClass(descriptor, this, OwnerKind.DEFAULT_IMPLS);
             new InterfaceImplBodyCodegen(declaration, traitImplContext, traitImplBuilder, state, parentCodegen).generate();
         }

compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java

@@ -236,7 +236,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         if (isInterface(descriptor) && !isLocal) {
             Type defaultImplsType = state.getTypeMapper().mapDefaultImpls(descriptor);
             ClassBuilder defaultImplsBuilder =
-                    state.getFactory().newVisitor(JvmDeclarationOriginKt.TraitImpl(myClass, descriptor), defaultImplsType, myClass.getContainingFile());
+                    state.getFactory().newVisitor(JvmDeclarationOriginKt.DefaultImpls(myClass, descriptor), defaultImplsType, myClass.getContainingFile());
 
             CodegenContext parentContext = context.getParentContext();
             assert parentContext != null : "Parent context of interface declaration should not be null";
@@ -329,7 +329,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 }
             }
         }
-        
+
         for (String kotlinMarkerInterface : kotlinMarkerInterfaces) {
             sw.writeInterface();
             sw.writeAsmType(Type.getObjectType(kotlinMarkerInterface));
@@ -1324,17 +1324,17 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         if (isAnnotationOrJvm6Interface(descriptor, state)) return;
 
         for (Map.Entry<FunctionDescriptor, FunctionDescriptor> entry : CodegenUtil.getNonPrivateTraitMethods(descriptor).entrySet()) {
-            FunctionDescriptor traitFun = entry.getKey();
+            FunctionDescriptor interfaceFun = entry.getKey();
             //skip java 8 default methods
-            if (!(traitFun instanceof JavaCallableMemberDescriptor)) {
+            if (!(interfaceFun instanceof JavaCallableMemberDescriptor)) {
-                generateDelegationToTraitImpl(traitFun, entry.getValue());
+                generateDelegationToDefaultImpl(interfaceFun, entry.getValue());
             }
         }
     }
 
-    private void generateDelegationToTraitImpl(@NotNull final FunctionDescriptor traitFun, @NotNull final FunctionDescriptor inheritedFun) {
+    private void generateDelegationToDefaultImpl(@NotNull final FunctionDescriptor traitFun, @NotNull final FunctionDescriptor inheritedFun) {
         functionCodegen.generateMethod(
-                JvmDeclarationOriginKt.DelegationToTraitImpl(descriptorToDeclaration(traitFun), traitFun),
+                JvmDeclarationOriginKt.DelegationToDefaultImpls(descriptorToDeclaration(traitFun), traitFun),
                 inheritedFun,
                 new FunctionGenerationStrategy.CodegenBased(state) {
                     @Override

compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.DelegationToTraitImpl
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.DelegationToDefaultImpls
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
@@ -85,19 +85,19 @@ class InterfaceImplBodyCodegen(
                                              CallableMemberDescriptor.Kind.DECLARATION, true)
 
             if (memberDescriptor is FunctionDescriptor) {
-                generateDelegationToSuperTraitImpl(copy as FunctionDescriptor, implementation as FunctionDescriptor)
+                generateDelegationToSuperDefaultImpls(copy as FunctionDescriptor, implementation as FunctionDescriptor)
             }
             else if (memberDescriptor is PropertyDescriptor) {
                 implementation as PropertyDescriptor
                 val getter = (copy as PropertyDescriptor).getter
                 val implGetter = implementation.getter
                 if (getter != null && implGetter != null) {
-                    generateDelegationToSuperTraitImpl(getter, implGetter)
+                    generateDelegationToSuperDefaultImpls(getter, implGetter)
                 }
                 val setter = copy.setter
                 val implSetter = implementation.setter
                 if (setter != null && implSetter != null) {
-                    generateDelegationToSuperTraitImpl(setter, implSetter)
+                    generateDelegationToSuperDefaultImpls(setter, implSetter)
                 }
             }
         }
@@ -105,14 +105,14 @@ class InterfaceImplBodyCodegen(
         generateSyntheticAccessors()
     }
 
-    private fun generateDelegationToSuperTraitImpl(descriptor: FunctionDescriptor, implementation: FunctionDescriptor) {
+    private fun generateDelegationToSuperDefaultImpls(descriptor: FunctionDescriptor, implementation: FunctionDescriptor) {
         val delegateTo = firstSuperMethodFromKotlin(descriptor, implementation) as FunctionDescriptor? ?: return
 
         // We can't call super methods from Java 1.8 interfaces because that requires INVOKESPECIAL which is forbidden from TImpl class
         if (delegateTo is JavaMethodDescriptor) return
 
         functionCodegen.generateMethod(
-                DelegationToTraitImpl(DescriptorToSourceUtils.descriptorToDeclaration(descriptor), descriptor),
+                DelegationToDefaultImpls(DescriptorToSourceUtils.descriptorToDeclaration(descriptor), descriptor),
                 descriptor,
                 object : FunctionGenerationStrategy.CodegenBased(state) {
                     override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InterfaceDefaultMethodCallChecker.kt

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.resolve.calls.checkers.CallCheckerContext
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 
-class TraitDefaultMethodCallChecker : CallChecker {
+class InterfaceDefaultMethodCallChecker : CallChecker {
     override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) {
         if (getSuperCallExpression(resolvedCall.call) == null) return
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/JvmDeclarationOrigin.kt

@@ -72,12 +72,12 @@ fun MultifileClass(representativeFile: KtFile?, descriptor: PackageFragmentDescr
 fun MultifileClassPart(file: KtFile, descriptor: PackageFragmentDescriptor): JvmDeclarationOrigin =
         JvmDeclarationOrigin(MULTIFILE_CLASS_PART, file, descriptor)
 
-fun TraitImpl(element: KtClassOrObject, descriptor: ClassDescriptor): JvmDeclarationOrigin = JvmDeclarationOrigin(INTERFACE_DEFAULT_IMPL, element, descriptor)
+fun DefaultImpls(element: KtClassOrObject, descriptor: ClassDescriptor): JvmDeclarationOrigin = JvmDeclarationOrigin(INTERFACE_DEFAULT_IMPL, element, descriptor)
-fun DelegationToTraitImpl(element: PsiElement?, descriptor: FunctionDescriptor): JvmDeclarationOrigin =
+fun DelegationToDefaultImpls(element: PsiElement?, descriptor: FunctionDescriptor): JvmDeclarationOrigin =
         JvmDeclarationOrigin(DELEGATION_TO_DEFAULT_IMPLS, element, descriptor)
 
 fun Delegation(element: PsiElement?, descriptor: FunctionDescriptor): JvmDeclarationOrigin = JvmDeclarationOrigin(DELEGATION, element, descriptor)
 
 fun SamDelegation(descriptor: FunctionDescriptor): JvmDeclarationOrigin = JvmDeclarationOrigin(SAM_DELEGATION, null, descriptor)
 
-fun Synthetic(element: PsiElement?, descriptor: CallableMemberDescriptor): JvmDeclarationOrigin = JvmDeclarationOrigin(SYNTHETIC, element, descriptor)
+fun Synthetic(element: PsiElement?, descriptor: CallableMemberDescriptor): JvmDeclarationOrigin = JvmDeclarationOrigin(SYNTHETIC, element, descriptor)

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt

@@ -47,7 +47,7 @@ object JvmPlatformConfigurator : PlatformConfigurator(
 
         additionalCallCheckers = listOf(
                 JavaAnnotationCallChecker(),
-                TraitDefaultMethodCallChecker(),
+                InterfaceDefaultMethodCallChecker(),
                 JavaClassOnCompanionChecker(),
                 ProtectedInSuperClassCompanionCallChecker(),
                 UnsupportedSyntheticCallableReferenceChecker(),