diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
index f5bc5122eda..7b1945f9351 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
+++ b/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) {
-        generateSubroutineControlFlow(subroutineElement, Collections.singletonList(body));
-    }
-
-    public void generateSubroutineControlFlow(@NotNull JetDeclaration subroutineElement, @NotNull List<? extends JetElement> body) {
-        builder.enterSubroutine(subroutineElement);
-        for (JetElement statement : body) {
-            statement.accept(new CFPVisitor(false));
+    public void generate(@NotNull JetDeclaration subroutine) {
+        builder.enterSubroutine(subroutine);
+        if (subroutine instanceof JetDeclarationWithBody) {
+            JetDeclarationWithBody declarationWithBody = (JetDeclarationWithBody) subroutine;
+            CFPVisitor cfpVisitor = new CFPVisitor(false);
+            List<JetParameter> valueParameters = declarationWithBody.getValueParameters();
+            for (JetParameter valueParameter : valueParameters) {
+                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) {
-        processLocalDeclaration(subroutineElement, Collections.singletonList(body));
-    }
-
-    private void processLocalDeclaration(@NotNull JetDeclaration subroutineElement, @NotNull List<? extends JetElement> body) {
+    private void processLocalDeclaration(@NotNull JetDeclaration subroutine) {
         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();
-            if (bodyExpression != null) {
-                processLocalDeclaration(function, bodyExpression);
-            }
+            processLocalDeclaration(function);
         }
 
         @Override
         public void visitFunctionLiteralExpression(JetFunctionLiteralExpression expression) {
             JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
-            JetBlockExpression bodyExpression = functionLiteral.getBodyExpression();
-            if (bodyExpression != null) {
-                List<JetElement> statements = bodyExpression.getStatements();
-                processLocalDeclaration(functionLiteral, statements);
-            }
+            processLocalDeclaration(functionLiteral);
             builder.read(expression);
         }
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
index 7b8f6fc2b0b..4c260399c57 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
+++ b/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));
                                 }
                             }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
index fc8ce9013f2..786acc783b2 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
+++ b/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);
-    PsiElementOnlyDiagnosticFactory1<JetNamedDeclaration, DeclarationDescriptor> ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE = PsiElementOnlyDiagnosticFactory1.create(WARNING, "Variable ''{0}'' is assigned but never accessed", NAME);
+    UnusedElementDiagnosticFactory<JetProperty, VariableDescriptor> UNUSED_VARIABLE = UnusedElementDiagnosticFactory.create(WARNING, "Variable ''{0}'' is never used", 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) {
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnusedElementDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnusedElementDiagnosticFactory.java
new file mode 100644
index 00000000000..d47ea66728f
--- /dev/null
+++ b/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);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java
index 4b24227c3cd..9635f3edafe 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java
+++ b/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;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java
index bdd82e73b85..36db4c054db 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java
+++ b/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
diff --git a/compiler/frontend/src/org/jetbrains/jet/plugin/JetMainDetector.java b/compiler/frontend/src/org/jetbrains/jet/plugin/JetMainDetector.java
index ec98c2d8eff..9e9d285bd23 100644
--- a/compiler/frontend/src/org/jetbrains/jet/plugin/JetMainDetector.java
+++ b/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 ("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;
-                        }
-                    }
-                }
+                if (isMain((JetNamedFunction) declaration)) return true;
+            }
+        }
+        return false;
+    }
 
+    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;
diff --git a/compiler/testData/cfg/Basic.instructions b/compiler/testData/cfg/Basic.instructions
index e199fb184fe..970f555349b 100644
--- a/compiler/testData/cfg/Basic.instructions
+++ b/compiler/testData/cfg/Basic.instructions
@@ -31,8 +31,10 @@ fun f(a : Boolean) : Unit {
 }
 ---------------------
 l0:
-    <START>             NEXT:[r(1)]                       PREV:[]
-    r(1)                NEXT:[r(a)]                       PREV:[<START>]
+    <START>             NEXT:[v(a : Boolean)]             PREV:[]
+    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:[]
-    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+    <START>           NEXT:[v(a : Boolean)]    PREV:[]
+    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:[]
-    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+    <START>                NEXT:[v(f : fun () : Any)]    PREV:[]
+    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>]
 =====================
diff --git a/compiler/testData/cfg/Finally.instructions b/compiler/testData/cfg/Finally.instructions
index b8c3f5fdf29..74f7c7177c4 100644
--- a/compiler/testData/cfg/Finally.instructions
+++ b/compiler/testData/cfg/Finally.instructions
@@ -388,8 +388,10 @@ fun t8(a : Int) {
 }
 ---------------------
 l0:
