001    /*
002     * Copyright 2010-2015 JetBrains s.r.o.
003     *
004     * Licensed under the Apache License, Version 2.0 (the "License");
005     * you may not use this file except in compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     * http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed under the License is distributed on an "AS IS" BASIS,
012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013     * See the License for the specific language governing permissions and
014     * limitations under the License.
015     */
016    
017    package org.jetbrains.kotlin.cfg;
018    
019    import com.google.common.collect.Lists;
020    import com.google.common.collect.Maps;
021    import com.google.common.collect.Sets;
022    import com.intellij.psi.PsiElement;
023    import com.intellij.psi.tree.IElementType;
024    import com.intellij.psi.util.PsiTreeUtil;
025    import kotlin.Unit;
026    import kotlin.jvm.functions.Function1;
027    import kotlin.jvm.functions.Function3;
028    import org.jetbrains.annotations.NotNull;
029    import org.jetbrains.annotations.Nullable;
030    import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
031    import org.jetbrains.kotlin.cfg.PseudocodeVariablesData.VariableControlFlowState;
032    import org.jetbrains.kotlin.cfg.PseudocodeVariablesData.VariableUseState;
033    import org.jetbrains.kotlin.cfg.pseudocode.PseudoValue;
034    import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode;
035    import org.jetbrains.kotlin.cfg.pseudocode.PseudocodeUtil;
036    import org.jetbrains.kotlin.cfg.pseudocode.PseudocodeUtilsKt;
037    import org.jetbrains.kotlin.cfg.pseudocode.instructions.Instruction;
038    import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitor;
039    import org.jetbrains.kotlin.cfg.pseudocode.instructions.JetElementInstruction;
040    import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.*;
041    import org.jetbrains.kotlin.cfg.pseudocode.instructions.jumps.*;
042    import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.LocalFunctionDeclarationInstruction;
043    import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.MarkInstruction;
044    import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.SubroutineExitInstruction;
045    import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.VariableDeclarationInstruction;
046    import org.jetbrains.kotlin.cfg.pseudocodeTraverser.Edges;
047    import org.jetbrains.kotlin.cfg.pseudocodeTraverser.PseudocodeTraverserKt;
048    import org.jetbrains.kotlin.cfg.pseudocodeTraverser.TraversalOrder;
049    import org.jetbrains.kotlin.descriptors.*;
050    import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptorKt;
051    import org.jetbrains.kotlin.diagnostics.Diagnostic;
052    import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
053    import org.jetbrains.kotlin.diagnostics.Errors;
054    import org.jetbrains.kotlin.idea.MainFunctionDetector;
055    import org.jetbrains.kotlin.lexer.KtTokens;
056    import org.jetbrains.kotlin.psi.*;
057    import org.jetbrains.kotlin.resolve.*;
058    import org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilsKt;
059    import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
060    import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
061    import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.ResolvedCallUtilKt;
062    import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
063    import org.jetbrains.kotlin.types.KotlinType;
064    import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
065    
066    import java.util.*;
067    
068    import static org.jetbrains.kotlin.cfg.PseudocodeVariablesData.VariableUseState.*;
069    import static org.jetbrains.kotlin.cfg.TailRecursionKind.*;
070    import static org.jetbrains.kotlin.cfg.pseudocodeTraverser.TraversalOrder.FORWARD;
071    import static org.jetbrains.kotlin.diagnostics.Errors.*;
072    import static org.jetbrains.kotlin.diagnostics.Errors.UNREACHABLE_CODE;
073    import static org.jetbrains.kotlin.resolve.BindingContext.*;
074    import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
075    import static org.jetbrains.kotlin.types.TypeUtils.noExpectedType;
076    
077    public class JetFlowInformationProvider {
078    
079        private final KtElement subroutine;
080        private final Pseudocode pseudocode;
081        private final BindingTrace trace;
082        private PseudocodeVariablesData pseudocodeVariablesData;
083    
084        private JetFlowInformationProvider(
085                @NotNull KtElement declaration,
086                @NotNull BindingTrace trace,
087                @NotNull Pseudocode pseudocode
088        ) {
089            this.subroutine = declaration;
090            this.trace = trace;
091            this.pseudocode = pseudocode;
092        }
093    
094        public JetFlowInformationProvider(
095                @NotNull KtElement declaration,
096                @NotNull BindingTrace trace
097        ) {
098            this(declaration, trace, new JetControlFlowProcessor(trace).generatePseudocode(declaration));
099        }
100    
101        public PseudocodeVariablesData getPseudocodeVariablesData() {
102            if (pseudocodeVariablesData == null) {
103                pseudocodeVariablesData = new PseudocodeVariablesData(pseudocode, trace.getBindingContext());
104            }
105            return pseudocodeVariablesData;
106        }
107    
108        public void checkForLocalClassOrObjectMode() {
109            // Local classes and objects are analyzed twice: when TopDownAnalyzer processes it and as a part of its container.
110            // Almost all checks can be done when the container is analyzed
111            // except recording initialized variables (this information is needed for DeclarationChecker).
112            recordInitializedVariables();
113        }
114    
115        public void checkDeclaration() {
116    
117            recordInitializedVariables();
118    
119            checkLocalFunctions();
120    
121            markUninitializedVariables();
122    
123            markUnusedVariables();
124    
125            markStatements();
126    
127            markUnusedExpressions();
128    
129            markWhenWithoutElse();
130        }
131    
132        public void checkFunction(@Nullable KotlinType expectedReturnType) {
133            UnreachableCode unreachableCode = collectUnreachableCode();
134            reportUnreachableCode(unreachableCode);
135    
136            if (subroutine instanceof KtFunctionLiteral) return;
137    
138            checkDefiniteReturn(expectedReturnType != null ? expectedReturnType : NO_EXPECTED_TYPE, unreachableCode);
139    
140            markTailCalls();
141        }
142    
143        private void collectReturnExpressions(@NotNull final Collection<KtElement> returnedExpressions) {
144            final Set<Instruction> instructions = Sets.newHashSet(pseudocode.getInstructions());
145            SubroutineExitInstruction exitInstruction = pseudocode.getExitInstruction();
146            for (Instruction previousInstruction : exitInstruction.getPreviousInstructions()) {
147                previousInstruction.accept(new InstructionVisitor() {
148                    @Override
149                    public void visitReturnValue(@NotNull ReturnValueInstruction instruction) {
150                        if (instructions.contains(instruction)) { //exclude non-local return expressions
151                            returnedExpressions.add(instruction.getElement());
152                        }
153                    }
154    
155                    @Override
156                    public void visitReturnNoValue(@NotNull ReturnNoValueInstruction instruction) {
157                        if (instructions.contains(instruction)) {
158                            returnedExpressions.add(instruction.getElement());
159                        }
160                    }
161    
162    
163                    @Override
164                    public void visitJump(@NotNull AbstractJumpInstruction instruction) {
165                        // Nothing
166                    }
167    
168                    @Override
169                    public void visitUnconditionalJump(@NotNull UnconditionalJumpInstruction instruction) {
170                        redirectToPrevInstructions(instruction);
171                    }
172    
173                    private void redirectToPrevInstructions(Instruction instruction) {
174                        for (Instruction previousInstruction : instruction.getPreviousInstructions()) {
175                            previousInstruction.accept(this);
176                        }
177                    }
178    
179                    @Override
180                    public void visitNondeterministicJump(@NotNull NondeterministicJumpInstruction instruction) {
181                        redirectToPrevInstructions(instruction);
182                    }
183    
184                    @Override
185                    public void visitMarkInstruction(@NotNull MarkInstruction instruction) {
186                        redirectToPrevInstructions(instruction);
187                    }
188    
189                    @Override
190                    public void visitInstruction(@NotNull Instruction instruction) {
191                        if (instruction instanceof JetElementInstruction) {
192                            JetElementInstruction elementInstruction = (JetElementInstruction) instruction;
193                            returnedExpressions.add(elementInstruction.getElement());
194                        }
195                        else {
196                            throw new IllegalStateException(instruction + " precedes the exit point");
197                        }
198                    }
199                });
200            }
201        }
202    
203        private void checkLocalFunctions() {
204            for (LocalFunctionDeclarationInstruction localDeclarationInstruction : pseudocode.getLocalDeclarations()) {
205                KtElement element = localDeclarationInstruction.getElement();
206                if (element instanceof KtDeclarationWithBody) {
207                    KtDeclarationWithBody localDeclaration = (KtDeclarationWithBody) element;
208    
209                    CallableDescriptor functionDescriptor =
210                            (CallableDescriptor) trace.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, localDeclaration);
211                    KotlinType expectedType = functionDescriptor != null ? functionDescriptor.getReturnType() : null;
212    
213                    JetFlowInformationProvider providerForLocalDeclaration =
214                            new JetFlowInformationProvider(localDeclaration, trace, localDeclarationInstruction.getBody());
215    
216                    providerForLocalDeclaration.checkFunction(expectedType);
217                }
218            }
219        }
220    
221        public void checkDefiniteReturn(final @NotNull KotlinType expectedReturnType, @NotNull final UnreachableCode unreachableCode) {
222            assert subroutine instanceof KtDeclarationWithBody;
223            KtDeclarationWithBody function = (KtDeclarationWithBody) subroutine;
224    
225            if (!function.hasBody()) return;
226    
227            List<KtElement> returnedExpressions = Lists.newArrayList();
228            collectReturnExpressions(returnedExpressions);
229    
230            final boolean blockBody = function.hasBlockBody();
231    
232            final boolean[] noReturnError = new boolean[] { false };
233            for (KtElement returnedExpression : returnedExpressions) {
234                returnedExpression.accept(new KtVisitorVoid() {
235                    @Override
236                    public void visitReturnExpression(@NotNull KtReturnExpression expression) {
237                        if (!blockBody) {
238                            trace.report(RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY.on(expression));
239                        }
240                    }
241    
242                    @Override
243                    public void visitJetElement(@NotNull KtElement element) {
244                        if (!(element instanceof KtExpression || element instanceof KtWhenCondition)) return;
245    
246                        if (blockBody && !noExpectedType(expectedReturnType)
247                                && !KotlinBuiltIns.isUnit(expectedReturnType)
248                                && !unreachableCode.getElements().contains(element)) {
249                            noReturnError[0] = true;
250                        }
251                    }
252                });
253            }
254            if (noReturnError[0]) {
255                trace.report(NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY.on(function));
256            }
257        }
258    
259        private void reportUnreachableCode(@NotNull UnreachableCode unreachableCode) {
260            for (KtElement element : unreachableCode.getElements()) {
261                trace.report(UNREACHABLE_CODE.on(element, unreachableCode.getUnreachableTextRanges(element)));
262                trace.record(BindingContext.UNREACHABLE_CODE, element, true);
263            }
264        }
265    
266        @NotNull
267        private UnreachableCode collectUnreachableCode() {
268            Set<KtElement> reachableElements = Sets.newHashSet();
269            Set<KtElement> unreachableElements = Sets.newHashSet();
270            for (Instruction instruction : pseudocode.getInstructionsIncludingDeadCode()) {
271                if (!(instruction instanceof JetElementInstruction)
272                        || instruction instanceof LoadUnitValueInstruction
273                        || instruction instanceof MergeInstruction
274                        || (instruction instanceof MagicInstruction && ((MagicInstruction) instruction).getSynthetic())) continue;
275    
276                KtElement element = ((JetElementInstruction) instruction).getElement();
277    
278                if (instruction instanceof JumpInstruction) {
279                    boolean isJumpElement = element instanceof KtBreakExpression
280                                            || element instanceof KtContinueExpression
281                                            || element instanceof KtReturnExpression
282                                            || element instanceof KtThrowExpression;
283                    if (!isJumpElement) continue;
284                }
285    
286                if (instruction.getDead()) {
287                    unreachableElements.add(element);
288                }
289                else {
290                    reachableElements.add(element);
291                }
292            }
293            return new UnreachableCodeImpl(reachableElements, unreachableElements);
294        }
295    
296    ////////////////////////////////////////////////////////////////////////////////
297    //  Uninitialized variables analysis
298    
299        public void markUninitializedVariables() {
300            final Collection<VariableDescriptor> varWithUninitializedErrorGenerated = Sets.newHashSet();
301            final Collection<VariableDescriptor> varWithValReassignErrorGenerated = Sets.newHashSet();
302            final boolean processClassOrObject = subroutine instanceof KtClassOrObject;
303    
304            PseudocodeVariablesData pseudocodeVariablesData = getPseudocodeVariablesData();
305            Map<Instruction, Edges<Map<VariableDescriptor, VariableControlFlowState>>> initializers =
306                    pseudocodeVariablesData.getVariableInitializers();
307            final Set<VariableDescriptor> declaredVariables = pseudocodeVariablesData.getDeclaredVariables(pseudocode, true);
308            final LexicalScopeVariableInfo lexicalScopeVariableInfo = pseudocodeVariablesData.getLexicalScopeVariableInfo();
309    
310            final Map<Instruction, DiagnosticFactory<?>> reportedDiagnosticMap = Maps.newHashMap();
311    
312            PseudocodeTraverserKt.traverse(
313                    pseudocode, FORWARD, initializers,
314                    new InstructionDataAnalyzeStrategy<Map<VariableDescriptor, VariableControlFlowState>>() {
315                        @Override
316                        public void execute(
317                                @NotNull Instruction instruction,
318                                @Nullable Map<VariableDescriptor, VariableControlFlowState> in,
319                                @Nullable Map<VariableDescriptor, VariableControlFlowState> out
320                        ) {
321                            assert in != null && out != null;
322                            VariableInitContext ctxt =
323                                    new VariableInitContext(instruction, reportedDiagnosticMap, in, out, lexicalScopeVariableInfo);
324                            if (ctxt.variableDescriptor == null) return;
325                            if (instruction instanceof ReadValueInstruction) {
326                                ReadValueInstruction readValueInstruction = (ReadValueInstruction) instruction;
327                                KtElement element = readValueInstruction.getElement();
328                                boolean error = checkBackingField(ctxt, element);
329                                if (!error &&
330                                    PseudocodeUtil.isThisOrNoDispatchReceiver(readValueInstruction, trace.getBindingContext()) &&
331                                    declaredVariables.contains(ctxt.variableDescriptor)) {
332                                    checkIsInitialized(ctxt, element, varWithUninitializedErrorGenerated);
333                                }
334                                return;
335                            }
336                            if (!(instruction instanceof WriteValueInstruction)) return;
337                            WriteValueInstruction writeValueInstruction = (WriteValueInstruction) instruction;
338                            KtElement element = writeValueInstruction.getLValue();
339                            boolean error = checkBackingField(ctxt, element);
340                            if (!(element instanceof KtExpression)) return;
341                            if (!error) {
342                                error = checkValReassignment(ctxt, (KtExpression) element, writeValueInstruction,
343                                                             varWithValReassignErrorGenerated);
344                            }
345                            if (!error && processClassOrObject) {
346                                error = checkAssignmentBeforeDeclaration(ctxt, (KtExpression) element);
347                            }
348                            if (!error && processClassOrObject) {
349                                checkInitializationUsingBackingField(ctxt, (KtExpression) element);
350                            }
351                        }
352                    }
353            );
354        }
355    
356        public void recordInitializedVariables() {
357            PseudocodeVariablesData pseudocodeVariablesData = getPseudocodeVariablesData();
358            Pseudocode pseudocode = pseudocodeVariablesData.getPseudocode();
359            Map<Instruction, Edges<Map<VariableDescriptor, VariableControlFlowState>>> initializers =
360                    pseudocodeVariablesData.getVariableInitializers();
361            recordInitializedVariables(pseudocode, initializers);
362            for (LocalFunctionDeclarationInstruction instruction : pseudocode.getLocalDeclarations()) {
363                recordInitializedVariables(instruction.getBody(), initializers);
364            }
365        }
366    
367        private void checkIsInitialized(
368                @NotNull VariableInitContext ctxt,
369                @NotNull KtElement element,
370                @NotNull Collection<VariableDescriptor> varWithUninitializedErrorGenerated
371        ) {
372            if (!(element instanceof KtSimpleNameExpression)) return;
373    
374    
375            boolean isDefinitelyInitialized = ctxt.exitInitState.definitelyInitialized();
376            VariableDescriptor variableDescriptor = ctxt.variableDescriptor;
377            if (variableDescriptor instanceof PropertyDescriptor) {
378                PropertyDescriptor propertyDescriptor = (PropertyDescriptor) variableDescriptor;
379                if (propertyDescriptor.isLateInit() || !trace.get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor)) {
380                    isDefinitelyInitialized = true;
381                }
382            }
383            if (!isDefinitelyInitialized && !varWithUninitializedErrorGenerated.contains(variableDescriptor)) {
384                if (!(variableDescriptor instanceof PropertyDescriptor)) {
385                    varWithUninitializedErrorGenerated.add(variableDescriptor);
386                }
387                if (variableDescriptor instanceof ValueParameterDescriptor) {
388                    report(Errors.UNINITIALIZED_PARAMETER.on((KtSimpleNameExpression) element,
389                                                             (ValueParameterDescriptor) variableDescriptor), ctxt);
390                }
391                else {
392                    report(Errors.UNINITIALIZED_VARIABLE.on((KtSimpleNameExpression) element, variableDescriptor), ctxt);
393                }
394            }
395        }
396    
397        private boolean checkValReassignment(
398                @NotNull VariableInitContext ctxt,
399                @NotNull KtExpression expression,
400                @NotNull WriteValueInstruction writeValueInstruction,
401                @NotNull Collection<VariableDescriptor> varWithValReassignErrorGenerated
402        ) {
403            VariableDescriptor variableDescriptor = ctxt.variableDescriptor;
404            PropertyDescriptor propertyDescriptor = SyntheticFieldDescriptorKt.getReferencedProperty(variableDescriptor);
405            if (KtPsiUtil.isBackingFieldReference(expression, variableDescriptor) && propertyDescriptor != null) {
406                KtPropertyAccessor accessor = PsiTreeUtil.getParentOfType(expression, KtPropertyAccessor.class);
407                if (accessor != null) {
408                    DeclarationDescriptor accessorDescriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, accessor);
409                    if (propertyDescriptor.getGetter() == accessorDescriptor) {
410                        //val can be reassigned through backing field inside its own getter
411                        return false;
412                    }
413                }
414            }
415    
416            boolean mayBeInitializedNotHere = ctxt.enterInitState.mayBeInitialized();
417            boolean hasBackingField = true;
418            if (variableDescriptor instanceof PropertyDescriptor) {
419                hasBackingField = trace.get(BindingContext.BACKING_FIELD_REQUIRED, (PropertyDescriptor) variableDescriptor);
420            }
421            if (variableDescriptor.isVar() && variableDescriptor instanceof PropertyDescriptor) {
422                DeclarationDescriptor descriptor = BindingContextUtils.getEnclosingDescriptor(trace.getBindingContext(), expression);
423                PropertySetterDescriptor setterDescriptor = ((PropertyDescriptor) variableDescriptor).getSetter();
424    
425                ResolvedCall<? extends CallableDescriptor> resolvedCall = CallUtilKt.getResolvedCall(expression, trace.getBindingContext());
426                ReceiverValue receiverValue = ReceiverValue.IRRELEVANT_RECEIVER;
427                if (resolvedCall != null) {
428                    receiverValue = ExpressionTypingUtils
429                            .normalizeReceiverValueForVisibility(resolvedCall.getDispatchReceiver(), trace.getBindingContext());
430    
431                }
432                if (Visibilities.isVisible(receiverValue, variableDescriptor, descriptor) && setterDescriptor != null
433                        && !Visibilities.isVisible(receiverValue, setterDescriptor, descriptor)) {
434                    report(Errors.INVISIBLE_SETTER.on(expression, variableDescriptor, setterDescriptor.getVisibility(),
435                                                      setterDescriptor), ctxt);
436                    return true;
437                }
438            }
439            boolean isThisOrNoDispatchReceiver =
440                    PseudocodeUtil.isThisOrNoDispatchReceiver(writeValueInstruction, trace.getBindingContext());
441            if ((mayBeInitializedNotHere || !hasBackingField || !isThisOrNoDispatchReceiver) && !variableDescriptor.isVar()) {
442                boolean hasReassignMethodReturningUnit = false;
443                KtSimpleNameExpression operationReference = null;
444                PsiElement parent = expression.getParent();
445                if (parent instanceof KtBinaryExpression) {
446                    operationReference = ((KtBinaryExpression) parent).getOperationReference();
447                }
448                else if (parent instanceof KtUnaryExpression) {
449                    operationReference = ((KtUnaryExpression) parent).getOperationReference();
450                }
451                if (operationReference != null) {
452                    DeclarationDescriptor descriptor = trace.get(BindingContext.REFERENCE_TARGET, operationReference);
453                    if (descriptor instanceof FunctionDescriptor) {
454                        if (KotlinBuiltIns.isUnit(((FunctionDescriptor) descriptor).getReturnType())) {
455                            hasReassignMethodReturningUnit = true;
456                        }
457                    }
458                    if (descriptor == null) {
459                        Collection<? extends DeclarationDescriptor> descriptors =
460                                trace.get(BindingContext.AMBIGUOUS_REFERENCE_TARGET, operationReference);
461                        if (descriptors != null) {
462                            for (DeclarationDescriptor referenceDescriptor : descriptors) {
463                                if (KotlinBuiltIns.isUnit(((FunctionDescriptor) referenceDescriptor).getReturnType())) {
464                                    hasReassignMethodReturningUnit = true;
465                                }
466                            }
467                        }
468                    }
469                }
470                if (!hasReassignMethodReturningUnit) {
471                    if (!isThisOrNoDispatchReceiver || !varWithValReassignErrorGenerated.contains(variableDescriptor)) {
472                        report(Errors.VAL_REASSIGNMENT.on(expression, variableDescriptor), ctxt);
473                    }
474                    if (isThisOrNoDispatchReceiver) {
475                        // try to get rid of repeating VAL_REASSIGNMENT diagnostic only for vars with no receiver
476                        // or when receiver is this
477                        varWithValReassignErrorGenerated.add(variableDescriptor);
478                    }
479                    return true;
480                }
481            }
482            return false;
483        }
484    
485        private boolean checkAssignmentBeforeDeclaration(@NotNull VariableInitContext ctxt, @NotNull KtExpression expression) {
486            if (!ctxt.enterInitState.isDeclared && !ctxt.exitInitState.isDeclared
487                && !ctxt.enterInitState.mayBeInitialized() && ctxt.exitInitState.mayBeInitialized()) {
488                report(Errors.INITIALIZATION_BEFORE_DECLARATION.on(expression, ctxt.variableDescriptor), ctxt);
489                return true;
490            }
491            return false;
492        }
493    
494        private boolean checkInitializationUsingBackingField(@NotNull VariableInitContext ctxt, @NotNull KtExpression expression) {
495            VariableDescriptor variableDescriptor = ctxt.variableDescriptor;
496            if (variableDescriptor instanceof PropertyDescriptor
497                && !ctxt.enterInitState.mayBeInitialized()
498                && ctxt.exitInitState.mayBeInitialized()) {
499                if (!variableDescriptor.isVar()) return false;
500                if (!trace.get(BindingContext.BACKING_FIELD_REQUIRED, (PropertyDescriptor) variableDescriptor)) return false;
501                PsiElement property = DescriptorToSourceUtils.descriptorToDeclaration(variableDescriptor);
502                assert property instanceof KtProperty;
503                KtPropertyAccessor setter = ((KtProperty) property).getSetter();
504                if (((PropertyDescriptor) variableDescriptor).getModality() == Modality.FINAL && (setter == null || !setter.hasBody())) {
505                    return false;
506                }
507                KtExpression variable = expression;
508                if (expression instanceof KtDotQualifiedExpression) {
509                    if (((KtDotQualifiedExpression) expression).getReceiverExpression() instanceof KtThisExpression) {
510                        variable = ((KtDotQualifiedExpression) expression).getSelectorExpression();
511                    }
512                }
513                if (variable instanceof KtSimpleNameExpression) {
514                    KtSimpleNameExpression simpleNameExpression = (KtSimpleNameExpression) variable;
515                    if (simpleNameExpression.getReferencedNameElementType() != KtTokens.FIELD_IDENTIFIER) {
516                        trace.record(IS_UNINITIALIZED, (PropertyDescriptor) variableDescriptor);
517                        return true;
518                    }
519                }
520            }
521            return false;
522        }
523    
524        private boolean checkBackingField(@NotNull VariableContext cxtx, @NotNull KtElement element) {
525            VariableDescriptor variableDescriptor = cxtx.variableDescriptor;
526            boolean[] error = new boolean[1];
527            if (!isCorrectBackingFieldReference(element, cxtx, error, true)) return false;
528            if (error[0]) return true;
529            if (!(variableDescriptor instanceof PropertyDescriptor)) {
530                report(Errors.NOT_PROPERTY_BACKING_FIELD.on(element), cxtx);
531                return true;
532            }
533            PsiElement property = DescriptorToSourceUtils.descriptorToDeclaration(variableDescriptor);
534            boolean insideSelfAccessors = PsiTreeUtil.isAncestor(property, element, false);
535            if (!trace.get(BindingContext.BACKING_FIELD_REQUIRED, (PropertyDescriptor) variableDescriptor) &&
536                    // not to generate error in accessors of abstract properties, there is one: declared accessor of abstract property
537                    !insideSelfAccessors) {
538    
539                if (((PropertyDescriptor) variableDescriptor).getModality() == Modality.ABSTRACT) {
540                    report(NO_BACKING_FIELD_ABSTRACT_PROPERTY.on(element), cxtx);
541                }
542                else {
543                    report(NO_BACKING_FIELD_CUSTOM_ACCESSORS.on(element), cxtx);
544                }
545                return true;
546            }
547            if (insideSelfAccessors) return false;
548    
549            DeclarationDescriptor declarationDescriptor = BindingContextUtils.getEnclosingDescriptor(trace.getBindingContext(), element);
550    
551            DeclarationDescriptor containingDeclaration = variableDescriptor.getContainingDeclaration();
552            if ((containingDeclaration instanceof ClassDescriptor)
553                    && DescriptorUtils.isAncestor(containingDeclaration, declarationDescriptor, false)) {
554                if (element instanceof KtSimpleNameExpression) {
555                    report(Errors.BACKING_FIELD_USAGE_FORBIDDEN.on((KtSimpleNameExpression) element), cxtx);
556                }
557                return false;
558            }
559            report(Errors.INACCESSIBLE_BACKING_FIELD.on(element), cxtx);
560            return true;
561        }
562    
563        private boolean isCorrectBackingFieldReference(
564                @Nullable KtElement element,
565                VariableContext ctxt,
566                boolean[] error,
567                boolean reportError
568        ) {
569            error[0] = false;
570            if (KtPsiUtil.isBackingFieldReference(element, null)) {
571                return true;
572            }
573            if (element instanceof KtDotQualifiedExpression && isCorrectBackingFieldReference(
574                    ((KtDotQualifiedExpression) element).getSelectorExpression(), ctxt, error, false)) {
575                if (((KtDotQualifiedExpression) element).getReceiverExpression() instanceof KtThisExpression) {
576                    return true;
577                }
578                error[0] = true;
579                if (reportError) {
580                    report(Errors.INACCESSIBLE_BACKING_FIELD.on(element), ctxt);
581                }
582            }
583            return false;
584        }
585    
586        private void recordInitializedVariables(
587                @NotNull Pseudocode pseudocode,
588                @NotNull Map<Instruction, Edges<Map<VariableDescriptor, VariableControlFlowState>>> initializersMap
589        ) {
590            Edges<Map<VariableDescriptor, VariableControlFlowState>> initializers = initializersMap.get(pseudocode.getExitInstruction());
591            if (initializers == null) return;
592            Set<VariableDescriptor> declaredVariables = getPseudocodeVariablesData().getDeclaredVariables(pseudocode, false);
593            for (VariableDescriptor variable : declaredVariables) {
594                if (variable instanceof PropertyDescriptor) {
595                    VariableControlFlowState variableControlFlowState = initializers.getIncoming().get(variable);
596                    if (variableControlFlowState != null && variableControlFlowState.definitelyInitialized()) continue;
597                    trace.record(BindingContext.IS_UNINITIALIZED, (PropertyDescriptor) variable);
598                }
599            }
600        }
601    
602    ////////////////////////////////////////////////////////////////////////////////
603    //  "Unused variable" & "unused value" analyses
604    
605        public void markUnusedVariables() {
606            final PseudocodeVariablesData pseudocodeVariablesData = getPseudocodeVariablesData();
607            Map<Instruction, Edges<Map<VariableDescriptor, VariableUseState>>> variableStatusData =
608                    pseudocodeVariablesData.getVariableUseStatusData();
609            final Map<Instruction, DiagnosticFactory<?>> reportedDiagnosticMap = Maps.newHashMap();
610            InstructionDataAnalyzeStrategy<Map<VariableDescriptor, VariableUseState>> variableStatusAnalyzeStrategy =
611                    new InstructionDataAnalyzeStrategy<Map<VariableDescriptor, VariableUseState>>() {
612                        @Override
613                        public void execute(
614                                @NotNull Instruction instruction,
615                                @Nullable Map<VariableDescriptor, VariableUseState> in,
616                                @Nullable Map<VariableDescriptor, VariableUseState> out
617                        ) {
618    
619                            assert in != null && out != null;
620                            VariableContext ctxt = new VariableUseContext(instruction, reportedDiagnosticMap, in, out);
621                            Set<VariableDescriptor> declaredVariables =
622                                    pseudocodeVariablesData.getDeclaredVariables(instruction.getOwner(), false);
623                            VariableDescriptor variableDescriptor = PseudocodeUtil.extractVariableDescriptorIfAny(
624                                    instruction, false, trace.getBindingContext());
625                            if (variableDescriptor == null || !declaredVariables.contains(variableDescriptor)
626                                    || !ExpressionTypingUtils.isLocal(variableDescriptor.getContainingDeclaration(), variableDescriptor)) {
627                                return;
628                            }
629                            PseudocodeVariablesData.VariableUseState variableUseState = in.get(variableDescriptor);
630                            if (instruction instanceof WriteValueInstruction) {
631                                if (trace.get(CAPTURED_IN_CLOSURE, variableDescriptor) != null) return;
632                                KtElement element = ((WriteValueInstruction) instruction).getElement();
633                                if (variableUseState != READ) {
634                                    if (element instanceof KtBinaryExpression &&
635                                        ((KtBinaryExpression) element).getOperationToken() == KtTokens.EQ) {
636                                        KtExpression right = ((KtBinaryExpression) element).getRight();
637                                        if (right != null) {
638                                            report(Errors.UNUSED_VALUE.on((KtBinaryExpression) element, right, variableDescriptor), ctxt);
639                                        }
640                                    }
641                                    else if (element instanceof KtPostfixExpression) {
642                                        IElementType operationToken =
643                                                ((KtPostfixExpression) element).getOperationReference().getReferencedNameElementType();
644                                        if (operationToken == KtTokens.PLUSPLUS || operationToken == KtTokens.MINUSMINUS) {
645                                            report(Errors.UNUSED_CHANGED_VALUE.on(element, element), ctxt);
646                                        }
647                                    }
648                                }
649                            }
650                            else if (instruction instanceof VariableDeclarationInstruction) {
651                                KtDeclaration element = ((VariableDeclarationInstruction) instruction).getVariableDeclarationElement();
652                                if (!(element instanceof KtNamedDeclaration)) return;
653                                PsiElement nameIdentifier = ((KtNamedDeclaration) element).getNameIdentifier();
654                                if (nameIdentifier == null) return;
655                                if (!VariableUseState.isUsed(variableUseState)) {
656                                    if (KtPsiUtil.isVariableNotParameterDeclaration(element)) {
657                                        report(Errors.UNUSED_VARIABLE.on((KtNamedDeclaration) element, variableDescriptor), ctxt);
658                                    }
659                                    else if (element instanceof KtParameter) {
660                                        PsiElement owner = element.getParent().getParent();
661                                        if (owner instanceof KtPrimaryConstructor) {
662                                            if (!((KtParameter) element).hasValOrVar()) {
663                                                KtClassOrObject containingClass = ((KtPrimaryConstructor) owner).getContainingClassOrObject();
664                                                DeclarationDescriptor containingClassDescriptor = trace.get(
665                                                        BindingContext.DECLARATION_TO_DESCRIPTOR, containingClass
666                                                );
667                                                if (!DescriptorUtils.isAnnotationClass(containingClassDescriptor)) {
668                                                    report(Errors.UNUSED_PARAMETER.on((KtParameter) element, variableDescriptor), ctxt);
669                                                }
670                                            }
671                                        }
672                                        else if (owner instanceof KtFunction) {
673                                            MainFunctionDetector mainFunctionDetector = new MainFunctionDetector(trace.getBindingContext());
674                                            boolean isMain = (owner instanceof KtNamedFunction) && mainFunctionDetector.isMain((KtNamedFunction) owner);
675                                            if (owner instanceof KtFunctionLiteral) return;
676                                            DeclarationDescriptor descriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, owner);
677                                            assert descriptor instanceof FunctionDescriptor : owner.getText();
678                                            FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
679                                            String functionName = functionDescriptor.getName().asString();
680                                            if (isMain
681                                                || functionDescriptor.getModality().isOverridable()
682                                                || !functionDescriptor.getOverriddenDescriptors().isEmpty()
683                                                || "getValue".equals(functionName) || "setValue".equals(functionName)
684                                                || "propertyDelegated".equals(functionName)
685                                                    ) {
686                                                return;
687                                            }
688                                            report(Errors.UNUSED_PARAMETER.on((KtParameter) element, variableDescriptor), ctxt);
689                                        }
690                                    }
691                                }
692                                else if (variableUseState == ONLY_WRITTEN_NEVER_READ && KtPsiUtil.isVariableNotParameterDeclaration(element)) {
693                                    report(Errors.ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE.on((KtNamedDeclaration) element, variableDescriptor), ctxt);
694                                }
695                                else if (variableUseState == WRITTEN_AFTER_READ && element instanceof KtVariableDeclaration) {
696                                    if (element instanceof KtProperty) {
697                                        KtExpression initializer = ((KtProperty) element).getInitializer();
698                                        if (initializer != null) {
699                                            report(Errors.VARIABLE_WITH_REDUNDANT_INITIALIZER.on(initializer, variableDescriptor), ctxt);
700                                        }
701                                    }
702                                    else if (element instanceof KtMultiDeclarationEntry) {
703                                        report(VARIABLE_WITH_REDUNDANT_INITIALIZER.on(element, variableDescriptor), ctxt);
704                                    }
705                                }
706                            }
707                        }
708                    };
709            PseudocodeTraverserKt.traverse(pseudocode, TraversalOrder.BACKWARD, variableStatusData, variableStatusAnalyzeStrategy);
710        }
711    
712    ////////////////////////////////////////////////////////////////////////////////
713    //  "Unused expressions" in block
714    
715        public void markUnusedExpressions() {
716            final Map<Instruction, DiagnosticFactory<?>> reportedDiagnosticMap = Maps.newHashMap();
717            PseudocodeTraverserKt.traverse(
718                    pseudocode, FORWARD, new JetFlowInformationProvider.FunctionVoid1<Instruction>() {
719                        @Override
720                        public void execute(@NotNull Instruction instruction) {
721                            if (!(instruction instanceof JetElementInstruction)) return;
722    
723                            KtElement element = ((JetElementInstruction)instruction).getElement();
724                            if (!(element instanceof KtExpression)) return;
725    
726                            if (BindingContextUtilsKt.isUsedAsStatement((KtExpression) element, trace.getBindingContext())
727                                && PseudocodeUtilsKt.getSideEffectFree(instruction)) {
728                                VariableContext ctxt = new VariableContext(instruction, reportedDiagnosticMap);
729                                report(
730                                        element instanceof KtFunctionLiteralExpression
731                                            ? Errors.UNUSED_FUNCTION_LITERAL.on((KtFunctionLiteralExpression) element)
732                                            : Errors.UNUSED_EXPRESSION.on(element),
733                                        ctxt
734                                );
735                            }
736                        }
737                    }
738            );
739        }
740    
741    ////////////////////////////////////////////////////////////////////////////////
742    // Statements
743    
744        public void markStatements() {
745            PseudocodeTraverserKt.traverse(
746                    pseudocode, FORWARD, new JetFlowInformationProvider.FunctionVoid1<Instruction>() {
747                        @Override
748                        public void execute(@NotNull Instruction instruction) {
749                            PseudoValue value = instruction instanceof InstructionWithValue
750                                                ? ((InstructionWithValue) instruction).getOutputValue()
751                                                : null;
752                            Pseudocode pseudocode = instruction.getOwner();
753                            boolean isUsedAsExpression = !pseudocode.getUsages(value).isEmpty();
754                            for (KtElement element : pseudocode.getValueElements(value)) {
755                                trace.record(BindingContext.USED_AS_EXPRESSION, element, isUsedAsExpression);
756                            }
757                        }
758                    }
759            );
760        }
761    
762        public void markWhenWithoutElse() {
763            PseudocodeTraverserKt.traverse(
764                    pseudocode, FORWARD, new JetFlowInformationProvider.FunctionVoid1<Instruction>() {
765                        @Override
766                        public void execute(@NotNull Instruction instruction) {
767                            PseudoValue value = instruction instanceof InstructionWithValue
768                                                ? ((InstructionWithValue) instruction).getOutputValue()
769                                                : null;
770                            for (KtElement element : instruction.getOwner().getValueElements(value)) {
771                                if (!(element instanceof KtWhenExpression)) continue;
772                                KtWhenExpression whenExpression = (KtWhenExpression) element;
773                                if (whenExpression.getElseExpression() != null) continue;
774    
775                                if (WhenChecker.mustHaveElse(whenExpression, trace)) {
776                                    trace.report(NO_ELSE_IN_WHEN.on(whenExpression));
777                                }
778                                else if (whenExpression.getSubjectExpression() != null) {
779                                    ClassDescriptor enumClassDescriptor = WhenChecker.getClassDescriptorOfTypeIfEnum(
780                                            trace.getType(whenExpression.getSubjectExpression()));
781                                    if (enumClassDescriptor != null
782                                        && !WhenChecker.isWhenOnEnumExhaustive(whenExpression, trace, enumClassDescriptor)) {
783                                        trace.report(NON_EXHAUSTIVE_WHEN.on(whenExpression));
784                                    }
785                                }
786                            }
787                        }
788                    }
789            );
790        }
791    
792    ////////////////////////////////////////////////////////////////////////////////
793    // Tail calls
794    
795        public void markTailCalls() {
796            final DeclarationDescriptor subroutineDescriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, subroutine);
797            if (!(subroutineDescriptor instanceof FunctionDescriptor)) return;
798            if (!((FunctionDescriptor) subroutineDescriptor).isTailrec()) return;
799    
800            // finally blocks are copied which leads to multiple diagnostics reported on one instruction
801            class KindAndCall {
802                TailRecursionKind kind;
803                ResolvedCall<?> call;
804    
805                KindAndCall(TailRecursionKind kind, ResolvedCall<?> call) {
806                    this.kind = kind;
807                    this.call = call;
808                }
809            }
810            final Map<KtElement, KindAndCall> calls = new HashMap<KtElement, KindAndCall>();
811            PseudocodeTraverserKt.traverse(
812                    pseudocode,
813                    FORWARD,
814                    new FunctionVoid1<Instruction>() {
815                        public void execute(@NotNull Instruction instruction) {
816                            if (!(instruction instanceof CallInstruction)) return;
817                            CallInstruction callInstruction = (CallInstruction) instruction;
818    
819                            ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(callInstruction.getElement(), trace.getBindingContext());
820                            if (resolvedCall == null) return;
821    
822                            // is this a recursive call?
823                            CallableDescriptor functionDescriptor = resolvedCall.getResultingDescriptor();
824                            if (!functionDescriptor.getOriginal().equals(subroutineDescriptor)) return;
825    
826                            KtElement element = callInstruction.getElement();
827                            //noinspection unchecked
828                            KtExpression parent = PsiTreeUtil.getParentOfType(
829                                    element,
830                                    KtTryExpression.class, KtFunction.class, KtClassInitializer.class
831                            );
832    
833                            if (parent instanceof KtTryExpression) {
834                                // We do not support tail calls Collections.singletonMap() try-catch-finally, for simplicity of the mental model
835                                // very few cases there would be real tail-calls, and it's often not so easy for the user to see why
836                                calls.put(element, new KindAndCall(IN_TRY, resolvedCall));
837                                return;
838                            }
839    
840                            boolean isTail = PseudocodeTraverserKt.traverseFollowingInstructions(
841                                    callInstruction,
842                                    new HashSet<Instruction>(),
843                                    FORWARD,
844                                    new TailRecursionDetector(subroutine, callInstruction)
845                            );
846    
847                            // A tail call is not allowed to change dispatch receiver
848                            //   class C {
849                            //       fun foo(other: C) {
850                            //           other.foo(this) // not a tail call
851                            //       }
852                            //   }
853                            boolean sameDispatchReceiver =
854                                    ResolvedCallUtilKt.hasThisOrNoDispatchReceiver(resolvedCall, trace.getBindingContext());
855    
856                            TailRecursionKind kind = isTail && sameDispatchReceiver ? TAIL_CALL : NON_TAIL;
857    
858                            KindAndCall kindAndCall = calls.get(element);
859                            calls.put(element,
860                                      new KindAndCall(
861                                              combineKinds(kind, kindAndCall == null ? null : kindAndCall.kind),
862                                              resolvedCall
863                                      )
864                            );
865                        }
866                    }
867            );
868            boolean hasTailCalls = false;
869            for (Map.Entry<KtElement, KindAndCall> entry : calls.entrySet()) {
870                KtElement element = entry.getKey();
871                KindAndCall kindAndCall = entry.getValue();
872                switch (kindAndCall.kind) {
873                    case TAIL_CALL:
874                        trace.record(TAIL_RECURSION_CALL, kindAndCall.call, TailRecursionKind.TAIL_CALL);
875                        hasTailCalls = true;
876                        break;
877                    case IN_TRY:
878                        trace.report(Errors.TAIL_RECURSION_IN_TRY_IS_NOT_SUPPORTED.on(element));
879                        break;
880                    case NON_TAIL:
881                        trace.report(Errors.NON_TAIL_RECURSIVE_CALL.on(element));
882                        break;
883                }
884            }
885    
886            if (!hasTailCalls) {
887                trace.report(Errors.NO_TAIL_CALLS_FOUND.on((KtNamedFunction) subroutine));
888            }
889        }
890    
891        private static TailRecursionKind combineKinds(TailRecursionKind kind, @Nullable TailRecursionKind existingKind) {
892            TailRecursionKind resultingKind;
893            if (existingKind == null || existingKind == kind) {
894                resultingKind = kind;
895            }
896            else {
897                if (check(kind, existingKind, IN_TRY, TAIL_CALL)) {
898                    resultingKind = IN_TRY;
899                }
900                else if (check(kind, existingKind, IN_TRY, NON_TAIL)) {
901                    resultingKind = IN_TRY;
902                }
903                else {
904                    // TAIL_CALL, NON_TAIL
905                    resultingKind = NON_TAIL;
906                }
907            }
908            return resultingKind;
909        }
910    
911        private static boolean check(Object a, Object b, Object x, Object y) {
912            return (a == x && b == y) || (a == y && b == x);
913        }
914    
915    ////////////////////////////////////////////////////////////////////////////////
916    // Utility classes and methods
917    
918        /**
919         * The method provides reporting of the same diagnostic only once for copied instructions
920         * (depends on whether it should be reported for all or only for one of the copies)
921         */
922        private void report(
923                @NotNull Diagnostic diagnostic,
924                @NotNull VariableContext ctxt
925        ) {
926            Instruction instruction = ctxt.instruction;
927            if (instruction.getCopies().isEmpty()) {
928                trace.report(diagnostic);
929                return;
930            }
931            Map<Instruction, DiagnosticFactory<?>> previouslyReported = ctxt.reportedDiagnosticMap;
932            previouslyReported.put(instruction, diagnostic.getFactory());
933    
934            boolean alreadyReported = false;
935            boolean sameErrorForAllCopies = true;
936            for (Instruction copy : instruction.getCopies()) {
937                DiagnosticFactory<?> previouslyReportedErrorFactory = previouslyReported.get(copy);
938                if (previouslyReportedErrorFactory != null) {
939                    alreadyReported = true;
940                }
941    
942                if (previouslyReportedErrorFactory != diagnostic.getFactory()) {
943                    sameErrorForAllCopies = false;
944                }
945            }
946    
947            if (mustBeReportedOnAllCopies(diagnostic.getFactory())) {
948                if (sameErrorForAllCopies) {
949                    trace.report(diagnostic);
950                }
951            }
952            else {
953                //only one reporting required
954                if (!alreadyReported) {
955                    trace.report(diagnostic);
956                }
957            }
958        }
959    
960        private static boolean mustBeReportedOnAllCopies(@NotNull DiagnosticFactory<?> diagnosticFactory) {
961            return diagnosticFactory == UNUSED_VARIABLE
962                   || diagnosticFactory == UNUSED_PARAMETER
963                   || diagnosticFactory == UNUSED_CHANGED_VALUE;
964        }
965    
966    
967        private class VariableContext {
968            final Map<Instruction, DiagnosticFactory<?>> reportedDiagnosticMap;
969            final Instruction instruction;
970            final VariableDescriptor variableDescriptor;
971    
972            private VariableContext(
973                    @NotNull Instruction instruction,
974                    @NotNull Map<Instruction, DiagnosticFactory<?>> map
975            ) {
976                this.instruction = instruction;
977                reportedDiagnosticMap = map;
978                variableDescriptor = PseudocodeUtil.extractVariableDescriptorIfAny(instruction, true, trace.getBindingContext());
979            }
980        }
981    
982        private class VariableInitContext extends VariableContext {
983            final VariableControlFlowState enterInitState;
984            final VariableControlFlowState exitInitState;
985    
986            private VariableInitContext(
987                    @NotNull Instruction instruction,
988                    @NotNull Map<Instruction, DiagnosticFactory<?>> map,
989                    @NotNull Map<VariableDescriptor, VariableControlFlowState> in,
990                    @NotNull Map<VariableDescriptor, VariableControlFlowState> out,
991                    @NotNull LexicalScopeVariableInfo lexicalScopeVariableInfo
992            ) {
993                super(instruction, map);
994                enterInitState = initialize(variableDescriptor, lexicalScopeVariableInfo, in);
995                exitInitState = initialize(variableDescriptor, lexicalScopeVariableInfo, out);
996            }
997    
998            private VariableControlFlowState initialize(
999                    VariableDescriptor variableDescriptor,
1000                    LexicalScopeVariableInfo lexicalScopeVariableInfo,
1001                    Map<VariableDescriptor, VariableControlFlowState> map
1002            ) {
1003                if (variableDescriptor == null) return null;
1004                VariableControlFlowState state = map.get(variableDescriptor);
1005                if (state != null) return state;
1006                return PseudocodeVariablesData.getDefaultValueForInitializers(variableDescriptor, instruction, lexicalScopeVariableInfo);
1007            }
1008        }
1009    
1010        private class VariableUseContext extends VariableContext {
1011            final VariableUseState enterUseState;
1012            final VariableUseState exitUseState;
1013    
1014    
1015            private VariableUseContext(
1016                    @NotNull Instruction instruction,
1017                    @NotNull Map<Instruction, DiagnosticFactory<?>> map,
1018                    @NotNull Map<VariableDescriptor, VariableUseState> in,
1019                    @NotNull Map<VariableDescriptor, VariableUseState> out
1020            ) {
1021                super(instruction, map);
1022                enterUseState = variableDescriptor != null ? in.get(variableDescriptor) : null;
1023                exitUseState = variableDescriptor != null ? out.get(variableDescriptor) : null;
1024            }
1025        }
1026    
1027        //TODO after KT-4621 rewrite to Kotlin
1028        public abstract static class InstructionDataAnalyzeStrategy<D> implements Function3<Instruction, D, D, Unit> {
1029            @Override
1030            public Unit invoke(Instruction instruction, D enterData, D exitData) {
1031                execute(instruction, enterData, exitData);
1032                return Unit.INSTANCE$;
1033            }
1034    
1035            public abstract void execute(Instruction instruction, D enterData, D exitData);
1036        }
1037    
1038        public abstract static class FunctionVoid1<P> implements Function1<P, Unit> {
1039            @Override
1040            public Unit invoke(P p) {
1041                execute(p);
1042                return Unit.INSTANCE$;
1043            }
1044    
1045            public abstract void execute(P p);
1046        }
1047    }