KT-609 Analyze not only local variables, but function parameters as well in 'unused values' analysis

compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java

@@ -35,26 +35,30 @@ public class JetControlFlowProcessor {
         this.trace = trace;
     }
 
-    public void generate(@NotNull JetDeclaration subroutineElement, @NotNull JetExpression body) {
+    public void generate(@NotNull JetDeclaration subroutine) {
-        generateSubroutineControlFlow(subroutineElement, Collections.singletonList(body));
+        builder.enterSubroutine(subroutine);
-    }
+        if (subroutine instanceof JetDeclarationWithBody) {
-
+            JetDeclarationWithBody declarationWithBody = (JetDeclarationWithBody) subroutine;
-    public void generateSubroutineControlFlow(@NotNull JetDeclaration subroutineElement, @NotNull List<? extends JetElement> body) {
+            CFPVisitor cfpVisitor = new CFPVisitor(false);
-        builder.enterSubroutine(subroutineElement);
+            List<JetParameter> valueParameters = declarationWithBody.getValueParameters();
-        for (JetElement statement : body) {
+            for (JetParameter valueParameter : valueParameters) {
-            statement.accept(new CFPVisitor(false));
+                valueParameter.accept(cfpVisitor);
+            }
+            JetExpression bodyExpression = declarationWithBody.getBodyExpression();
+            if (bodyExpression != null) {
+                bodyExpression.accept(cfpVisitor);
+            }
         }
-        builder.exitSubroutine(subroutineElement);
+        else {
+            subroutine.accept(new CFPVisitor(false));
+        }
+        builder.exitSubroutine(subroutine);
     }
 
-    private void processLocalDeclaration(@NotNull JetDeclaration subroutineElement, @NotNull JetExpression body) {
+    private void processLocalDeclaration(@NotNull JetDeclaration subroutine) {
-        processLocalDeclaration(subroutineElement, Collections.singletonList(body));
-    }
-
-    private void processLocalDeclaration(@NotNull JetDeclaration subroutineElement, @NotNull List<? extends JetElement> body) {
         Label afterDeclaration = builder.createUnboundLabel();
         builder.nondeterministicJump(afterDeclaration);
-        generateSubroutineControlFlow(subroutineElement, body);
+        generate(subroutine);
         builder.bindLabel(afterDeclaration);
     }
 
@@ -569,6 +573,12 @@ public class JetControlFlowProcessor {
             }
         }
 
+        @Override
+        public void visitParameter(JetParameter parameter) {
+            builder.declare(parameter);
+            builder.write(parameter, parameter);
+        }
+
         @Override
         public void visitBlockExpression(JetBlockExpression expression) {
             List<JetElement> statements = expression.getStatements();
@@ -582,20 +592,13 @@ public class JetControlFlowProcessor {
 
         @Override
         public void visitNamedFunction(JetNamedFunction function) {
-            JetExpression bodyExpression = function.getBodyExpression();
+            processLocalDeclaration(function);
-            if (bodyExpression != null) {
-                processLocalDeclaration(function, bodyExpression);
-            }
         }
 
         @Override
         public void visitFunctionLiteralExpression(JetFunctionLiteralExpression expression) {
             JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
-            JetBlockExpression bodyExpression = functionLiteral.getBodyExpression();
+            processLocalDeclaration(functionLiteral);
-            if (bodyExpression != null) {
-                List<JetElement> statements = bodyExpression.getStatements();
-                processLocalDeclaration(functionLiteral, statements);
-            }
             builder.read(expression);
         }
 

compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java

@@ -19,6 +19,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.types.JetStandardClasses;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lexer.JetTokens;
+import org.jetbrains.jet.plugin.JetMainDetector;
 
 import java.util.*;
 
@@ -68,7 +69,7 @@ public class JetFlowInformationProvider {
             }
         };
         JetControlFlowInstructionsGenerator instructionsGenerator = new JetControlFlowInstructionsGenerator(wrappedTrace);
-        new JetControlFlowProcessor(trace, instructionsGenerator).generate(declaration, bodyExpression);
+        new JetControlFlowProcessor(trace, instructionsGenerator).generate(declaration);
         wrappedTrace.close();
     }
 
@@ -479,13 +480,27 @@ public class JetFlowInformationProvider {
                         } 
                         else if (instruction instanceof VariableDeclarationInstruction) {
                             JetDeclaration element = ((VariableDeclarationInstruction) instruction).getVariableDeclarationElement();
-                            if (element instanceof JetProperty) {
+                            if (element instanceof JetNamedDeclaration) {
                                 PsiElement nameIdentifier = ((JetNamedDeclaration) element).getNameIdentifier();
                                 PsiElement elementToMark = nameIdentifier != null ? nameIdentifier : element;
                                 if (enterData.get(variableDescriptor) == VariableStatus.UNUSED) {
-                                    trace.report(Errors.UNUSED_VARIABLE.on((JetNamedDeclaration) element, elementToMark, variableDescriptor));
+                                    if (element instanceof JetProperty) {
+                                        trace.report(Errors.UNUSED_VARIABLE.on((JetProperty) element, elementToMark, variableDescriptor));
+                                    }
+                                    else if (element instanceof JetParameter) {
+                                        PsiElement psiElement = element.getParent().getParent();
+                                        if (psiElement instanceof JetFunction) {
+                                            boolean isMain = (psiElement instanceof JetNamedFunction) && JetMainDetector.isMain((JetNamedFunction) psiElement);
+                                            DeclarationDescriptor descriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, psiElement);
+                                            assert descriptor instanceof FunctionDescriptor;
+                                            FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
+                                            if (!isMain && !functionDescriptor.getModality().isOverridable() && functionDescriptor.getOverriddenDescriptors().isEmpty()) {
+                                                trace.report(Errors.UNUSED_PARAMETER.on((JetParameter) element, elementToMark, variableDescriptor));
+                                            }
+                                        }
+                                    }
                                 }
-                                else if (enterData.get(variableDescriptor) == VariableStatus.WRITTEN) {
+                                else if (enterData.get(variableDescriptor) == VariableStatus.WRITTEN && element instanceof JetProperty) {
                                     trace.report(Errors.ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE.on((JetNamedDeclaration) element, elementToMark, variableDescriptor));
                                 }
                             }

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java

@@ -147,8 +147,9 @@ public interface Errors {
     PsiElementOnlyDiagnosticFactory3<JetModifierListOwner, CallableMemberDescriptor, CallableMemberDescriptor, DeclarationDescriptor> VIRTUAL_MEMBER_HIDDEN = PsiElementOnlyDiagnosticFactory3.create(ERROR, "''{0}'' hides ''{1}'' in class {2} and needs 'override' modifier", DescriptorRenderer.TEXT);
 
     PsiElementOnlyDiagnosticFactory1<JetSimpleNameExpression, DeclarationDescriptor> UNINITIALIZED_VARIABLE = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Variable ''{0}'' must be initialized", NAME);
-    PsiElementOnlyDiagnosticFactory1<JetNamedDeclaration, DeclarationDescriptor> UNUSED_VARIABLE = PsiElementOnlyDiagnosticFactory1.create(WARNING, "Variable ''{0}'' is never used", NAME);
+    UnusedElementDiagnosticFactory<JetProperty, VariableDescriptor> UNUSED_VARIABLE = UnusedElementDiagnosticFactory.create(WARNING, "Variable ''{0}'' is never used", NAME);
-    PsiElementOnlyDiagnosticFactory1<JetNamedDeclaration, DeclarationDescriptor> ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE = PsiElementOnlyDiagnosticFactory1.create(WARNING, "Variable ''{0}'' is assigned but never accessed", NAME);
+    UnusedElementDiagnosticFactory<JetParameter, VariableDescriptor> UNUSED_PARAMETER = UnusedElementDiagnosticFactory.create(WARNING, "Parameter ''{0}'' is never used", NAME);
+    UnusedElementDiagnosticFactory<JetNamedDeclaration, DeclarationDescriptor> ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE = UnusedElementDiagnosticFactory.create(WARNING, "Variable ''{0}'' is assigned but never accessed", NAME);
     PsiElementOnlyDiagnosticFactory2<JetElement, JetElement, DeclarationDescriptor> UNUSED_VALUE = new PsiElementOnlyDiagnosticFactory2<JetElement, JetElement, DeclarationDescriptor>(WARNING, "The value ''{0}'' assigned to ''{1}'' is never used", NAME) {
         @Override
         protected String makeMessageForA(@NotNull JetElement element) {

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnusedElementDiagnosticFactory.java

@@ -0,0 +1,23 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.psi.PsiElement;
+/**
+ * @author svtk
+ */
+public class UnusedElementDiagnosticFactory<T extends PsiElement, A> extends PsiElementOnlyDiagnosticFactory1<T, A> {
+    public static <T extends PsiElement, A> UnusedElementDiagnosticFactory<T, A> create(Severity severity, String messageStub) {
+        return new UnusedElementDiagnosticFactory<T, A>(severity, messageStub);
+    }
+
+    public static <T extends PsiElement, A> UnusedElementDiagnosticFactory<T, A> create(Severity severity, String messageStub, Renderer renderer) {
+        return new UnusedElementDiagnosticFactory<T, A>(severity, messageStub, renderer);
+    }
+
+    public UnusedElementDiagnosticFactory(Severity severity, String message, Renderer renderer) {
+        super(severity, message, renderer);
+    }
+
+    protected UnusedElementDiagnosticFactory(Severity severity, String message) {
+        super(severity, message);
+    }
+}

compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java

@@ -5,6 +5,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.VariableAsFunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.types.JetType;
@@ -43,6 +44,9 @@ public class BindingContextUtils {
         if (descriptor instanceof VariableDescriptor) {
             return (VariableDescriptor) descriptor;
         }
+        if (descriptor instanceof VariableAsFunctionDescriptor) {
+            return ((VariableAsFunctionDescriptor) descriptor).getVariableDescriptor();
+        }
         return null;
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java

@@ -1,7 +1,6 @@
 package org.jetbrains.jet.lang.types.expressions;
 
 import com.intellij.lang.ASTNode;
-import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.*;
@@ -14,7 +13,6 @@ import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.util.lazy.ReenteringLazyValueComputationException;
 
-import static org.jetbrains.jet.lang.diagnostics.Errors.ELSE_MISPLACED_IN_WHEN;
 import static org.jetbrains.jet.lang.diagnostics.Errors.TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM;
 
 /**
@@ -22,11 +20,9 @@ import static org.jetbrains.jet.lang.diagnostics.Errors.TYPECHECKER_HAS_RUN_INTO
  */
 public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetType, ExpressionTypingContext> implements ExpressionTypingInternals {
 
-    private static ExpressionTypingVisitorDispatcher BASIC_DISPATCHER = new ExpressionTypingVisitorDispatcher(null);
-
     @NotNull
     public static ExpressionTypingFacade create() {
-        return BASIC_DISPATCHER;
+        return new ExpressionTypingVisitorDispatcher(null);
     }
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/plugin/JetMainDetector.java

@@ -17,17 +17,20 @@ public class JetMainDetector {
     public static boolean hasMain(List<JetDeclaration> declarations) {
         for (JetDeclaration declaration : declarations) {
             if (declaration instanceof JetNamedFunction) {
-                JetNamedFunction function = (JetNamedFunction) declaration;
+                if (isMain((JetNamedFunction) declaration)) return true;
-                if ("main".equals(function.getName())) {
+            }
-                    List<JetParameter> parameters = function.getValueParameters();
+        }
-                    if (parameters.size() == 1) {
+        return false;
-                        JetTypeReference reference = parameters.get(0).getTypeReference();
+    }
-                        if (reference != null && reference.getText().equals("Array<String>")) {  // TODO correct check
-                            return true;
-                        }
-                    }
-                }
 
+    public static boolean isMain(JetNamedFunction function) {
+        if ("main".equals(function.getName())) {
+            List<JetParameter> parameters = function.getValueParameters();
+            if (parameters.size() == 1) {
+                JetTypeReference reference = parameters.get(0).getTypeReference();
+                if (reference != null && reference.getText().equals("Array<String>")) {  // TODO correct check
+                    return true;
+                }
             }
         }
         return false;

compiler/testData/cfg/Basic.instructions

@@ -31,8 +31,10 @@ fun f(a : Boolean) : Unit {
 }
 ---------------------
 l0:
-    <START>             NEXT:[r(1)]                       PREV:[]
+    <START>             NEXT:[v(a : Boolean)]             PREV:[]
-    r(1)                NEXT:[r(a)]                       PREV:[<START>]
+    v(a : Boolean)      NEXT:[w(a)]                       PREV:[<START>]
+    w(a)                NEXT:[r(1)]                       PREV:[v(a : Boolean)]
+    r(1)                NEXT:[r(a)]                       PREV:[w(a)]
     r(a)                NEXT:[r(2)]                       PREV:[r(1)]
     r(2)                NEXT:[r(lng)]                     PREV:[r(a)]
     r(lng)              NEXT:[r(2.lng)]                   PREV:[r(2)]
@@ -92,14 +94,18 @@ sink:
 fun foo(a : Boolean, b : Int) : Unit {}
 ---------------------
 l0:
-    <START>        NEXT:[read (Unit)]    PREV:[]
+    <START>           NEXT:[v(a : Boolean)]    PREV:[]
-    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+    v(a : Boolean)    NEXT:[w(a)]              PREV:[<START>]
+    w(a)              NEXT:[v(b : Int)]        PREV:[v(a : Boolean)]
+    v(b : Int)        NEXT:[w(b)]              PREV:[w(a)]
+    w(b)              NEXT:[read (Unit)]       PREV:[v(b : Int)]
+    read (Unit)       NEXT:[<END>]             PREV:[w(b)]
 l1:
-    <END>          NEXT:[<SINK>]         PREV:[read (Unit)]
+    <END>             NEXT:[<SINK>]            PREV:[read (Unit)]
 error:
-    <ERROR>        NEXT:[]               PREV:[]
+    <ERROR>           NEXT:[]                  PREV:[]
 sink:
-    <SINK>         NEXT:[]               PREV:[<END>]
+    <SINK>            NEXT:[]                  PREV:[<END>]
 =====================
 == genfun ==
 fun genfun<T>() : Unit {}
@@ -118,12 +124,14 @@ sink:
 fun flfun(f : fun () : Any) : Unit {}
 ---------------------
 l0:
-    <START>        NEXT:[read (Unit)]    PREV:[]
+    <START>                NEXT:[v(f : fun () : Any)]    PREV:[]
-    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+    v(f : fun () : Any)    NEXT:[w(f)]                   PREV:[<START>]
+    w(f)                   NEXT:[read (Unit)]            PREV:[v(f : fun () : Any)]
+    read (Unit)            NEXT:[<END>]                  PREV:[w(f)]
 l1:
-    <END>          NEXT:[<SINK>]         PREV:[read (Unit)]
+    <END>                  NEXT:[<SINK>]                 PREV:[read (Unit)]
 error:
-    <ERROR>        NEXT:[]               PREV:[]
+    <ERROR>                NEXT:[]                       PREV:[]
 sink:
-    <SINK>         NEXT:[]               PREV:[<END>]
+    <SINK>                 NEXT:[]                       PREV:[<END>]
 =====================

compiler/testData/cfg/Finally.instructions

@@ -388,8 +388,10 @@ fun t8(a : Int) {
 }
 ---------------------
 l0:
-    <START>        NEXT:[r(1)]                 PREV:[]
+    <START>        NEXT:[v(a : Int)]           PREV:[]
-    r(1)           NEXT:[r(a)]                 PREV:[<START>]
+    v(a : Int)     NEXT:[w(a)]                 PREV:[<START>]
+    w(a)           NEXT:[r(1)]                 PREV:[v(a : Int)]
+    r(1)           NEXT:[r(a)]                 PREV:[w(a)]
     r(a)           NEXT:[r(..)]                PREV:[r(1)]
     r(..)          NEXT:[r(1..a)]              PREV:[r(a)]
     r(1..a)        NEXT:[v(i)]                 PREV:[r(..)]
@@ -439,8 +441,10 @@ fun t9(a : Int) {
 }
 ---------------------
 l0:
-    <START>        NEXT:[r(1)]                    PREV:[]
+    <START>        NEXT:[v(a : Int)]              PREV:[]
-    r(1)           NEXT:[r(a)]                    PREV:[<START>]
+    v(a : Int)     NEXT:[w(a)]                    PREV:[<START>]
+    w(a)           NEXT:[r(1)]                    PREV:[v(a : Int)]
+    r(1)           NEXT:[r(a)]                    PREV:[w(a)]
     r(a)           NEXT:[r(..)]                   PREV:[r(1)]
     r(..)          NEXT:[r(1..a)]                 PREV:[r(a)]
     r(1..a)        NEXT:[v(i)]                    PREV:[r(..)]
@@ -489,8 +493,10 @@ fun t10(a : Int) {
 }
 ---------------------
 l0:
-    <START>        NEXT:[r(1)]                    PREV:[]
+    <START>        NEXT:[v(a : Int)]              PREV:[]
-    r(1)           NEXT:[r(a)]                    PREV:[<START>]
+    v(a : Int)     NEXT:[w(a)]                    PREV:[<START>]
+    w(a)           NEXT:[r(1)]                    PREV:[v(a : Int)]
+    r(1)           NEXT:[r(a)]                    PREV:[w(a)]
     r(a)           NEXT:[r(..)]                   PREV:[r(1)]
     r(..)          NEXT:[r(1..a)]                 PREV:[r(a)]
     r(1..a)        NEXT:[v(i)]                    PREV:[r(..)]
@@ -747,8 +753,10 @@ fun doSmth(i: Int) {
 }
 ---------------------
 l0:
-    <START>        NEXT:[read (Unit)]    PREV:[]
+    <START>        NEXT:[v(i: Int)]      PREV:[]
-    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+    v(i: Int)      NEXT:[w(i)]           PREV:[<START>]
+    w(i)           NEXT:[read (Unit)]    PREV:[v(i: Int)]
+    read (Unit)    NEXT:[<END>]          PREV:[w(i)]
 l1:
     <END>          NEXT:[<SINK>]         PREV:[read (Unit)]
 error:

compiler/testData/cfg/For.instructions

@@ -34,8 +34,10 @@ sink:
 fun doSmth(i: Int) {}
 ---------------------
 l0:
-    <START>        NEXT:[read (Unit)]    PREV:[]
+    <START>        NEXT:[v(i: Int)]      PREV:[]
-    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+    v(i: Int)      NEXT:[w(i)]           PREV:[<START>]
+    w(i)           NEXT:[read (Unit)]    PREV:[v(i: Int)]
+    read (Unit)    NEXT:[<END>]          PREV:[w(i)]
 l1:
     <END>          NEXT:[<SINK>]         PREV:[read (Unit)]
 error:

compiler/testData/cfg/If.instructions

@@ -17,8 +17,10 @@ fun t1(b: Boolean) {
 }
 ---------------------
 l0:
-    <START>             NEXT:[v(var u: String)]       PREV:[]
+    <START>             NEXT:[v(b: Boolean)]          PREV:[]
-    v(var u: String)    NEXT:[r(b)]                   PREV:[<START>]
+    v(b: Boolean)       NEXT:[w(b)]                   PREV:[<START>]
+    w(b)                NEXT:[v(var u: String)]       PREV:[v(b: Boolean)]
+    v(var u: String)    NEXT:[r(b)]                   PREV:[w(b)]
     r(b)                NEXT:[jf(l2)]                 PREV:[v(var u: String)]
     jf(l2)              NEXT:[read (Unit), r("s")]    PREV:[r(b)]
     r("s")              NEXT:[w(u)]                   PREV:[jf(l2)]
@@ -63,45 +65,49 @@ fun t2(b: Boolean) {
 }
 ---------------------
 l0:
-    <START>         NEXT:[v(val i = 3)]           PREV:[]
+    <START>          NEXT:[v(b: Boolean)]          PREV:[]
-    v(val i = 3)    NEXT:[r(3)]                   PREV:[<START>]
+    v(b: Boolean)    NEXT:[w(b)]                   PREV:[<START>]
-    r(3)            NEXT:[w(i)]                   PREV:[v(val i = 3)]
+    w(b)             NEXT:[v(val i = 3)]           PREV:[v(b: Boolean)]
-    w(i)            NEXT:[r(b)]                   PREV:[r(3)]
+    v(val i = 3)     NEXT:[r(3)]                   PREV:[w(b)]
-    r(b)            NEXT:[jf(l2)]                 PREV:[w(i)]
+    r(3)             NEXT:[w(i)]                   PREV:[v(val i = 3)]
-    jf(l2)          NEXT:[read (Unit), ret l1]    PREV:[r(b)]
+    w(i)             NEXT:[r(b)]                   PREV:[r(3)]
-    ret l1          NEXT:[<END>]                  PREV:[jf(l2)]
+    r(b)             NEXT:[jf(l2)]                 PREV:[w(i)]
-*   jmp(l3)         NEXT:[r(i)]                   PREV:[]
+    jf(l2)           NEXT:[read (Unit), ret l1]    PREV:[r(b)]
+    ret l1           NEXT:[<END>]                  PREV:[jf(l2)]
+*   jmp(l3)          NEXT:[r(i)]                   PREV:[]
 l2:
-    read (Unit)     NEXT:[r(i)]                   PREV:[jf(l2)]
+    read (Unit)      NEXT:[r(i)]                   PREV:[jf(l2)]
 l3:
-    r(i)            NEXT:[r(doSmth)]              PREV:[read (Unit)]
+    r(i)             NEXT:[r(doSmth)]              PREV:[read (Unit)]
-    r(doSmth)       NEXT:[r(doSmth(i))]           PREV:[r(i)]
+    r(doSmth)        NEXT:[r(doSmth(i))]           PREV:[r(i)]
-    r(doSmth(i))    NEXT:[r(i)]                   PREV:[r(doSmth)]
+    r(doSmth(i))     NEXT:[r(i)]                   PREV:[r(doSmth)]
-    r(i)            NEXT:[r(i is Int)]            PREV:[r(doSmth(i))]
+    r(i)             NEXT:[r(i is Int)]            PREV:[r(doSmth(i))]
-    r(i is Int)     NEXT:[jf(l4)]                 PREV:[r(i)]
+    r(i is Int)      NEXT:[jf(l4)]                 PREV:[r(i)]
-    jf(l4)          NEXT:[read (Unit), ret l1]    PREV:[r(i is Int)]
+    jf(l4)           NEXT:[read (Unit), ret l1]    PREV:[r(i is Int)]
-    ret l1          NEXT:[<END>]                  PREV:[jf(l4)]
+    ret l1           NEXT:[<END>]                  PREV:[jf(l4)]
-*   jmp(l5)         NEXT:[<END>]                  PREV:[]
+*   jmp(l5)          NEXT:[<END>]                  PREV:[]
 l4:
-    read (Unit)     NEXT:[<END>]                  PREV:[jf(l4)]
+    read (Unit)      NEXT:[<END>]                  PREV:[jf(l4)]
 l1:
 l5:
-    <END>           NEXT:[<SINK>]                 PREV:[ret l1, ret l1, read (Unit)]
+    <END>            NEXT:[<SINK>]                 PREV:[ret l1, ret l1, read (Unit)]
 error:
-    <ERROR>         NEXT:[]                       PREV:[]
+    <ERROR>          NEXT:[]                       PREV:[]
 sink:
-    <SINK>          NEXT:[]                       PREV:[<END>]
+    <SINK>           NEXT:[]                       PREV:[<END>]
 =====================
 == doSmth ==
 fun doSmth(s: String) {}
 ---------------------
 l0:
-    <START>        NEXT:[read (Unit)]    PREV:[]
+    <START>         NEXT:[v(s: String)]    PREV:[]
-    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+    v(s: String)    NEXT:[w(s)]            PREV:[<START>]
+    w(s)            NEXT:[read (Unit)]     PREV:[v(s: String)]
+    read (Unit)     NEXT:[<END>]           PREV:[w(s)]
 l1:
-    <END>          NEXT:[<SINK>]         PREV:[read (Unit)]
+    <END>           NEXT:[<SINK>]          PREV:[read (Unit)]
 error:
-    <ERROR>        NEXT:[]               PREV:[]
+    <ERROR>         NEXT:[]                PREV:[]
 sink:
-    <SINK>         NEXT:[]               PREV:[<END>]
+    <SINK>          NEXT:[]                PREV:[<END>]
 =====================

compiler/testData/cfg/LazyBooleans.instructions

@@ -18,57 +18,61 @@ fun lazyBooleans(a : Boolean, b : Boolean) : Unit {
 }
 ---------------------
 l0:
-    <START>        NEXT:[r(a)]                  PREV:[]
+    <START>           NEXT:[v(a : Boolean)]        PREV:[]
-    r(a)           NEXT:[jf(l2)]                PREV:[<START>]
+    v(a : Boolean)    NEXT:[w(a)]                  PREV:[<START>]
-    jf(l2)         NEXT:[r(2), r(1)]            PREV:[r(a)]
+    w(a)              NEXT:[v(b : Boolean)]        PREV:[v(a : Boolean)]
-    r(1)           NEXT:[jmp(l3)]               PREV:[jf(l2)]
+    v(b : Boolean)    NEXT:[w(b)]                  PREV:[w(a)]
-    jmp(l3)        NEXT:[r(3)]                  PREV:[r(1)]
+    w(b)              NEXT:[r(a)]                  PREV:[v(b : Boolean)]
+    r(a)              NEXT:[jf(l2)]                PREV:[w(b)]
+    jf(l2)            NEXT:[r(2), r(1)]            PREV:[r(a)]
+    r(1)              NEXT:[jmp(l3)]               PREV:[jf(l2)]
+    jmp(l3)           NEXT:[r(3)]                  PREV:[r(1)]
 l2:
-    r(2)           NEXT:[r(3)]                  PREV:[jf(l2)]
+    r(2)              NEXT:[r(3)]                  PREV:[jf(l2)]
 l3:
-    r(3)           NEXT:[r(a)]                  PREV:[jmp(l3), r(2)]
+    r(3)              NEXT:[r(a)]                  PREV:[jmp(l3), r(2)]
-    r(a)           NEXT:[jf(l4)]                PREV:[r(3)]
+    r(a)              NEXT:[jf(l4)]                PREV:[r(3)]
-    jf(l4)         NEXT:[jf(l5), r(b)]          PREV:[r(a)]
+    jf(l4)            NEXT:[jf(l5), r(b)]          PREV:[r(a)]
-    r(b)           NEXT:[jf(l5)]                PREV:[jf(l4)]
+    r(b)              NEXT:[jf(l5)]                PREV:[jf(l4)]
 l4:
-    jf(l5)         NEXT:[r(6), r(5)]            PREV:[jf(l4), r(b)]
+    jf(l5)            NEXT:[r(6), r(5)]            PREV:[jf(l4), r(b)]
-    r(5)           NEXT:[jmp(l6)]               PREV:[jf(l5)]
+    r(5)              NEXT:[jmp(l6)]               PREV:[jf(l5)]
-    jmp(l6)        NEXT:[r(7)]                  PREV:[r(5)]
+    jmp(l6)           NEXT:[r(7)]                  PREV:[r(5)]
 l5:
-    r(6)           NEXT:[r(7)]                  PREV:[jf(l5)]
+    r(6)              NEXT:[r(7)]                  PREV:[jf(l5)]
 l6:
-    r(7)           NEXT:[r(a)]                  PREV:[jmp(l6), r(6)]
+    r(7)              NEXT:[r(a)]                  PREV:[jmp(l6), r(6)]
-    r(a)           NEXT:[jt(l7)]                PREV:[r(7)]
+    r(a)              NEXT:[jt(l7)]                PREV:[r(7)]
-    jt(l7)         NEXT:[r(b), jf(l8)]          PREV:[r(a)]
+    jt(l7)            NEXT:[r(b), jf(l8)]          PREV:[r(a)]
-    r(b)           NEXT:[jf(l8)]                PREV:[jt(l7)]
+    r(b)              NEXT:[jf(l8)]                PREV:[jt(l7)]
 l7:
-    jf(l8)         NEXT:[r(9), r(8)]            PREV:[jt(l7), r(b)]
+    jf(l8)            NEXT:[r(9), r(8)]            PREV:[jt(l7), r(b)]
-    r(8)           NEXT:[jmp(l9)]               PREV:[jf(l8)]
+    r(8)              NEXT:[jmp(l9)]               PREV:[jf(l8)]
-    jmp(l9)        NEXT:[r(10)]                 PREV:[r(8)]
+    jmp(l9)           NEXT:[r(10)]                 PREV:[r(8)]
 l8:
-    r(9)           NEXT:[r(10)]                 PREV:[jf(l8)]
+    r(9)              NEXT:[r(10)]                 PREV:[jf(l8)]
 l9:
-    r(10)          NEXT:[r(a)]                  PREV:[jmp(l9), r(9)]
+    r(10)             NEXT:[r(a)]                  PREV:[jmp(l9), r(9)]
-    r(a)           NEXT:[jf(l10)]               PREV:[r(10)]
+    r(a)              NEXT:[jf(l10)]               PREV:[r(10)]
-    jf(l10)        NEXT:[read (Unit), r(11)]    PREV:[r(a)]
+    jf(l10)           NEXT:[read (Unit), r(11)]    PREV:[r(a)]
-    r(11)          NEXT:[jmp(l11)]              PREV:[jf(l10)]
+    r(11)             NEXT:[jmp(l11)]              PREV:[jf(l10)]
-    jmp(l11)       NEXT:[r(12)]                 PREV:[r(11)]
+    jmp(l11)          NEXT:[r(12)]                 PREV:[r(11)]
 l10:
-    read (Unit)    NEXT:[r(12)]                 PREV:[jf(l10)]
+    read (Unit)       NEXT:[r(12)]                 PREV:[jf(l10)]
 l11:
-    r(12)          NEXT:[r(a)]                  PREV:[jmp(l11), read (Unit)]
+    r(12)             NEXT:[r(a)]                  PREV:[jmp(l11), read (Unit)]
-    r(a)           NEXT:[jf(l12)]               PREV:[r(12)]
+    r(a)              NEXT:[jf(l12)]               PREV:[r(12)]
-    jf(l12)        NEXT:[r(13), read (Unit)]    PREV:[r(a)]
+    jf(l12)           NEXT:[r(13), read (Unit)]    PREV:[r(a)]
-    read (Unit)    NEXT:[jmp(l13)]              PREV:[jf(l12)]
+    read (Unit)       NEXT:[jmp(l13)]              PREV:[jf(l12)]
-    jmp(l13)       NEXT:[r(14)]                 PREV:[read (Unit)]
+    jmp(l13)          NEXT:[r(14)]                 PREV:[read (Unit)]
 l12:
-    r(13)          NEXT:[r(14)]                 PREV:[jf(l12)]
+    r(13)             NEXT:[r(14)]                 PREV:[jf(l12)]
 l13:
-    r(14)          NEXT:[<END>]                 PREV:[jmp(l13), r(13)]
+    r(14)             NEXT:[<END>]                 PREV:[jmp(l13), r(13)]
 l1:
-    <END>          NEXT:[<SINK>]                PREV:[r(14)]
+    <END>             NEXT:[<SINK>]                PREV:[r(14)]
 error:
-    <ERROR>        NEXT:[]                      PREV:[]
+    <ERROR>           NEXT:[]                      PREV:[]
 sink:
-    <SINK>         NEXT:[]                      PREV:[<END>]
+    <SINK>            NEXT:[]                      PREV:[<END>]
 =====================

compiler/testData/cfg/LocalDeclarations.instructions

@@ -80,8 +80,10 @@ sink:
 fun doSmth(i: Int) {}
 ---------------------
 l0:
-    <START>        NEXT:[read (Unit)]    PREV:[]
+    <START>        NEXT:[v(i: Int)]      PREV:[]
-    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+    v(i: Int)      NEXT:[w(i)]           PREV:[<START>]
+    w(i)           NEXT:[read (Unit)]    PREV:[v(i: Int)]
+    read (Unit)    NEXT:[<END>]          PREV:[w(i)]
 l1:
     <END>          NEXT:[<SINK>]         PREV:[read (Unit)]
 error:

compiler/testData/checkerWithErrorTypes/quick/Abstract.jet

@@ -237,7 +237,7 @@ abstract class B3(i: Int) {
     this(): this(1)
 }
 
-fun foo(c: B3) {
+fun foo(<!UNUSED_PARAMETER!>c<!>: B3) {
     val <!UNUSED_VARIABLE!>a<!> = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B3()<!>
     val <!UNUSED_VARIABLE!>b<!> = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B1(2, "s")<!>
 }

compiler/testData/checkerWithErrorTypes/quick/AutoCreatedIt.jet

@@ -15,18 +15,18 @@ fun text() {
     bar2 <!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>it<!> => it}<!>
 }
 
-fun bar(f : fun (Int, Int) : Int) {}
+fun bar(<!UNUSED_PARAMETER!>f<!> : fun (Int, Int) : Int) {}
-fun bar1(f : fun (Int) : Int) {}
+fun bar1(<!UNUSED_PARAMETER!>f<!> : fun (Int) : Int) {}
-fun bar2(f : fun () : Int) {}
+fun bar2(<!UNUSED_PARAMETER!>f<!> : fun () : Int) {}
 
-fun String.to(dest : String) {
+fun String.to(<!UNUSED_PARAMETER!>dest<!> : String) {
 
 }
 
-fun String.on(predicate : fun (s : URI) : Boolean) : URI {
+fun String.on(<!UNUSED_PARAMETER!>predicate<!> : fun (s : URI) : Boolean) : URI {
     return URI(this)
 }
 
 class URI(val body : Any) {
-    fun to(dest : String) {}
+    fun to(<!UNUSED_PARAMETER!>dest<!> : String) {}
 }

compiler/testData/checkerWithErrorTypes/quick/AutocastsForStableIdentifiers.jet

@@ -16,7 +16,7 @@ class AClass() {
 
 val x : Any? = 1
 
-fun Any?.vars(a: Any?) : Int {
+fun Any?.vars(<!UNUSED_PARAMETER!>a<!>: Any?) : Int {
     var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>b<!>: Int = 0
     if (ns.y is Int) {
         b = <!UNUSED_VALUE!>ns.y<!>

compiler/testData/checkerWithErrorTypes/quick/Basic.jet

@@ -1,4 +1,4 @@
-fun foo(u : Unit) : Int = 1
+fun foo(<!UNUSED_PARAMETER!>u<!> : Unit) : Int = 1
 
 fun test() : Int {
     foo(<!TYPE_MISMATCH!>1<!>)

compiler/testData/checkerWithErrorTypes/quick/BinaryCallsOnNullableValues.jet

@@ -1,13 +1,13 @@
 class A() {
-  fun equals(a : Any?) : Boolean = false
+  fun equals(<!UNUSED_PARAMETER!>a<!> : Any?) : Boolean = false
 }
 
 class B() {
-  fun equals(a : Any?) : Boolean? = false
+  fun equals(<!UNUSED_PARAMETER!>a<!> : Any?) : Boolean? = false
 }
 
 class C() {
-  fun equals(a : Any?) : Int = 0
+  fun equals(<!UNUSED_PARAMETER!>a<!> : Any?) : Int = 0
 }
 
 fun f(): Unit {

compiler/testData/checkerWithErrorTypes/quick/BreakContinue.jet

@@ -1,6 +1,6 @@
 class C {
 
-    fun f (a : Boolean, b : Boolean) {
+    fun f (<!UNUSED_PARAMETER!>a<!> : Boolean, <!UNUSED_PARAMETER!>b<!> : Boolean) {
         @b (while (true)
           @a {
             <!NOT_A_LOOP_LABEL!>break@f<!>
@@ -25,7 +25,7 @@ class C {
         <!NOT_A_LOOP_LABEL!>break@f<!>
     }
 
-    fun containsBreak(a: String?, b: String?) {
+    fun containsBreak(a: String?, <!UNUSED_PARAMETER!>b<!>: String?) {
         while (a == null) {
             break;
         }

compiler/testData/checkerWithErrorTypes/quick/ConflictingOverloads.jet

@@ -1,9 +1,9 @@
 // http://youtrack.jetbrains.net/issue/KT-424
 
 class A {
-    <!CONFLICTING_OVERLOADS!>fun a(a: Int): Int<!> = 0
+    <!CONFLICTING_OVERLOADS!>fun a(<!UNUSED_PARAMETER!>a<!>: Int): Int<!> = 0
 
-    <!CONFLICTING_OVERLOADS!>fun a(a: Int)<!> {
+    <!CONFLICTING_OVERLOADS!>fun a(<!UNUSED_PARAMETER!>a<!>: Int)<!> {
     }
 
     <!CONFLICTING_OVERLOADS!>fun b()<!> {
@@ -14,17 +14,17 @@ class A {
 }
 
 namespace deepSpace {
-    <!CONFLICTING_OVERLOADS!>fun c(s: String)<!> {
+    <!CONFLICTING_OVERLOADS!>fun c(<!UNUSED_PARAMETER!>s<!>: String)<!> {
     }
 
-    <!CONFLICTING_OVERLOADS!>fun c(s: String)<!> {
+    <!CONFLICTING_OVERLOADS!>fun c(<!UNUSED_PARAMETER!>s<!>: String)<!> {
     }
 
     class B {
-        <!CONFLICTING_OVERLOADS!>fun d(s: String)<!> {
+        <!CONFLICTING_OVERLOADS!>fun d(<!UNUSED_PARAMETER!>s<!>: String)<!> {
         }
 
-        <!CONFLICTING_OVERLOADS!>fun d(s: String)<!> {
+        <!CONFLICTING_OVERLOADS!>fun d(<!UNUSED_PARAMETER!>s<!>: String)<!> {
         }
     }
 }
@@ -49,9 +49,9 @@ namespace ns3 {
 // check same rules apply for ext functions
 
 namespace extensionFunctions {
-    <!CONFLICTING_OVERLOADS!>fun Int.qwe(a: Float)<!> = 1
+    <!CONFLICTING_OVERLOADS!>fun Int.qwe(<!UNUSED_PARAMETER!>a<!>: Float)<!> = 1
     
-    <!CONFLICTING_OVERLOADS!>fun Int.qwe(a: Float)<!> = 2
+    <!CONFLICTING_OVERLOADS!>fun Int.qwe(<!UNUSED_PARAMETER!>a<!>: Float)<!> = 2
     
     fun Int.rty() = 3
     
@@ -95,4 +95,3 @@ namespace constructorVsFun {
         }
     }
 }
-

compiler/testData/checkerWithErrorTypes/quick/DefaultValuesTypechecking.jet

@@ -1,5 +1,5 @@
 val x = ""
 
-fun bar(x : Int = <!TYPE_MISMATCH!>""<!>, y : Int = <!TYPE_MISMATCH!>x<!>, z : String = <!UNRESOLVED_REFERENCE!>y<!>) {
+fun bar(<!UNUSED_PARAMETER!>x<!> : Int = <!TYPE_MISMATCH!>""<!>, <!UNUSED_PARAMETER!>y<!> : Int = <!TYPE_MISMATCH!>x<!>, <!UNUSED_PARAMETER!>z<!> : String = <!UNRESOLVED_REFERENCE!>y<!>) {
 
 }

compiler/testData/checkerWithErrorTypes/quick/ExtensionFunctions.jet

@@ -3,7 +3,7 @@
 fun Int?.optint() : Unit {}
 val Int?.optval : Unit = ()
 
-fun <T, E> T.foo(x : E, y : A) : T   {
+fun <T, E> T.foo(<!UNUSED_PARAMETER!>x<!> : E, y : A) : T   {
   y.plus(1)
   y plus 1
   y + 1.0
@@ -15,7 +15,7 @@ fun <T, E> T.foo(x : E, y : A) : T   {
 
 class A
 
-fun A.plus(a : Any) {
+fun A.plus(<!UNUSED_PARAMETER!>a<!> : Any) {
 
   1.foo()
   true.<!NONE_APPLICABLE!>foo<!>()
@@ -23,11 +23,11 @@ fun A.plus(a : Any) {
   1
 }
 
-fun A.plus(a : Int) {
+fun A.plus(<!UNUSED_PARAMETER!>a<!> : Int) {
   1
 }
 
-fun <T> T.minus(t : T) : Int = 1
+fun <T> T.minus(<!UNUSED_PARAMETER!>t<!> : T) : Int = 1
 
 fun test() {
   val <!UNUSED_VARIABLE!>y<!> = 1.abs
@@ -41,15 +41,15 @@ fun Int.foo() = this
 
 namespace null_safety {
 
-        fun parse(cmd: String): Command? { return null  }
+        fun parse(<!UNUSED_PARAMETER!>cmd<!>: String): Command? { return null  }
         class Command() {
         //  fun equals(other : Any?) : Boolean
           val foo : Int = 0
         }
 
-        fun Any.equals(other : Any?) : Boolean = true
+        fun Any.equals(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
-        fun Any?.equals1(other : Any?) : Boolean = true
+        fun Any?.equals1(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
-        fun Any.equals2(other : Any?) : Boolean = true
+        fun Any.equals2(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
 
         fun main(args: Array<String>) {
 

compiler/testData/checkerWithErrorTypes/quick/FunctionCalleeExpressions.jet

@@ -51,7 +51,7 @@ fun main(args : Array<String>) {
 
 fun f() : fun Int.() : Unit = {}
 
-fun main1(args : Array<String>) {
+fun main1() {
     1.{Int.() => 1}();
     {1}()
     {(x : Int) => x}(1)

compiler/testData/checkerWithErrorTypes/quick/GenericFunctionIsLessSpecific.jet

@@ -1,6 +1,6 @@
 // A generic funciton is always less specific than a non-generic one
-fun foo<T>(t : T) : Unit {}
+fun foo<T>(<!UNUSED_PARAMETER!>t<!> : T) : Unit {}
-fun foo(i : Int) : Int = 1
+fun foo(<!UNUSED_PARAMETER!>i<!> : Int) : Int = 1
 
 fun test() {
     foo(1) : Int

compiler/testData/checkerWithErrorTypes/quick/InferNullabilityInThenBlock.jet

@@ -1,5 +1,4 @@
-
+fun ff(<!UNUSED_PARAMETER!>a<!>: String) = 1
-fun ff(a: String) = 1
 
 fun gg() {
     val a: String? = ""
@@ -8,4 +7,3 @@ fun gg() {
         ff(a)
     }
 }
-

compiler/testData/checkerWithErrorTypes/quick/LValueAssignment.jet

@@ -7,7 +7,7 @@ open class B() {
 
 class C() : B() {
     var x = 4
-    fun foo(c: C) {
+    fun foo(<!UNUSED_PARAMETER!>c<!>: C) {
         this.x = 34
         this.b = 123
         super.b = 23
@@ -17,7 +17,7 @@ class C() : B() {
         <!VARIABLE_EXPECTED!>getInt()<!> = 12
     }
 
-    fun foo1(c: C) {
+    fun foo1(<!UNUSED_PARAMETER!>c<!>: C) {
         <!VAL_REASSIGNMENT!>super.c<!> = 34
     }
 
@@ -36,7 +36,7 @@ class D() {
     }
 }
 
-fun cannotBe(var i: Int) {
+fun cannotBe(var <!UNUSED_PARAMETER!>i<!>: Int) {
     <!UNRESOLVED_REFERENCE!>z<!> = 30;
     <!VARIABLE_EXPECTED!>()<!> = ();
 
@@ -47,18 +47,18 @@ fun cannotBe(var i: Int) {
 }
 
 fun canBe(var i: Int, val j: Int) {
-    (i: Int) = 36
+    (i: Int) = <!UNUSED_VALUE!>36<!>
-    (@label i) = 34
+    (@label i) = <!UNUSED_VALUE!>34<!>
 
-    (<!VAL_REASSIGNMENT!>j<!>: Int) = 36
+    (<!VAL_REASSIGNMENT!>j<!>: Int) = <!UNUSED_VALUE!>36<!>
-    (@label j) = 34 //repeat for j
+    (@label j) = <!UNUSED_VALUE!>34<!> //repeat for j
 
     val a = A()
     (@ a.a) = 3894
 }
 
 fun canBe2(val j: Int) {
-    (@label <!VAL_REASSIGNMENT!>j<!>) = 34
+    (@label <!VAL_REASSIGNMENT!>j<!>) = <!UNUSED_VALUE!>34<!>
 }
 
 class A() {

compiler/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet

@@ -1,7 +1,7 @@
-fun foo(a : Int = 1, b : String = "abc") {
+fun foo(<!UNUSED_PARAMETER!>a<!> : Int = 1, <!UNUSED_PARAMETER!>b<!> : String = "abc") {
 }
 
-fun bar(x : Int = 1, y : Int = 1, z : String) {
+fun bar(<!UNUSED_PARAMETER!>x<!> : Int = 1, <!UNUSED_PARAMETER!>y<!> : Int = 1, <!UNUSED_PARAMETER!>z<!> : String) {
 }
 
 fun test() {

compiler/testData/checkerWithErrorTypes/quick/ResolveOfJavaGenerics.jet

@@ -1,7 +1,7 @@
 // +JDK
 
 // Fixpoint generic in Java: Enum<T extends Enum<T>>
-fun test(a : annotation.RetentionPolicy) {
+fun test(<!UNUSED_PARAMETER!>a<!> : annotation.RetentionPolicy) {
 
 }
 
@@ -9,14 +9,14 @@ fun test() {
   java.util.Collections.emptyList()
 }
 
-fun test(a : java.lang.Comparable<Int>) {
+fun test(<!UNUSED_PARAMETER!>a<!> : java.lang.Comparable<Int>) {
 
 }
 
-fun test(a : java.util.ArrayList<Int>) {
+fun test(<!UNUSED_PARAMETER!>a<!> : java.util.ArrayList<Int>) {
 
 }
 
-fun test(a : java.lang.Class<Int>) {
+fun test(<!UNUSED_PARAMETER!>a<!> : java.lang.Class<Int>) {
 
 }

compiler/testData/checkerWithErrorTypes/quick/ResolveToJava.jet

@@ -9,7 +9,7 @@ import java.lang.Comparable as Com
 
 val l : List<in Int> = ArrayList<Int>()
 
-fun test(l : java.util.List<Int>) {
+fun test(<!UNUSED_PARAMETER!>l<!> : java.util.List<Int>) {
   val <!UNUSED_VARIABLE!>x<!> : java.<!UNRESOLVED_REFERENCE!>List<!>
   val <!UNUSED_VARIABLE!>y<!> : java.util.List<Int>
   val <!UNUSED_VARIABLE!>b<!> : java.lang.Object

compiler/testData/checkerWithErrorTypes/quick/Super.jet

@@ -1,6 +1,6 @@
 namespace example;
 
-fun any(a : Any) {}
+fun any(<!UNUSED_PARAMETER!>a<!> : Any) {}
 
 fun notAnExpression() {
     any(<!SUPER_IS_NOT_AN_EXPRESSION!>super<!>) // not an expression

compiler/testData/checkerWithErrorTypes/quick/TypeInference.jet

@@ -2,7 +2,7 @@ class C<T>() {
   fun foo() : T <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
 }
 
-fun foo(c: C<Int>) {}
+fun foo(<!UNUSED_PARAMETER!>c<!>: C<Int>) {}
 fun bar<T>() : C<T> <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
 
 fun main(args : Array<String>) {

compiler/testData/checkerWithErrorTypes/quick/UninitializedOrReassignedVariables.jet

@@ -1,7 +1,7 @@
 namespace uninitialized_reassigned_variables
 
-fun doSmth(s: String) {}
+fun doSmth(<!UNUSED_PARAMETER!>s<!>: String) {}
-fun doSmth(i: Int) {}
+fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {}
 
 // ------------------------------------------------
 // uninitialized variables
@@ -54,9 +54,9 @@ fun t2() {
 class A() {}
 
 fun t4(a: A, val b: A, var c: A) {
-    <!VAL_REASSIGNMENT!>a<!> = A()
+    <!VAL_REASSIGNMENT!>a<!> = <!UNUSED_VALUE!>A()<!>
-    <!VAL_REASSIGNMENT!>b<!> = A()
+    <!VAL_REASSIGNMENT!>b<!> = <!UNUSED_VALUE!>A()<!>
-    c = A()
+    c = <!UNUSED_VALUE!>A()<!>
 }
 
 // ------------------------------------------------
@@ -191,7 +191,7 @@ class AnonymousInitializers(var a: String, val b: String) {
 }
 
 fun reassignFunParams(val a: Int) {
-    <!VAL_REASSIGNMENT!>a<!> = 1
+    <!VAL_REASSIGNMENT!>a<!> = <!UNUSED_VALUE!>1<!>
 }
 
 open class Open(a: Int, w: Int) {}

compiler/testData/checkerWithErrorTypes/quick/UnreachableCode.jet

@@ -47,7 +47,7 @@ fun t3() : Any {
   <!UNREACHABLE_CODE!>1<!>
 }
 
-fun t4(a : Boolean) : Int {
+fun t4(<!UNUSED_PARAMETER!>a<!> : Boolean) : Int {
   do {
     return 1
   }
@@ -55,7 +55,7 @@ fun t4(a : Boolean) : Int {
   <!UNREACHABLE_CODE!>1<!>
 }
 
-fun t4break(a : Boolean) : Int {
+fun t4break(<!UNUSED_PARAMETER!>a<!> : Boolean) : Int {
   do {
     break
   }
@@ -162,7 +162,7 @@ fun nullIsNotNothing() : Unit {
     fail()
 }
 
-fun returnInWhile(a: Int) {
+fun returnInWhile(<!UNUSED_PARAMETER!>a<!>: Int) {
     do {return}
     while (<!UNREACHABLE_CODE!>1 > a<!>)
 }

compiler/testData/checkerWithErrorTypes/quick/Unresolved.jet

@@ -28,4 +28,4 @@ fun testUnresolved() {
     }
 }
 
-fun foo1(i: Int) {}
+fun foo1(<!UNUSED_PARAMETER!>i<!>: Int) {}

compiler/testData/checkerWithErrorTypes/quick/UnusedVariables.jet

@@ -86,8 +86,8 @@ class MyTest() {
         }
     }
 
-    fun doSmth(s: String) {}
+    fun doSmth(<!UNUSED_PARAMETER!>s<!>: String) {}
-    fun doSmth(a: Any) {}
+    fun doSmth(<!UNUSED_PARAMETER!>a<!>: Any) {}
 }
 
 fun testInnerFunctions() {
@@ -139,4 +139,4 @@ fun testBackingFieldsNotMarked() {
     }
 }
 
-fun doSmth(i : Int) {}
+fun doSmth(<!UNUSED_PARAMETER!>i<!> : Int) {}

compiler/testData/checkerWithErrorTypes/quick/Varargs.jet

@@ -1,5 +1,5 @@
-fun v(x : Int, y : String, vararg f : Long) {}
+fun v(<!UNUSED_PARAMETER!>x<!> : Int, <!UNUSED_PARAMETER!>y<!> : String, vararg <!UNUSED_PARAMETER!>f<!> : Long) {}
-fun v1(vararg f : fun (Int) : Unit) {}
+fun v1(vararg <!UNUSED_PARAMETER!>f<!> : fun (Int) : Unit) {}
 
 fun test() {
     v(1, "")

compiler/testData/checkerWithErrorTypes/quick/Variance.jet

@@ -19,17 +19,17 @@ fun foo(c: Consumer<Int>, p: Producer<Int>, u: Usual<Int>) {
 
 //Arrays copy example
 class Array<T>(val length : Int, val t : T) {
-    fun get(index : Int) : T { return t }
+    fun get(<!UNUSED_PARAMETER!>index<!> : Int) : T { return t }
-    fun set(index : Int, value : T) { /* ... */ }
+    fun set(<!UNUSED_PARAMETER!>index<!> : Int, <!UNUSED_PARAMETER!>value<!> : T) { /* ... */ }
 }
 
-fun copy1(from : Array<Any>, to : Array<Any>) {}
+fun copy1(<!UNUSED_PARAMETER!>from<!> : Array<Any>, <!UNUSED_PARAMETER!>to<!> : Array<Any>) {}
 
-fun copy2(from : Array<out Any>, to : Array<in Any>) {}
+fun copy2(<!UNUSED_PARAMETER!>from<!> : Array<out Any>, <!UNUSED_PARAMETER!>to<!> : Array<in Any>) {}
 
-fun <T> copy3(from : Array<out T>, to : Array<in T>) {}
+fun <T> copy3(<!UNUSED_PARAMETER!>from<!> : Array<out T>, <!UNUSED_PARAMETER!>to<!> : Array<in T>) {}
 
-fun copy4(from : Array<out Number>, to : Array<in Int>) {}
+fun copy4(<!UNUSED_PARAMETER!>from<!> : Array<out Number>, <!UNUSED_PARAMETER!>to<!> : Array<in Int>) {}
 
 fun f(ints: Array<Int>, any: Array<Any>, numbers: Array<Number>) {
     copy1(<!TYPE_MISMATCH!>ints<!>, any)

compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/InfixCallNullability.jet

@@ -1,11 +1,11 @@
 class A() {
-  fun plus(i : Int) {}
+  fun plus(<!UNUSED_PARAMETER!>i<!> : Int) {}
   fun minus() {}
-   fun contains(a : Any?) : Boolean = true
+   fun contains(<!UNUSED_PARAMETER!>a<!> : Any?) : Boolean = true
 }
 
-fun A.div(i : Int) {}
+fun A.div(<!UNUSED_PARAMETER!>i<!> : Int) {}
-fun A?.times(i : Int) {}
+fun A?.times(<!UNUSED_PARAMETER!>i<!> : Int) {}
 
 fun test(x : Int?, a : A?) {
     x<!UNSAFE_CALL!>.<!>plus(1)

compiler/testData/checkerWithErrorTypes/quick/regressions/AmbiguityOnLazyTypeComputation.jet

@@ -7,6 +7,6 @@ val b : Foo = Foo()
 val a1 = b.compareTo(2)
 
 class Foo() {
-  fun compareTo(other : Byte)   : Int = 0
+  fun compareTo(<!UNUSED_PARAMETER!>other<!> : Byte)   : Int = 0
-  fun compareTo(other : Char)   : Int = 0
+  fun compareTo(<!UNUSED_PARAMETER!>other<!> : Char)   : Int = 0
 }

compiler/testData/checkerWithErrorTypes/quick/regressions/CoercionToUnit.jet

@@ -1,4 +1,4 @@
-fun foo(u : Unit) : Int = 1
+fun foo(<!UNUSED_PARAMETER!>u<!> : Unit) : Int = 1
 
 fun test() : Int {
     foo(<!TYPE_MISMATCH!>1<!>)

compiler/testData/checkerWithErrorTypes/quick/regressions/ErrorsOnIbjectExpressionsAsParameters.jet

@@ -1,4 +1,4 @@
-fun foo(a : Any) {}
+fun foo(<!UNUSED_PARAMETER!>a<!> : Any) {}
 
 fun test() {
   foo(object {});

compiler/testData/checkerWithErrorTypes/quick/regressions/Jet124.jet

@@ -1,8 +1,8 @@
 fun foo1() : fun (Int) : Int = { (x: Int) => x }
 
 fun foo() {
-  val <!UNUSED_VARIABLE!>h<!> : fun (Int) : Int = foo1();
+  val h : fun (Int) : Int = foo1();
   h(1)
-  val <!UNUSED_VARIABLE!>m<!> : fun (Int) : Int = {(a : Int) => 1}//foo1()
+  val m : fun (Int) : Int = {(a : Int) => 1}//foo1()
   m(1)
 }

compiler/testData/checkerWithErrorTypes/quick/regressions/Jet169.jet

@@ -1,4 +1,4 @@
-fun set(key : String, value : String) {
+fun set(<!UNUSED_PARAMETER!>key<!> : String, <!UNUSED_PARAMETER!>value<!> : String) {
   val a : String? = ""
   when (a) {
     "" => a<!UNSAFE_CALL!>.<!>get(0)

compiler/testData/checkerWithErrorTypes/quick/regressions/Jet69.jet

@@ -1,6 +1,6 @@
 class Command() {}
 
-fun parse(cmd: String): Command? { return null  }
+fun parse(<!UNUSED_PARAMETER!>cmd<!>: String): Command? { return null  }
 
 fun Any.equals(other : Any?) : Boolean = this === other
 

compiler/testData/checkerWithErrorTypes/quick/regressions/OutProjections.jet

@@ -3,7 +3,7 @@ class Point() {
 
 class G<T>() {}
 
-fun f<T>(expression : T) : G<out T> = G<T>
+fun f<T>(<!UNUSED_PARAMETER!>expression<!> : T) : G<out T> = G<T>
 
 
 fun foo() : G<Point> {
@@ -13,7 +13,7 @@ fun foo() : G<Point> {
 
 class Out<out T>() {}
 
-fun fout<T>(expression : T) : Out<out T> = Out<T>
+fun fout<T>(<!UNUSED_PARAMETER!>expression<!> : T) : Out<out T> = Out<T>
 
 fun fooout() : Out<Point> {
   val p = Point();

compiler/testData/checkerWithErrorTypes/quick/regressions/ScopeForSecondaryConstructors.jet

@@ -8,7 +8,7 @@ class Foo(var bar : Int, var barr : Int, var barrr : Int) {
     }
 
     this(var bar : Int) : this(1, 1, 1) {
-      bar = 1
+      bar = <!UNUSED_VALUE!>1<!>
       this.bar
       1 : Int
       val <!UNUSED_VARIABLE!>a<!> : Int =1

compiler/testData/checkerWithErrorTypes/quick/regressions/SpecififcityByReceiver.jet

@@ -1,4 +1,4 @@
-fun Any.equals(other : Any?) : Boolean = true
+fun Any.equals(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
 
 fun main(args: Array<String>) {
 

compiler/testData/checkerWithErrorTypes/quick/regressions/WrongTraceInCallResolver.jet

@@ -1,8 +1,8 @@
 open class Foo {}
 open class Bar {}
 
-fun <T : Bar, T1> foo(x : Int) {}
+fun <T : Bar, T1> foo(<!UNUSED_PARAMETER!>x<!> : Int) {}
-fun <T1, T : Foo> foo(x : Long) {}
+fun <T1, T : Foo> foo(<!UNUSED_PARAMETER!>x<!> : Long) {}
 
 fun f(): Unit {
     foo<<!UPPER_BOUND_VIOLATED!>Int<!>, Int>(1)

compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt609.jet

@@ -0,0 +1,19 @@
+//KT-609 Analyze not only local variables, but function parameters as well in 'unused values' analysis
+
+namespace kt609
+
+fun test(var a: Int) {
+    a = <!UNUSED_VALUE!>324<!> //should be an 'unused value' warning here
+}
+
+class C() {
+    fun foo(<!UNUSED_PARAMETER!>s<!>: String) {}  //should be an 'unused variable' warning
+}
+
+open class A() {
+    open fun foo(s : String) {}  //should not be a warning
+}
+
+class B() : A() {
+    final override fun foo(s : String) {}  //should not be a warning
+}

compiler/testData/checkerWithErrorTypes/quick/regressions/kt127.jet

@@ -2,8 +2,8 @@
 
 class Foo() {}
 
-fun Any.equals(other : Any?) : Boolean = true
+fun Any.equals(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
-fun Any?.equals1(other : Any?) : Boolean = true
+fun Any?.equals1(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
 
 fun main(args: Array<String>) {
 

compiler/testData/checkerWithErrorTypes/quick/regressions/kt128.jet

@@ -1,6 +1,6 @@
 // KT-128 Support passing only the last closure if all the other parameters have default values
 
-fun div(c : String = "", f : fun()) {}
+fun div(<!UNUSED_PARAMETER!>c<!> : String = "", <!UNUSED_PARAMETER!>f<!> : fun()) {}
 fun f() {
     div { // Nothing passed, but could have been...
       // ...

compiler/testData/checkerWithErrorTypes/quick/regressions/kt235.jet

@@ -36,13 +36,13 @@ fun main(args: Array<String>) {
 }
 
 class MyArray() {
-    fun get(i: Int): Int = 1
+    fun get(<!UNUSED_PARAMETER!>i<!>: Int): Int = 1
-    fun set(i: Int, value: Int): Int = 1
+    fun set(<!UNUSED_PARAMETER!>i<!>: Int, <!UNUSED_PARAMETER!>value<!>: Int): Int = 1
 }
 
 class MyArray1() {
-    fun get(i: Int): Int = 1
+    fun get(<!UNUSED_PARAMETER!>i<!>: Int): Int = 1
-    fun set(i: Int, value: Int) {}
+    fun set(<!UNUSED_PARAMETER!>i<!>: Int, <!UNUSED_PARAMETER!>value<!>: Int) {}
 }
 
 class MyNumber() {

compiler/testData/checkerWithErrorTypes/quick/regressions/kt258.jet

@@ -8,4 +8,4 @@ fun test() {
   attributes["href"] = "1" // inference fails, but it shouldn't
 }
 
-fun <K, V> java.util.Map<K, V>.set(key : K, value : V) {}//= this.put(key, value)
+fun <K, V> java.util.Map<K, V>.set(<!UNUSED_PARAMETER!>key<!> : K, <!UNUSED_PARAMETER!>value<!> : V) {}//= this.put(key, value)

compiler/testData/checkerWithErrorTypes/quick/regressions/kt282.jet

@@ -1,12 +1,12 @@
 // KT-282 Nullability in extension functions and in binary calls
 
 class Set {
-    fun contains(x : Int) : Boolean = true
+    fun contains(<!UNUSED_PARAMETER!>x<!> : Int) : Boolean = true
 }
 
-fun Set?.plus(x : Int) : Int = 1
+fun Set?.plus(<!UNUSED_PARAMETER!>x<!> : Int) : Int = 1
 
-fun Int?.contains(x : Int) : Boolean = false
+fun Int?.contains(<!UNUSED_PARAMETER!>x<!> : Int) : Boolean = false
 
 fun f(): Unit {
     var set : Set? = null

compiler/testData/checkerWithErrorTypes/quick/regressions/kt287.jet

@@ -6,7 +6,7 @@ import java.util.*
 fun attributes() : Map<String, String> = HashMap() // Should be inferred;
 val attributes : Map<String, String> = HashMap() // Should be inferred;
 
-fun foo(m : Map<String, String>) {}
+fun foo(<!UNUSED_PARAMETER!>m<!> : Map<String, String>) {}
 
 fun test() {
     foo(HashMap())

compiler/testData/checkerWithErrorTypes/quick/regressions/kt335.336.jet

@@ -9,7 +9,7 @@ fun <T : java.lang.Comparable<T>> List<T>.sort() {
   Collections.sort(this) // Error here
 }
 
-fun <T> List<T>.plus(other : List<T>) : List<T> {
+fun <T> List<T>.plus(<!UNUSED_PARAMETER!>other<!> : List<T>) : List<T> {
   val result = ArrayList(this)
   return result
 }

compiler/testData/checkerWithErrorTypes/quick/regressions/kt352.jet

@@ -18,7 +18,7 @@ val g : fun() : Unit = <!TYPE_MISMATCH!>{ (): Int => 42 }<!>
 val h : fun() : Unit = { doSmth() }
 
 fun doSmth(): Int = 42
-fun doSmth(a: String) {}
+fun doSmth(<!UNUSED_PARAMETER!>a<!>: String) {}
 
 val testIt : fun(Any) : Unit = {
     if (it is String) {

compiler/testData/checkerWithErrorTypes/quick/regressions/kt399.jet

@@ -1,6 +1,6 @@
 // KT-399 Type argument inference not implemented for CALL_EXPRESSION
 
-fun <T> getSameTypeChecker(obj: T) : Function1<Any,Boolean> {
+fun <T> getSameTypeChecker(<!UNUSED_PARAMETER!>obj<!>: T) : Function1<Any,Boolean> {
     return { (a : Any) => a is T }
 }
 

compiler/testData/checkerWithErrorTypes/quick/regressions/kt411.jet

@@ -9,7 +9,7 @@ fun f() {
     }
     )
 }
-fun invoker(gen : fun() : Int) : Int  = 0
+fun invoker(<!UNUSED_PARAMETER!>gen<!> : fun() : Int) : Int  = 0
 
 //more tests
 fun t1() {

compiler/testData/checkerWithErrorTypes/quick/regressions/kt439.jet

@@ -2,6 +2,6 @@
 
 inline fun run1<T>(body : fun() : T) : T = body()
 
-fun main1(args : Array<String>) {
+fun main1(<!UNUSED_PARAMETER!>args<!> : Array<String>) {
     run1 @l{ 1 } // should not be an error
 }

compiler/testData/checkerWithErrorTypes/quick/regressions/kt442.jet

@@ -6,7 +6,7 @@ fun testFunny() {
     val <!UNUSED_VARIABLE!>a<!> : Int = funny {1}
 }
 
-fun <T> funny2(f : fun(t : T) : T) : T <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
+fun <T> funny2(<!UNUSED_PARAMETER!>f<!> : fun(t : T) : T) : T <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
 
 fun testFunny2() {
     val <!UNUSED_VARIABLE!>a<!> : Int = funny2 {it}

compiler/testData/checkerWithErrorTypes/quick/regressions/kt455.jet

@@ -7,4 +7,4 @@ fun foo() {
     doSmth(<!UNINITIALIZED_VARIABLE!>a<!>)   //error
     doSmth(a)   //no repeat error
 }
-fun doSmth(i: Int) {}
+fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {}

compiler/testData/checkerWithErrorTypes/quick/regressions/kt459.jet

@@ -6,4 +6,4 @@ fun test() {
   attributes["href"] = "1" // inference fails, but it shouldn't
 }
 
-fun <K, V> java.util.Map<K, V>.set(key : K, value : V) {}//= this.put(key, value)
+fun <K, V> java.util.Map<K, V>.set(<!UNUSED_PARAMETER!>key<!> : K, <!UNUSED_PARAMETER!>value<!> : V) {}//= this.put(key, value)

compiler/testData/checkerWithErrorTypes/quick/regressions/kt58.jet

@@ -88,5 +88,5 @@ fun t7() : Int {
     }
 }
 
-fun doSmth(i: Int) {
+fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {
 }

compiler/testData/checkerWithErrorTypes/quick/regressions/kt618.jet

@@ -1,19 +1,19 @@
 namespace lol
 
 class B() {
-    fun plusAssign(other : B) : String {
+    fun plusAssign(<!UNUSED_PARAMETER!>other<!> : B) : String {
         return "s"
     }
-    fun minusAssign(other : B) : String {
+    fun minusAssign(<!UNUSED_PARAMETER!>other<!> : B) : String {
         return "s"
     }
-    fun modAssign(other : B) : String {
+    fun modAssign(<!UNUSED_PARAMETER!>other<!> : B) : String {
         return "s"
     }
-    fun divAssign(other : B) : String {
+    fun divAssign(<!UNUSED_PARAMETER!>other<!> : B) : String {
         return "s"
     }
-    fun timesAssign(other : B) : String {
+    fun timesAssign(<!UNUSED_PARAMETER!>other<!> : B) : String {
         return "s"
     }
 }

compiler/testData/checkerWithErrorTypes/quick/regressions/kt629.jet

@@ -4,7 +4,7 @@ namespace kt629
 
 class A() {
     var p = "yeah"
-    fun mod(other : A) : A {
+    fun mod(<!UNUSED_PARAMETER!>other<!> : A) : A {
         return A();
     }
 }

compiler/testData/checkerWithErrorTypes/quick/shadowing/ShadowParameterInFunctionBody.jet

@@ -1,5 +1,4 @@
-
+fun f(<!UNUSED_PARAMETER!>p<!>: Int): Int {
-fun f(p: Int): Int {
     val <!NAME_SHADOWING!>p<!> = 2
     return p
 }

compiler/testData/checkerWithErrorTypes/quick/shadowing/ShadowParameterInNestedBlockInFor.jet

@@ -1,4 +1,4 @@
-fun f(i: Int) {
+fun f(<!UNUSED_PARAMETER!>i<!>: Int) {
     for (j in 1..100) {
         {
             var <!NAME_SHADOWING!>i<!> = 12

compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java

@@ -39,7 +39,7 @@ public class CheckerTestUtilTest extends JetLiteFixture {
         doTest(new TheTest("Missing TYPE_MISMATCH at 56 to 57") {
             @Override
             protected void makeTestData(List<Diagnostic> diagnostics, List<CheckerTestUtil.DiagnosedRange> diagnosedRanges) {
-                diagnostics.remove(0);
+                diagnostics.remove(1);
             }
         });
     }
@@ -48,7 +48,7 @@ public class CheckerTestUtilTest extends JetLiteFixture {
         doTest(new TheTest("Unexpected TYPE_MISMATCH at 56 to 57") {
             @Override
             protected void makeTestData(List<Diagnostic> diagnostics, List<CheckerTestUtil.DiagnosedRange> diagnosedRanges) {
-                diagnosedRanges.remove(0);
+                diagnosedRanges.remove(1);
             }
         });
     }
@@ -57,7 +57,7 @@ public class CheckerTestUtilTest extends JetLiteFixture {
         doTest(new TheTest("Unexpected TYPE_MISMATCH at 56 to 57", "Missing UNRESOLVED_REFERENCE at 166 to 168") {
             @Override
             protected void makeTestData(List<Diagnostic> diagnostics, List<CheckerTestUtil.DiagnosedRange> diagnosedRanges) {
-                diagnosedRanges.remove(0);
+                diagnosedRanges.remove(1);
                 diagnostics.remove(diagnostics.size() - 1);
             }
         });
@@ -67,7 +67,7 @@ public class CheckerTestUtilTest extends JetLiteFixture {
         doTest(new TheTest("Unexpected NONE_APPLICABLE at 122 to 123", "Missing TYPE_MISMATCH at 161 to 169") {
             @Override
             protected void makeTestData(List<Diagnostic> diagnostics, List<CheckerTestUtil.DiagnosedRange> diagnosedRanges) {
-                diagnosedRanges.remove(3);
+                diagnosedRanges.remove(4);
                 diagnostics.remove(diagnostics.size() - 3);
             }
         });

idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java

@@ -88,7 +88,7 @@ public class JetPsiChecker implements Annotator {
                         }
                         else if (diagnostic.getSeverity() == Severity.WARNING) {
                             annotation = holder.createWarningAnnotation(diagnostic.getFactory().getTextRange(diagnostic), getMessage(diagnostic));
-                            if (diagnostic.getFactory() == Errors.UNUSED_VARIABLE || diagnostic.getFactory() == Errors.ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE) {
+                            if (diagnostic.getFactory() instanceof UnusedElementDiagnosticFactory) {
                                 annotation.setHighlightType(ProblemHighlightType.LIKE_UNUSED_SYMBOL);
                             }
                         }

idea/testData/checker/Abstract.jet

@@ -160,7 +160,7 @@ abstract class B3(i: Int) {
     this(): this(1)
 }
 
-fun foo(a: B3) {
+fun foo(<warning>a</warning>: B3) {
     val <warning>a</warning> = <error>B3()</error>
     val <warning>b</warning> = <error>B1(2, "s")</error>
 }

idea/testData/checker/BinaryCallsOnNullableValues.jet

@@ -1,13 +1,13 @@
 class A() {
-  fun equals(a : Any?) : Boolean = false
+  fun equals(<warning>a</warning> : Any?) : Boolean = false
 }
 
 class B() {
-  fun equals(a : Any?) : Boolean? = false
+  fun equals(<warning>a</warning> : Any?) : Boolean? = false
 }
 
 class C() {
-  fun equals(a : Any?) : Int = 0
+  fun equals(<warning>a</warning> : Any?) : Int = 0
 }
 
 fun f(): Unit {

idea/testData/checker/BreakContinue.jet

@@ -1,6 +1,6 @@
 class C {
 
-    fun f (a : Boolean, b : Boolean) {
+    fun f (<warning>a</warning> : Boolean, <warning>b</warning> : Boolean) {
         @b (while (true)
           @a {
             <error>break@f</error>

idea/testData/checker/ExtensionFunctions.jet

@@ -1,7 +1,7 @@
 fun Int?.optint() : Unit {}
 val Int?.optval : Unit = ()
 
-fun <T, E> T.foo(x : E, y : A) : T   {
+fun <T, E> T.foo(<warning>x</warning> : E, y : A) : T   {
   y.plus(1)
   y plus 1
   y + 1.0
@@ -13,7 +13,7 @@ fun <T, E> T.foo(x : E, y : A) : T   {
 
 class A
 
-fun A.plus(a : Any) {
+fun A.plus(<warning>a</warning> : Any) {
 
   1.foo()
   true.<error>foo</error>()
@@ -21,11 +21,11 @@ fun A.plus(a : Any) {
   1
 }
 
-fun A.plus(a : Int) {
+fun A.plus(<warning>a</warning> : Int) {
   1
 }
 
-fun <T> T.minus(t : T) : Int = 1
+fun <T> T.minus(<warning>t</warning> : T) : Int = 1
 
 fun test() {
   val <warning>y</warning> = 1.abs
@@ -39,15 +39,15 @@ fun Int.foo() = this
 
 namespace null_safety {
 
-        fun parse(cmd: String): Command? { return null  }
+        fun parse(<warning>cmd</warning>: String): Command? { return null  }
         class Command() {
         //  fun equals(other : Any?) : Boolean
           val foo : Int = 0
         }
 
-        fun Any.equals(other : Any?) : Boolean = true
+        fun Any.equals(<warning>other</warning> : Any?) : Boolean = true
-        fun Any?.equals1(other : Any?) : Boolean = true
+        fun Any?.equals1(<warning>other</warning> : Any?) : Boolean = true
-        fun Any.equals2(other : Any?) : Boolean = true
+        fun Any.equals2(<warning>other</warning> : Any?) : Boolean = true
 
         fun main(args: Array<String>) {
 

idea/testData/checker/ResolveToJava.jet

@@ -7,7 +7,7 @@ import java.lang.Comparable as Com
 
 val l : List<in Int> = ArrayList<Int>()
 
-fun test(l : java.util.List<Int>) {
+fun test(<warning>l</warning> : java.util.List<Int>) {
   val <warning>x</warning> : java.<error>List</error>
   val <warning>y</warning> : java.util.List<Int>
   val <warning>b</warning> : java.lang.Object

idea/testData/checker/UnreachableCode.jet

@@ -45,7 +45,7 @@ fun t3() : Any {
   <error>1</error>
 }
 
-fun t4(a : Boolean) : Int {
+fun t4(<warning>a</warning> : Boolean) : Int {
   do {
     return 1
   }
@@ -53,7 +53,7 @@ fun t4(a : Boolean) : Int {
   <error>1</error>
 }
 
-fun t4break(a : Boolean) : Int {
+fun t4break(<warning>a</warning> : Boolean) : Int {
   do {
     break
   }

idea/testData/checker/Unresolved.jet

@@ -28,4 +28,4 @@ fun testUnresolved() {
     }
 }
 
-fun foo1(i: Int) {}
+fun foo1(<warning>i</warning>: Int) {}

idea/testData/checker/Variance.jet

@@ -19,17 +19,17 @@ fun foo(c: Consumer<Int>, p: Producer<Int>, u: Usual<Int>) {
 
 //Arrays copy example
 class Array<T>(val length : Int, val t : T) {
-    fun get(index : Int) : T { return t }
+    fun get(<warning>index</warning> : Int) : T { return t }
-    fun set(index : Int, value : T) { /* ... */ }
+    fun set(<warning>index</warning> : Int, <warning>value</warning> : T) { /* ... */ }
 }
 
-fun copy1(from : Array<Any>, to : Array<Any>) {}
+fun copy1(<warning>from</warning> : Array<Any>, <warning>to</warning> : Array<Any>) {}
 
-fun copy2(from : Array<out Any>, to : Array<in Any>) {}
+fun copy2(<warning>from</warning> : Array<out Any>, <warning>to</warning> : Array<in Any>) {}
 
-fun <T> copy3(from : Array<out T>, to : Array<in T>) {}
+fun <T> copy3(<warning>from</warning> : Array<out T>, <warning>to</warning> : Array<in T>) {}
 
-fun copy4(from : Array<out Number>, to : Array<in Int>) {}
+fun copy4(<warning>from</warning> : Array<out Number>, <warning>to</warning> : Array<in Int>) {}
 
 fun f(ints: Array<Int>, any: Array<Any>, numbers: Array<Number>) {
     copy1(<error>ints</error>, any)

idea/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet

@@ -7,6 +7,6 @@ val b : Foo = Foo()
 val a1 = b.compareTo(2)
 
 class Foo() {
-  fun compareTo(other : Byte)   : Int = 0
+  fun compareTo(<warning>other</warning> : Byte)   : Int = 0
-  fun compareTo(other : Char)   : Int = 0
+  fun compareTo(<warning>other</warning> : Char)   : Int = 0
 }

idea/testData/checker/regression/CoercionToUnit.jet

@@ -1,4 +1,4 @@
-fun foo(u : Unit) : Int = 1
+fun foo(<warning>u</warning> : Unit) : Int = 1
 
 fun test() : Int {
     foo(<error>1</error>)

idea/testData/checker/regression/Jet124.jet

@@ -1,8 +1,8 @@
 fun foo1() : fun (Int) : Int = { (x: Int) => x }
 
 fun foo() {
-  val <warning>h</warning> : fun (Int) : Int = foo1();
+  val h : fun (Int) : Int = foo1();
   h(1)
-  val <warning>m</warning> : fun (Int) : Int = {(a : Int) => 1}//foo1()
+  val m : fun (Int) : Int = {(a : Int) => 1}//foo1()
   m(1)
 }

idea/testData/checker/regression/Jet169.jet

@@ -1,4 +1,4 @@
-fun set(key : String, value : String) {
+fun set(<warning>key</warning> : String, <warning>value</warning> : String) {
   val a : String? = ""
   when (a) {
     "" => a<error>.</error>get(0)

idea/testData/checker/regression/Jet69.jet

@@ -1,6 +1,6 @@
 class Command() {}
 
-fun parse(cmd: String): Command? { return null  }
+fun parse(<warning>cmd</warning>: String): Command? { return null  }
 
 fun Any.equals(other : Any?) : Boolean = this === other
 

idea/testData/checker/regression/ScopeForSecondaryConstructors.jet

@@ -8,7 +8,7 @@
     }
 
     this(var bar : Int) : this(1, 1, 1) {
-      bar = 1
+      bar = <warning>1</warning>
       this.bar
       1 : Int
       val <warning>a</warning> : Int =1

idea/testData/checker/regression/SpecififcityByReceiver.jet

@@ -1,4 +1,4 @@
-fun Any.equals(other : Any?) : Boolean = true
+fun Any.equals(<warning>other</warning> : Any?) : Boolean = true
 
 fun main(args: Array<String>) {
 

idea/testData/checker/regression/WrongTraceInCallResolver.jet

@@ -1,8 +1,8 @@
 open class Foo {}
 open class Bar {}
 
-fun <T : Bar, T1> foo(x : Int) {}
+fun <T : Bar, T1> foo(<warning>x</warning> : Int) {}
-fun <T1, T : Foo> foo(x : Long) {}
+fun <T1, T : Foo> foo(<warning>x</warning> : Long) {}
 
 fun f(): Unit {
     foo<<error>Int</error>, Int>(1)