-    <START>        NEXT:[r(1)]                 PREV:[]
-    r(1)           NEXT:[r(a)]                 PREV:[<START>]
+    <START>        NEXT:[v(a : Int)]           PREV:[]
+    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:[]
-    r(1)           NEXT:[r(a)]                    PREV:[<START>]
+    <START>        NEXT:[v(a : Int)]              PREV:[]
+    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:[]
-    r(1)           NEXT:[r(a)]                    PREV:[<START>]
+    <START>        NEXT:[v(a : Int)]              PREV:[]
+    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:[]
-    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+    <START>        NEXT:[v(i: Int)]      PREV:[]
+    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:
diff --git a/compiler/testData/cfg/For.instructions b/compiler/testData/cfg/For.instructions
index 7b782c13b55..6a8ceb0d916 100644
--- a/compiler/testData/cfg/For.instructions
+++ b/compiler/testData/cfg/For.instructions
@@ -34,8 +34,10 @@ sink:
 fun doSmth(i: Int) {}
 ---------------------
 l0:
-    <START>        NEXT:[read (Unit)]    PREV:[]
-    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+    <START>        NEXT:[v(i: Int)]      PREV:[]
+    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:
diff --git a/compiler/testData/cfg/If.instructions b/compiler/testData/cfg/If.instructions
index b188c60a1a4..5d3c31f3bc1 100644
--- a/compiler/testData/cfg/If.instructions
+++ b/compiler/testData/cfg/If.instructions
@@ -17,8 +17,10 @@ fun t1(b: Boolean) {
 }
 ---------------------
 l0:
-    <START>             NEXT:[v(var u: String)]       PREV:[]
-    v(var u: String)    NEXT:[r(b)]                   PREV:[<START>]
+    <START>             NEXT:[v(b: Boolean)]          PREV:[]
+    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:[]
-    v(val i = 3)    NEXT:[r(3)]                   PREV:[<START>]
-    r(3)            NEXT:[w(i)]                   PREV:[v(val i = 3)]
-    w(i)            NEXT:[r(b)]                   PREV:[r(3)]
-    r(b)            NEXT:[jf(l2)]                 PREV:[w(i)]
-    jf(l2)          NEXT:[read (Unit), ret l1]    PREV:[r(b)]
-    ret l1          NEXT:[<END>]                  PREV:[jf(l2)]
-*   jmp(l3)         NEXT:[r(i)]                   PREV:[]
+    <START>          NEXT:[v(b: Boolean)]          PREV:[]
+    v(b: Boolean)    NEXT:[w(b)]                   PREV:[<START>]
+    w(b)             NEXT:[v(val i = 3)]           PREV:[v(b: Boolean)]
+    v(val i = 3)     NEXT:[r(3)]                   PREV:[w(b)]
+    r(3)             NEXT:[w(i)]                   PREV:[v(val i = 3)]
+    w(i)             NEXT:[r(b)]                   PREV:[r(3)]
+    r(b)             NEXT:[jf(l2)]                 PREV:[w(i)]
+    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(doSmth)       NEXT:[r(doSmth(i))]           PREV:[r(i)]
-    r(doSmth(i))    NEXT:[r(i)]                   PREV:[r(doSmth)]
-    r(i)            NEXT:[r(i is Int)]            PREV:[r(doSmth(i))]
-    r(i is Int)     NEXT:[jf(l4)]                 PREV:[r(i)]
-    jf(l4)          NEXT:[read (Unit), ret l1]    PREV:[r(i is Int)]
-    ret l1          NEXT:[<END>]                  PREV:[jf(l4)]
-*   jmp(l5)         NEXT:[<END>]                  PREV:[]
+    r(i)             NEXT:[r(doSmth)]              PREV:[read (Unit)]
+    r(doSmth)        NEXT:[r(doSmth(i))]           PREV:[r(i)]
+    r(doSmth(i))     NEXT:[r(i)]                   PREV:[r(doSmth)]
+    r(i)             NEXT:[r(i is Int)]            PREV:[r(doSmth(i))]
+    r(i is Int)      NEXT:[jf(l4)]                 PREV:[r(i)]
+    jf(l4)           NEXT:[read (Unit), ret l1]    PREV:[r(i is Int)]
+    ret l1           NEXT:[<END>]                  PREV:[jf(l4)]
+*   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:[]
-    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+    <START>         NEXT:[v(s: String)]    PREV:[]
+    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>]
 =====================
diff --git a/compiler/testData/cfg/LazyBooleans.instructions b/compiler/testData/cfg/LazyBooleans.instructions
index 080a7519745..f204026d0a0 100644
--- a/compiler/testData/cfg/LazyBooleans.instructions
+++ b/compiler/testData/cfg/LazyBooleans.instructions
@@ -18,57 +18,61 @@ fun lazyBooleans(a : Boolean, b : Boolean) : Unit {
 }
 ---------------------
 l0:
