rename PSI classes according to current terminology:

KtMultiDeclaration(Entry) -> KtDestructuringDeclaration(Entry)
KtFunctionLiteralExpression -> KtLambdaExpression
KtFunctionLiteralArgument -> KtLambdaArgument
KtDelegationSpecifierList -> KtSuperTypeList
KtDelegationSpecifier -> KtSuperTypeListEntry
KtDelegatorToSuperClass -> KtSuperTypeEntry
KtDelegatorToSuperCall -> KtSuperTypeCallEntry
KtDelegationByExpressionSpecifier ->KtDelegatedSuperTypeEntry

js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DelegationTranslator.kt

@@ -33,8 +33,8 @@ import org.jetbrains.kotlin.js.translate.utils.TranslationUtils.simpleReturnFunc
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils.translateFunctionAsEcma5PropertyDescriptor
 import org.jetbrains.kotlin.js.translate.utils.generateDelegateCall
 import org.jetbrains.kotlin.psi.KtClassOrObject
-import org.jetbrains.kotlin.psi.KtDelegationSpecifier
-import org.jetbrains.kotlin.psi.KtDelegatorByExpressionSpecifier
+import org.jetbrains.kotlin.psi.KtSuperTypeListEntry
+import org.jetbrains.kotlin.psi.KtDelegatedSuperTypeEntry
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import java.util.*
 