-    <START>        NEXT:[r(a)]                  PREV:[]
-    r(a)           NEXT:[jf(l2)]                PREV:[<START>]
-    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)]
+    <START>           NEXT:[v(a : Boolean)]        PREV:[]
+    v(a : Boolean)    NEXT:[w(a)]                  PREV:[<START>]
+    w(a)              NEXT:[v(b : Boolean)]        PREV:[v(a : Boolean)]
+    v(b : Boolean)    NEXT:[w(b)]                  PREV:[w(a)]
+    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(a)           NEXT:[jf(l4)]                PREV:[r(3)]
-    jf(l4)         NEXT:[jf(l5), r(b)]          PREV:[r(a)]
-    r(b)           NEXT:[jf(l5)]                PREV:[jf(l4)]
+    r(3)              NEXT:[r(a)]                  PREV:[jmp(l3), r(2)]
+    r(a)              NEXT:[jf(l4)]                PREV:[r(3)]
+    jf(l4)            NEXT:[jf(l5), r(b)]          PREV:[r(a)]
+    r(b)              NEXT:[jf(l5)]                PREV:[jf(l4)]
 l4:
-    jf(l5)         NEXT:[r(6), r(5)]            PREV:[jf(l4), r(b)]
-    r(5)           NEXT:[jmp(l6)]               PREV:[jf(l5)]
-    jmp(l6)        NEXT:[r(7)]                  PREV:[r(5)]
+    jf(l5)            NEXT:[r(6), r(5)]            PREV:[jf(l4), r(b)]
+    r(5)              NEXT:[jmp(l6)]               PREV:[jf(l5)]
+    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(a)           NEXT:[jt(l7)]                PREV:[r(7)]
-    jt(l7)         NEXT:[r(b), jf(l8)]          PREV:[r(a)]
-    r(b)           NEXT:[jf(l8)]                PREV:[jt(l7)]
+    r(7)              NEXT:[r(a)]                  PREV:[jmp(l6), r(6)]
+    r(a)              NEXT:[jt(l7)]                PREV:[r(7)]
+    jt(l7)            NEXT:[r(b), jf(l8)]          PREV:[r(a)]
+    r(b)              NEXT:[jf(l8)]                PREV:[jt(l7)]
 l7:
-    jf(l8)         NEXT:[r(9), r(8)]            PREV:[jt(l7), r(b)]
-    r(8)           NEXT:[jmp(l9)]               PREV:[jf(l8)]
-    jmp(l9)        NEXT:[r(10)]                 PREV:[r(8)]
+    jf(l8)            NEXT:[r(9), r(8)]            PREV:[jt(l7), r(b)]
+    r(8)              NEXT:[jmp(l9)]               PREV:[jf(l8)]
+    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(a)           NEXT:[jf(l10)]               PREV:[r(10)]
-    jf(l10)        NEXT:[read (Unit), r(11)]    PREV:[r(a)]
-    r(11)          NEXT:[jmp(l11)]              PREV:[jf(l10)]
-    jmp(l11)       NEXT:[r(12)]                 PREV:[r(11)]
+    r(10)             NEXT:[r(a)]                  PREV:[jmp(l9), r(9)]
+    r(a)              NEXT:[jf(l10)]               PREV:[r(10)]
+    jf(l10)           NEXT:[read (Unit), r(11)]    PREV:[r(a)]
+    r(11)             NEXT:[jmp(l11)]              PREV:[jf(l10)]
+    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(a)           NEXT:[jf(l12)]               PREV:[r(12)]
-    jf(l12)        NEXT:[r(13), read (Unit)]    PREV:[r(a)]
-    read (Unit)    NEXT:[jmp(l13)]              PREV:[jf(l12)]
-    jmp(l13)       NEXT:[r(14)]                 PREV:[read (Unit)]
+    r(12)             NEXT:[r(a)]                  PREV:[jmp(l11), read (Unit)]
+    r(a)              NEXT:[jf(l12)]               PREV:[r(12)]
+    jf(l12)           NEXT:[r(13), read (Unit)]    PREV:[r(a)]
+    read (Unit)       NEXT:[jmp(l13)]              PREV:[jf(l12)]
+    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>]
 =====================
diff --git a/compiler/testData/cfg/LocalDeclarations.instructions b/compiler/testData/cfg/LocalDeclarations.instructions
index 94fabadf512..179ed5fe1d7 100644
--- a/compiler/testData/cfg/LocalDeclarations.instructions
+++ b/compiler/testData/cfg/LocalDeclarations.instructions
@@ -80,8 +80,10 @@ sink:
 fun doSmth(i: Int) {}
 ---------------------
 l0:
-    <START>        NEXT:[read (Unit)]    PREV:[]
-    read (Unit)    NEXT:[<END>]          PREV:[<START>]
+    <START>        NEXT:[v(i: Int)]      PREV:[]
+    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:
diff --git a/compiler/testData/checkerWithErrorTypes/quick/Abstract.jet b/compiler/testData/checkerWithErrorTypes/quick/Abstract.jet
index a13891668c6..d36e7769f63 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/Abstract.jet
+++ b/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")<!>
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/AutoCreatedIt.jet b/compiler/testData/checkerWithErrorTypes/quick/AutoCreatedIt.jet
index ef474b07d54..b9aa7b90c6b 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/AutoCreatedIt.jet
+++ b/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 bar1(f : fun (Int) : Int) {}
-fun bar2(f : fun () : Int) {}
+fun bar(<!UNUSED_PARAMETER!>f<!> : fun (Int, Int) : Int) {}
+fun bar1(<!UNUSED_PARAMETER!>f<!> : fun (Int) : 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) {}
 }
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/AutocastsForStableIdentifiers.jet b/compiler/testData/checkerWithErrorTypes/quick/AutocastsForStableIdentifiers.jet
index c46164e8c73..f6ccdfc8a0a 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/AutocastsForStableIdentifiers.jet
+++ b/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<!>
@@ -88,4 +88,4 @@ open class C {
           t = <!UNUSED_VALUE!>this@C<!>
        }
     }
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/Basic.jet b/compiler/testData/checkerWithErrorTypes/quick/Basic.jet
index 82775571c83..4dc3161b26a 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/Basic.jet
+++ b/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<!>)
diff --git a/compiler/testData/checkerWithErrorTypes/quick/BinaryCallsOnNullableValues.jet b/compiler/testData/checkerWithErrorTypes/quick/BinaryCallsOnNullableValues.jet
index 5394c137aae..f32efe534f1 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/BinaryCallsOnNullableValues.jet
+++ b/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 {
diff --git a/compiler/testData/checkerWithErrorTypes/quick/BreakContinue.jet b/compiler/testData/checkerWithErrorTypes/quick/BreakContinue.jet
index 1cecda9dae9..4502e880282 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/BreakContinue.jet
+++ b/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;
         }
diff --git a/compiler/testData/checkerWithErrorTypes/quick/ConflictingOverloads.jet b/compiler/testData/checkerWithErrorTypes/quick/ConflictingOverloads.jet
index b1055124354..6f13050d3ae 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/ConflictingOverloads.jet
+++ b/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
     
@@ -94,5 +94,4 @@ namespace constructorVsFun {
             class ololo() { }
         }
     }