@@ -47,10 +47,10 @@ public class DelegationTranslator(
             BindingUtils.getClassDescriptor(context.bindingContext(), classDeclaration);
 
     private val delegationBySpecifiers =
-            classDeclaration.getDelegationSpecifiers().filterIsInstance<KtDelegatorByExpressionSpecifier>();
+            classDeclaration.getSuperTypeListEntries().filterIsInstance<KtDelegatedSuperTypeEntry>();
 
     private class Field (val name: String, val generateField: Boolean)
-    private val fields = HashMap<KtDelegatorByExpressionSpecifier, Field>()
+    private val fields = HashMap<KtDelegatedSuperTypeEntry, Field>()
 
     init {
         for (specifier in delegationBySpecifiers) {
@@ -88,8 +88,8 @@ public class DelegationTranslator(
         }
     }
 
-    private fun getSuperClass(specifier: KtDelegationSpecifier): ClassDescriptor =
-        CodegenUtil.getSuperClassByDelegationSpecifier(specifier, bindingContext())
+    private fun getSuperClass(specifier: KtSuperTypeListEntry): ClassDescriptor =
+        CodegenUtil.getSuperClassBySuperTypeListEntry(specifier, bindingContext())
 
     private fun generateDelegates(toClass: ClassDescriptor, field: Field, properties: MutableList<JsPropertyInitializer>) {
         for ((descriptor, overriddenDescriptor) in CodegenUtilKt.getDelegates(classDescriptor, toClass)) {

js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/DestructuringDeclarationTranslator.java

@@ -28,8 +28,8 @@ import org.jetbrains.kotlin.js.translate.callTranslator.CallTranslator;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.js.translate.reference.CallExpressionTranslator;
-import org.jetbrains.kotlin.psi.KtMultiDeclaration;
-import org.jetbrains.kotlin.psi.KtMultiDeclarationEntry;
+import org.jetbrains.kotlin.psi.KtDestructuringDeclaration;
+import org.jetbrains.kotlin.psi.KtDestructuringDeclarationEntry;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -39,28 +39,28 @@ import java.util.List;
 
 import static org.jetbrains.kotlin.js.translate.utils.InlineUtils.setInlineCallMetadata;
 
-public class MultiDeclarationTranslator extends AbstractTranslator {
+public class DestructuringDeclarationTranslator extends AbstractTranslator {
 
     // if multiObjectName was init, initializer must be null
     @NotNull
     public static JsVars translate(
-            @NotNull KtMultiDeclaration multiDeclaration,
+            @NotNull KtDestructuringDeclaration multiDeclaration,
             @NotNull JsName multiObjectName,
             @Nullable JsExpression initializer,
             @NotNull TranslationContext context
     ) {
-        return new MultiDeclarationTranslator(multiDeclaration, multiObjectName, initializer, context).translate();
+        return new DestructuringDeclarationTranslator(multiDeclaration, multiObjectName, initializer, context).translate();
     }
 
     @NotNull
-    private final KtMultiDeclaration multiDeclaration;
+    private final KtDestructuringDeclaration multiDeclaration;
     @NotNull
     private final JsName multiObjectName;
     @Nullable
     private final JsExpression initializer;
 
-    private MultiDeclarationTranslator(
-            @NotNull KtMultiDeclaration multiDeclaration,
+    private DestructuringDeclarationTranslator(
+            @NotNull KtDestructuringDeclaration multiDeclaration,
             @NotNull JsName multiObjectName,
             @Nullable JsExpression initializer,
             @NotNull TranslationContext context
@@ -78,7 +78,7 @@ public class MultiDeclarationTranslator extends AbstractTranslator {
         }
 
         JsNameRef multiObjNameRef = multiObjectName.makeRef();
-        for (KtMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
+        for (KtDestructuringDeclarationEntry entry : multiDeclaration.getEntries()) {
             ResolvedCall<FunctionDescriptor> entryInitCall =  context().bindingContext().get(BindingContext.COMPONENT_RESOLVED_CALL, entry);
             assert entryInitCall != null : "Entry init call must be not null";
             JsExpression entryInitializer = CallTranslator.translate(context(), entryInitCall, multiObjNameRef);

js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java

@@ -123,11 +123,11 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
     }
 
     @Override
-    public JsNode visitMultiDeclaration(@NotNull KtMultiDeclaration multiDeclaration, @NotNull TranslationContext context) {
+    public JsNode visitDestructuringDeclaration(@NotNull KtDestructuringDeclaration multiDeclaration, @NotNull TranslationContext context) {
         KtExpression jetInitializer = multiDeclaration.getInitializer();
         assert jetInitializer != null : "Initializer for multi declaration must be not null";
         JsExpression initializer = Translation.translateAsExpression(jetInitializer, context);
-        return MultiDeclarationTranslator.translate(multiDeclaration, context.scope().declareTemporary(), initializer, context);
+        return DestructuringDeclarationTranslator.translate(multiDeclaration, context.scope().declareTemporary(), initializer, context);
     }
 
     @Override
@@ -409,7 +409,7 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitFunctionLiteralExpression(@NotNull KtFunctionLiteralExpression expression, @NotNull TranslationContext context) {
+    public JsNode visitLambdaExpression(@NotNull KtLambdaExpression expression, @NotNull TranslationContext context) {
         return new LiteralFunctionTranslator(context).translate(expression.getFunctionLiteral());
     }
 

js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/FunctionTranslator.java

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils;
 import org.jetbrains.kotlin.psi.KtDeclarationWithBody;
-import org.jetbrains.kotlin.psi.KtFunctionLiteralExpression;
+import org.jetbrains.kotlin.psi.KtLambdaExpression;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 
@@ -160,6 +160,6 @@ public final class FunctionTranslator extends AbstractTranslator {
     }
 
     private boolean isExtensionFunction() {
-        return DescriptorUtils.isExtension(descriptor) && !(functionDeclaration instanceof KtFunctionLiteralExpression);
+        return DescriptorUtils.isExtension(descriptor) && !(functionDeclaration instanceof KtLambdaExpression);
     }
 }

js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/LoopTranslator.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.js.translate.callTranslator.CallTranslator
 import org.jetbrains.kotlin.js.translate.context.TemporaryVariable
 import org.jetbrains.kotlin.js.translate.context.TranslationContext
-import org.jetbrains.kotlin.js.translate.expression.MultiDeclarationTranslator
+import org.jetbrains.kotlin.js.translate.expression.DestructuringDeclarationTranslator
 import org.jetbrains.kotlin.js.translate.general.Translation
 import org.jetbrains.kotlin.js.translate.intrinsic.functions.factories.CompositeFIF
 import org.jetbrains.kotlin.js.translate.utils.BindingUtils.getHasNextCallable
@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.js.translate.utils.TranslationUtils
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtBinaryExpression
 import org.jetbrains.kotlin.psi.KtForExpression
-import org.jetbrains.kotlin.psi.KtMultiDeclaration
+import org.jetbrains.kotlin.psi.KtDestructuringDeclaration
 import org.jetbrains.kotlin.psi.KtWhileExpressionBase
 import org.jetbrains.kotlin.resolve.DescriptorUtils.getClassDescriptorForType
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
@@ -115,14 +115,14 @@ public fun translateForExpression(expression: KtForExpression, context: Translat
                getClassDescriptorForType(rangeType).getName().asString() == "IntArray"
     }
 
-    val multiParameter: KtMultiDeclaration? = expression.getMultiParameter();
+    val destructuringParameter: KtDestructuringDeclaration? = expression.getDestructuringParameter();
 
     fun declareParameter(): JsName {
         val loopParameter = getLoopParameter(expression)
         if (loopParameter != null) {
             return context.getNameForElement(loopParameter)
         }
-        assert(multiParameter != null) { "If loopParameter is null, multi parameter must be not null ${expression.getText()}" }
+        assert(destructuringParameter != null) { "If loopParameter is null, multi parameter must be not null ${expression.getText()}" }
         return context.scope().declareTemporary()
     }
 
@@ -130,15 +130,15 @@ public fun translateForExpression(expression: KtForExpression, context: Translat
 
     fun translateBody(itemValue: JsExpression?): JsStatement? {
         val realBody = expression.getBody()?.let { Translation.translateAsStatementAndMergeInBlockIfNeeded(it, context) }
-        if (itemValue == null && multiParameter == null) {
+        if (itemValue == null && destructuringParameter == null) {
             return realBody
         }
         else {
             val currentVarInit =
-                if (multiParameter == null)
+                if (destructuringParameter == null)
                     newVar(parameterName, itemValue)
                 else
-                    MultiDeclarationTranslator.translate(multiParameter, parameterName, itemValue, context)
+                    DestructuringDeclarationTranslator.translate(destructuringParameter, parameterName, itemValue, context)
 
             if (realBody == null) return JsBlock(currentVarInit)
 

js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/ClassInitializerTranslator.java

@@ -158,9 +158,9 @@ public final class ClassInitializerTranslator extends AbstractTranslator {
 
     @Nullable
     private ResolvedCall<FunctionDescriptor> getSuperCall() {
-        for (KtDelegationSpecifier specifier : classDeclaration.getDelegationSpecifiers()) {
-            if (specifier instanceof KtDelegatorToSuperCall) {
-                KtDelegatorToSuperCall superCall = (KtDelegatorToSuperCall) specifier;
+        for (KtSuperTypeListEntry specifier : classDeclaration.getSuperTypeListEntries()) {
+            if (specifier instanceof KtSuperTypeCallEntry) {
+                KtSuperTypeCallEntry superCall = (KtSuperTypeCallEntry) specifier;
                 //noinspection unchecked
                 return (ResolvedCall<FunctionDescriptor>) CallUtilKt.getResolvedCallWithAssert(superCall, bindingContext());
             }