-}
-
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/DefaultValuesTypechecking.jet b/compiler/testData/checkerWithErrorTypes/quick/DefaultValuesTypechecking.jet
index 55df425bc64..67d360888da 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/DefaultValuesTypechecking.jet
+++ b/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<!>) {
 
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/ExtensionFunctions.jet b/compiler/testData/checkerWithErrorTypes/quick/ExtensionFunctions.jet
index 245be61e735..e7e3c1cebf4 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/ExtensionFunctions.jet
+++ b/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?.equals1(other : Any?) : Boolean = true
-        fun Any.equals2(other : Any?) : Boolean = true
+        fun Any.equals(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
+        fun Any?.equals1(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
+        fun Any.equals2(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
 
         fun main(args: Array<String>) {
 
@@ -70,4 +70,4 @@ namespace null_safety {
             if (command == null) 1
         }
 
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/FunctionCalleeExpressions.jet b/compiler/testData/checkerWithErrorTypes/quick/FunctionCalleeExpressions.jet
index 15acd8ec22c..5e6ef793f1d 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/FunctionCalleeExpressions.jet
+++ b/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)
diff --git a/compiler/testData/checkerWithErrorTypes/quick/GenericFunctionIsLessSpecific.jet b/compiler/testData/checkerWithErrorTypes/quick/GenericFunctionIsLessSpecific.jet
index 308a3cd08c0..868937e8397 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/GenericFunctionIsLessSpecific.jet
+++ b/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(i : Int) : Int = 1
+fun foo<T>(<!UNUSED_PARAMETER!>t<!> : T) : Unit {}
+fun foo(<!UNUSED_PARAMETER!>i<!> : Int) : Int = 1
 
 fun test() {
     foo(1) : Int
diff --git a/compiler/testData/checkerWithErrorTypes/quick/InferNullabilityInThenBlock.jet b/compiler/testData/checkerWithErrorTypes/quick/InferNullabilityInThenBlock.jet
index 4925867c8c6..17a21679c79 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/InferNullabilityInThenBlock.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/InferNullabilityInThenBlock.jet
@@ -1,5 +1,4 @@
-
-fun ff(a: String) = 1
+fun ff(<!UNUSED_PARAMETER!>a<!>: String) = 1
 
 fun gg() {
     val a: String? = ""
@@ -7,5 +6,4 @@ fun gg() {
     if (a != null) {
         ff(a)
     }
-}
-
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/LValueAssignment.jet b/compiler/testData/checkerWithErrorTypes/quick/LValueAssignment.jet
index fd3796e1ffd..e9551afa2fd 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/LValueAssignment.jet
+++ b/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
-    (@label i) = 34
+    (i: Int) = <!UNUSED_VALUE!>36<!>
+    (@label i) = <!UNUSED_VALUE!>34<!>
 
-    (<!VAL_REASSIGNMENT!>j<!>: Int) = 36
-    (@label j) = 34 //repeat for j
+    (<!VAL_REASSIGNMENT!>j<!>: Int) = <!UNUSED_VALUE!>36<!>
+    (@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() {
@@ -140,4 +140,4 @@ fun Array<Int>.checkThis() {
 
 abstract class Ab {
     abstract fun getArray() : Array<Int>
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet b/compiler/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet
index f1d42c6b60d..8f9476575d4 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet
+++ b/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() {
diff --git a/compiler/testData/checkerWithErrorTypes/quick/ResolveOfJavaGenerics.jet b/compiler/testData/checkerWithErrorTypes/quick/ResolveOfJavaGenerics.jet
index 2353e215293..ae44ace8caf 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/ResolveOfJavaGenerics.jet
+++ b/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>) {
 
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/ResolveToJava.jet b/compiler/testData/checkerWithErrorTypes/quick/ResolveToJava.jet
index d404b2365ba..ff4d34b1cf7 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/ResolveToJava.jet
+++ b/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
@@ -51,4 +51,4 @@ fun test(l : java.util.List<Int>) {
 
 namespace xxx {
   import java.lang.Class;
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/Super.jet b/compiler/testData/checkerWithErrorTypes/quick/Super.jet
index 7a3095d820f..ca3fff3dc9e 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/Super.jet
+++ b/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
diff --git a/compiler/testData/checkerWithErrorTypes/quick/TypeInference.jet b/compiler/testData/checkerWithErrorTypes/quick/TypeInference.jet
index 5f35e4d98a5..4dd8649fff0 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/TypeInference.jet
+++ b/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>) {
diff --git a/compiler/testData/checkerWithErrorTypes/quick/UninitializedOrReassignedVariables.jet b/compiler/testData/checkerWithErrorTypes/quick/UninitializedOrReassignedVariables.jet
index f1bbe6de43b..593d34b02c4 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/UninitializedOrReassignedVariables.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/UninitializedOrReassignedVariables.jet
@@ -1,7 +1,7 @@
 namespace uninitialized_reassigned_variables
 
-fun doSmth(s: String) {}
-fun doSmth(i: Int) {}
+fun doSmth(<!UNUSED_PARAMETER!>s<!>: String) {}
+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!>b<!> = A()
-    c = A()
+    <!VAL_REASSIGNMENT!>a<!> = <!UNUSED_VALUE!>A()<!>
+    <!VAL_REASSIGNMENT!>b<!> = <!UNUSED_VALUE!>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) {}
diff --git a/compiler/testData/checkerWithErrorTypes/quick/UnreachableCode.jet b/compiler/testData/checkerWithErrorTypes/quick/UnreachableCode.jet
index 36bfd0e8925..088bba18e54 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/UnreachableCode.jet
+++ b/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<!>)
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/Unresolved.jet b/compiler/testData/checkerWithErrorTypes/quick/Unresolved.jet
index a13dae7809b..b5b6018377d 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/Unresolved.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/Unresolved.jet
@@ -28,4 +28,4 @@ fun testUnresolved() {
     }
 }
 
-fun foo1(i: Int) {}
\ No newline at end of file
+fun foo1(<!UNUSED_PARAMETER!>i<!>: Int) {}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/UnusedVariables.jet b/compiler/testData/checkerWithErrorTypes/quick/UnusedVariables.jet
index dd23f8a97d6..060ad3f83a4 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/UnusedVariables.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/UnusedVariables.jet
@@ -86,8 +86,8 @@ class MyTest() {
         }
     }
 
-    fun doSmth(s: String) {}
-    fun doSmth(a: Any) {}
+    fun doSmth(<!UNUSED_PARAMETER!>s<!>: String) {}
+    fun doSmth(<!UNUSED_PARAMETER!>a<!>: Any) {}
 }
 
 fun testInnerFunctions() {
@@ -139,4 +139,4 @@ fun testBackingFieldsNotMarked() {
     }
 }
 
-fun doSmth(i : Int) {}
+fun doSmth(<!UNUSED_PARAMETER!>i<!> : Int) {}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/Varargs.jet b/compiler/testData/checkerWithErrorTypes/quick/Varargs.jet
index 7904791df5a..5986ce0982d 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/Varargs.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/Varargs.jet
@@ -1,5 +1,5 @@
-fun v(x : Int, y : String, vararg f : Long) {}
-fun v1(vararg f : fun (Int) : Unit) {}
+fun v(<!UNUSED_PARAMETER!>x<!> : Int, <!UNUSED_PARAMETER!>y<!> : String, vararg <!UNUSED_PARAMETER!>f<!> : Long) {}
+fun v1(vararg <!UNUSED_PARAMETER!>f<!> : fun (Int) : Unit) {}
 
 fun test() {
     v(1, "")
@@ -14,4 +14,4 @@ fun test() {
     v1({}, {}, {it})
     v1({}) <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
     v1 <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/Variance.jet b/compiler/testData/checkerWithErrorTypes/quick/Variance.jet
index 1306c251f00..8785dfd87cb 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/Variance.jet
+++ b/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 set(index : Int, value : T) { /* ... */ }
+    fun get(<!UNUSED_PARAMETER!>index<!> : Int) : T { return 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)
diff --git a/compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/InfixCallNullability.jet b/compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/InfixCallNullability.jet
index d27f6834a73..e1eb592bc2e 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/InfixCallNullability.jet
+++ b/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?.times(i : Int) {}
+fun A.div(<!UNUSED_PARAMETER!>i<!> : Int) {}
+fun A?.times(<!UNUSED_PARAMETER!>i<!> : Int) {}
 
 fun test(x : Int?, a : A?) {
     x<!UNSAFE_CALL!>.<!>plus(1)
@@ -38,4 +38,4 @@ fun test(x : Int?, a : A?) {
     a <!UNSAFE_INFIX_CALL!>contains<!> 1
     a<!UNSAFE_CALL!>.<!>contains(1)
     a?.contains(1)
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/AmbiguityOnLazyTypeComputation.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/AmbiguityOnLazyTypeComputation.jet
index 779ee4c4d97..cdced141c6a 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/AmbiguityOnLazyTypeComputation.jet
+++ b/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(other : Char)   : Int = 0
-}
+  fun compareTo(<!UNUSED_PARAMETER!>other<!> : Byte)   : Int = 0
+  fun compareTo(<!UNUSED_PARAMETER!>other<!> : Char)   : Int = 0
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/CoercionToUnit.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/CoercionToUnit.jet
index 6ce84f8c66b..765036145b7 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/CoercionToUnit.jet
+++ b/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<!>)
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/ErrorsOnIbjectExpressionsAsParameters.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/ErrorsOnIbjectExpressionsAsParameters.jet
index 75432316689..e5c2de37d80 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/ErrorsOnIbjectExpressionsAsParameters.jet
+++ b/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 {});
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet124.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet124.jet
index 58e876a80f2..317b1438f41 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet124.jet
+++ b/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)
 }
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet169.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet169.jet
index 000536ce340..c0196a2543d 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet169.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet169.jet
@@ -1,8 +1,8 @@
-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)
     is String, is Any => a.compareTo("")
     else => a.toString()
   }
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet69.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet69.jet
index dd198aa0f61..9e8c5fa83dd 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet69.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet69.jet
@@ -1,10 +1,10 @@
 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
 
 fun main(args: Array<String>) {
     val command = parse("")
     if (command == null) 1 // error on this line, but must be OK
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/OutProjections.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/OutProjections.jet
index f6c32d8f776..224e6decd93 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/OutProjections.jet
+++ b/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();
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/ScopeForSecondaryConstructors.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/ScopeForSecondaryConstructors.jet
index 31212378979..ae4bc37dabe 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/ScopeForSecondaryConstructors.jet
+++ b/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
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/SpecififcityByReceiver.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/SpecififcityByReceiver.jet
index bbca53527c8..e0ea1063e56 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/SpecififcityByReceiver.jet
+++ b/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>) {
 
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/WrongTraceInCallResolver.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/WrongTraceInCallResolver.jet
index 952ac6c3dbe..c81f9324b71 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/WrongTraceInCallResolver.jet
+++ b/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 <T1, T : Foo> foo(x : Long) {}
+fun <T : Bar, T1> foo(<!UNUSED_PARAMETER!>x<!> : Int) {}
+fun <T1, T : Foo> foo(<!UNUSED_PARAMETER!>x<!> : Long) {}
 
 fun f(): Unit {
     foo<<!UPPER_BOUND_VIOLATED!>Int<!>, Int>(1)
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt510.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt510.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/quick/regressions/kt510.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt510.jet
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt607.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt607.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/quick/regressions/kt607.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt607.jet
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt609.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt609.jet
new file mode 100644
index 00000000000..56f75e247e2
--- /dev/null
+++ b/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
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt610.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt610.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/quick/regressions/kt610.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt610.jet
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt127.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt127.jet
index 19ad92b2d52..edb6f1b6d7f 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt127.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt127.jet
@@ -2,8 +2,8 @@
 
 class Foo() {}
 
-fun Any.equals(other : Any?) : Boolean = true
-fun Any?.equals1(other : Any?) : Boolean = true
+fun Any.equals(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
+fun Any?.equals1(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
 
 fun main(args: Array<String>) {
 
@@ -15,4 +15,4 @@ fun main(args: Array<String>) {
     //   ?.equals(null) => 1 // same here
     // }
     command.equals(null)
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt128.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt128.jet
index efc005cf183..ca9b223cd02 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt128.jet
+++ b/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...
       // ...
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt235.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt235.jet
index c5a96d7c961..0f0c33183a5 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt235.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt235.jet
@@ -36,15 +36,15 @@ fun main(args: Array<String>) {
 }
 
 class MyArray() {
-    fun get(i: Int): Int = 1
-    fun set(i: Int, value: Int): Int = 1
+    fun get(<!UNUSED_PARAMETER!>i<!>: Int): Int = 1
+    fun set(<!UNUSED_PARAMETER!>i<!>: Int, <!UNUSED_PARAMETER!>value<!>: Int): Int = 1
 }
 
 class MyArray1() {
-    fun get(i: Int): Int = 1
-    fun set(i: Int, value: Int) {}
+    fun get(<!UNUSED_PARAMETER!>i<!>: Int): Int = 1
+    fun set(<!UNUSED_PARAMETER!>i<!>: Int, <!UNUSED_PARAMETER!>value<!>: Int) {}
 }
 
 class MyNumber() {
     fun inc(): MyNumber = MyNumber()
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt258.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt258.jet
index 00b7e9696d4..eb77de9e665 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt258.jet
+++ b/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)
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt282.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt282.jet
index bd6d55ce380..b9c3a16196d 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt282.jet
+++ b/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
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt287.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt287.jet
index 69d2d526fb0..15cf0100499 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt287.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt287.jet
@@ -6,8 +6,8 @@ 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())
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt335.336.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt335.336.jet
index e874d8f005d..a9007627a23 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt335.336.jet
+++ b/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
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt352.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt352.jet
index e9b4eb34e94..74f9ddecdb0 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt352.jet
+++ b/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) {
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt399.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt399.jet
index 9fd7e71c393..3c52df4cc6e 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt399.jet
+++ b/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 }
 }
 
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt411.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt411.jet
index 5d724d405da..0828b9a4efd 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt411.jet
+++ b/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() {
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt439.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt439.jet
index a914cc023c5..176e3280e18 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt439.jet
+++ b/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
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt442.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt442.jet
index 79390466a35..0618918b14a 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt442.jet
+++ b/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}
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt455.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt455.jet
index d8d20b06265..0db1c1c4ae9 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt455.jet
+++ b/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) {}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt459.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt459.jet
index faa62212f38..930e9e76670 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt459.jet
+++ b/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)
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt58.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt58.jet
index 57562a61f37..d6a0e64456f 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt58.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt58.jet
@@ -88,5 +88,5 @@ fun t7() : Int {
     }
 }
 
-fun doSmth(i: Int) {
-}
+fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt618.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt618.jet
index 569d286c17b..f70f921730e 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt618.jet
+++ b/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"
     }
 }
@@ -25,4 +25,4 @@ fun main(args : Array<String>) {
     <!TYPE_MISMATCH!>c /= B()<!>
     <!TYPE_MISMATCH!>c -= B()<!>
     <!TYPE_MISMATCH!>c %= B()<!>
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt629.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt629.jet
index f9a92abc839..3d52542ad7f 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt629.jet
+++ b/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();
     }
 }
diff --git a/compiler/testData/checkerWithErrorTypes/quick/shadowing/ShadowParameterInFunctionBody.jet b/compiler/testData/checkerWithErrorTypes/quick/shadowing/ShadowParameterInFunctionBody.jet
index 3f99c1e45bb..943e005359e 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/shadowing/ShadowParameterInFunctionBody.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/shadowing/ShadowParameterInFunctionBody.jet
@@ -1,5 +1,4 @@
-
-fun f(p: Int): Int {
+fun f(<!UNUSED_PARAMETER!>p<!>: Int): Int {
     val <!NAME_SHADOWING!>p<!> = 2
     return p
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/quick/shadowing/ShadowParameterInNestedBlockInFor.jet b/compiler/testData/checkerWithErrorTypes/quick/shadowing/ShadowParameterInNestedBlockInFor.jet
index e3e91fbe857..303434c77a1 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/shadowing/ShadowParameterInNestedBlockInFor.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/shadowing/ShadowParameterInNestedBlockInFor.jet
@@ -1,7 +1,7 @@
-fun f(i: Int) {
+fun f(<!UNUSED_PARAMETER!>i<!>: Int) {
     for (j in 1..100) {
         {
             var <!NAME_SHADOWING!>i<!> = 12
         }
     }
-}
+}
\ No newline at end of file
diff --git a/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java b/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java
index cdf385d3158..13258e0d505 100644
--- a/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java
+++ b/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);
             }
         });
diff --git a/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java b/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java
index 5dfb0bd94e4..cb7e36c4a98 100644
--- a/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java
+++ b/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);
                             }
                         }
diff --git a/idea/testData/checker/Abstract.jet b/idea/testData/checker/Abstract.jet
index 4c34620c5e5..b9ad43da2c2 100644
--- a/idea/testData/checker/Abstract.jet
+++ b/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>
 }
\ No newline at end of file
diff --git a/idea/testData/checker/BinaryCallsOnNullableValues.jet b/idea/testData/checker/BinaryCallsOnNullableValues.jet
index a66c709b010..31186881eea 100644
--- a/idea/testData/checker/BinaryCallsOnNullableValues.jet
+++ b/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 {
diff --git a/idea/testData/checker/BreakContinue.jet b/idea/testData/checker/BreakContinue.jet
index de5243502d8..f7e34060980 100644
--- a/idea/testData/checker/BreakContinue.jet
+++ b/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>
diff --git a/idea/testData/checker/ExtensionFunctions.jet b/idea/testData/checker/ExtensionFunctions.jet
index 3fd3dcffbfb..4076cdfff62 100644
--- a/idea/testData/checker/ExtensionFunctions.jet
+++ b/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?.equals1(other : Any?) : Boolean = true
-        fun Any.equals2(other : Any?) : Boolean = true
+        fun Any.equals(<warning>other</warning> : Any?) : Boolean = true
+        fun Any?.equals1(<warning>other</warning> : Any?) : Boolean = true
+        fun Any.equals2(<warning>other</warning> : Any?) : Boolean = true
 
         fun main(args: Array<String>) {
 
diff --git a/idea/testData/checker/ResolveToJava.jet b/idea/testData/checker/ResolveToJava.jet
index 17eafa7b2d8..e8cb67fceb3 100644
--- a/idea/testData/checker/ResolveToJava.jet
+++ b/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
diff --git a/idea/testData/checker/UnreachableCode.jet b/idea/testData/checker/UnreachableCode.jet
index 15ba14178fc..3fdd4ffe9df 100644
--- a/idea/testData/checker/UnreachableCode.jet
+++ b/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
   }
diff --git a/idea/testData/checker/Unresolved.jet b/idea/testData/checker/Unresolved.jet
index 159fe931f0b..a4b85b6b54a 100644
--- a/idea/testData/checker/Unresolved.jet
+++ b/idea/testData/checker/Unresolved.jet
@@ -28,4 +28,4 @@ fun testUnresolved() {
     }
 }
 
-fun foo1(i: Int) {}
+fun foo1(<warning>i</warning>: Int) {}
diff --git a/idea/testData/checker/Variance.jet b/idea/testData/checker/Variance.jet
index da4384f88bb..756214a3145 100644
--- a/idea/testData/checker/Variance.jet
+++ b/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 set(index : Int, value : T) { /* ... */ }
+    fun get(<warning>index</warning> : Int) : T { return 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)
diff --git a/idea/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet b/idea/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet
index 779ee4c4d97..813be88472a 100644
--- a/idea/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet
+++ b/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(other : Char)   : Int = 0
+  fun compareTo(<warning>other</warning> : Byte)   : Int = 0
+  fun compareTo(<warning>other</warning> : Char)   : Int = 0
 }
diff --git a/idea/testData/checker/regression/CoercionToUnit.jet b/idea/testData/checker/regression/CoercionToUnit.jet
index ec8c8e32275..f02143657f7 100644
--- a/idea/testData/checker/regression/CoercionToUnit.jet
+++ b/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>)
diff --git a/idea/testData/checker/regression/Jet124.jet b/idea/testData/checker/regression/Jet124.jet
index 48aa4644dea..317b1438f41 100644
--- a/idea/testData/checker/regression/Jet124.jet
+++ b/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)
 }
\ No newline at end of file
diff --git a/idea/testData/checker/regression/Jet169.jet b/idea/testData/checker/regression/Jet169.jet
index 2bed1f918f3..0ba52f8e3cb 100644
--- a/idea/testData/checker/regression/Jet169.jet
+++ b/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)
diff --git a/idea/testData/checker/regression/Jet69.jet b/idea/testData/checker/regression/Jet69.jet
index dd198aa0f61..346a98fd25a 100644
--- a/idea/testData/checker/regression/Jet69.jet
+++ b/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
 
diff --git a/idea/testData/checker/regression/ScopeForSecondaryConstructors.jet b/idea/testData/checker/regression/ScopeForSecondaryConstructors.jet
index f4516941508..84c59da5a8a 100644
--- a/idea/testData/checker/regression/ScopeForSecondaryConstructors.jet
+++ b/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
diff --git a/idea/testData/checker/regression/SpecififcityByReceiver.jet b/idea/testData/checker/regression/SpecififcityByReceiver.jet
index b25f919e597..67d6776baba 100644
--- a/idea/testData/checker/regression/SpecififcityByReceiver.jet
+++ b/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>) {
 
diff --git a/idea/testData/checker/regression/WrongTraceInCallResolver.jet b/idea/testData/checker/regression/WrongTraceInCallResolver.jet
index 2c88d2450dd..30af5e2d8e8 100644
--- a/idea/testData/checker/regression/WrongTraceInCallResolver.jet
+++ b/idea/testData/checker/regression/WrongTraceInCallResolver.jet
@@ -1,8 +1,8 @@
 open class Foo {}
 open class Bar {}
 
-fun <T : Bar, T1> foo(x : Int) {}
-fun <T1, T : Foo> foo(x : Long) {}
+fun <T : Bar, T1> foo(<warning>x</warning> : Int) {}
+fun <T1, T : Foo> foo(<warning>x</warning> : Long) {}
 
 fun f(): Unit {
     foo<<error>Int</error>, Int>(1)