From d440f0711191c87100485a9ca5664c705f12b24c Mon Sep 17 00:00:00 2001
From: Alexander Udalov <Alexander.Udalov@jetbrains.com>
Date: Sat, 1 Apr 2017 02:28:36 +0300
Subject: [PATCH] Use Java 7+ diamond operator in compiler modules

---
 .../kotlin/compilerRunner/ArgumentUtils.java  |  2 +-
 .../kotlin/android/tests/ant/AntRunner.java   |  2 +-
 .../android/tests/gradle/GradleRunner.java    |  2 +-
 .../tests/CodegenTestsOnAndroidGenerator.java |  4 +-
 .../kotlin/codegen/AbstractClassBuilder.java  |  2 +-
 .../AccessorForFunctionDescriptor.java        |  2 +-
 .../kotlin/codegen/AnnotationCodegen.java     | 14 +++---
 .../org/jetbrains/kotlin/codegen/AsmUtil.java |  2 +-
 .../kotlin/codegen/ClassBodyCodegen.java      |  2 +-
 .../kotlin/codegen/ClassFileFactory.java      | 10 ++--
 .../kotlin/codegen/ClosureCodegen.java        |  4 +-
 .../kotlin/codegen/ExpressionCodegen.java     | 26 +++++-----
 .../jetbrains/kotlin/codegen/FrameMap.java    |  6 +--
 .../FunctionReferenceGenerationStrategy.java  |  9 ++--
 .../codegen/ImplementationBodyCodegen.java    | 17 +++----
 .../kotlin/codegen/KotlinCodegenFacade.java   |  8 +--
 .../kotlin/codegen/MemberCodegen.java         |  4 +-
 .../kotlin/codegen/PackageCodegenImpl.java    |  4 +-
 .../kotlin/codegen/PackagePartCodegen.java    |  4 +-
 .../codegen/TransformationMethodVisitor.java  |  2 +-
 .../binding/CodegenAnnotatingVisitor.java     |  8 +--
 .../codegen/binding/CodegenBinding.java       | 15 +++---
 .../codegen/binding/MutableClosure.java       |  9 ++--
 .../codegen/context/CodegenContext.java       |  6 +--
 .../codegen/context/FieldOwnerContext.java    |  5 +-
 .../inline/AnonymousObjectTransformer.java    | 24 ++++-----
 .../kotlin/codegen/inline/InlineAdapter.java  |  2 +-
 .../kotlin/codegen/inline/InlineCodegen.java  |  7 ++-
 .../codegen/inline/InliningContext.java       |  5 +-
 .../inline/InternalFinallyBlockInliner.java   | 16 +++---
 .../kotlin/codegen/inline/LambdaInfo.java     |  2 +-
 .../MaxStackFrameSizeAndLocalsCalculator.java | 11 ++--
 .../kotlin/codegen/inline/NameGenerator.java  |  2 +-
 .../RedundantBoxedValuesCollection.java       |  2 +-
 .../RedundantBoxingMethodTransformer.java     |  4 +-
 .../transformer/MethodTransformer.java        |  2 +-
 .../JvmSerializationBindings.java             |  4 +-
 .../signature/BothSignatureWriter.java        |  2 +-
 .../codegen/signature/JvmSignatureWriter.java |  4 +-
 .../when/MappingsClassesForWhenByEnum.java    |  2 +-
 .../codegen/when/StringSwitchCodegen.java     |  6 +--
 .../kotlin/codegen/when/SwitchCodegen.java    |  4 +-
 .../codegen/when/SwitchCodegenUtil.java       |  4 +-
 .../codegen/when/WhenByEnumsMapping.java      |  2 +-
 .../arguments/CommonCompilerArguments.java    |  4 +-
 .../messages/GroupingMessageCollector.java    |  2 +-
 .../cli/common/modules/ModuleXmlParser.java   |  2 +-
 .../kotlin/cli/common/CLICompiler.java        |  2 +-
 .../jetbrains/kotlin/cli/js/K2JSCompiler.java |  4 +-
 .../java/sam/SingleAbstractMethodUtils.java   | 10 ++--
 .../impl/JavaClassifierTypeImpl.java          |  4 +-
 .../load/kotlin/FileBasedKotlinClass.java     |  4 +-
 .../kotlin/resolve/jvm/AsmTypes.java          |  2 +-
 .../kotlin/resolve/jvm/JavaResolverUtils.java | 11 ++--
 .../resolve/jvm/KotlinJavaPsiFacade.java      |  6 +--
 .../diagnostics/DefaultErrorMessagesJvm.java  |  2 +-
 .../SignaturesPropagationData.java            |  4 +-
 .../kotlin/checkers/CheckerTestUtil.java      | 14 +++---
 .../kotlin/config/CompilerConfiguration.java  |  2 +-
 .../config/CompilerConfigurationKey.java      |  2 +-
 .../diagnostics/DiagnosticFactory0.java       |  4 +-
 .../diagnostics/DiagnosticFactory1.java       |  4 +-
 .../diagnostics/DiagnosticFactory2.java       |  6 +--
 .../diagnostics/DiagnosticFactory3.java       |  4 +-
 .../rendering/DefaultErrorMessages.java       |  2 +-
 .../DiagnosticFactoryToRendererMap.java       |  2 +-
 .../rendering/TabledDescriptorRenderer.java   |  2 +-
 .../org/jetbrains/kotlin/lexer/_JetLexer.java |  9 ++--
 .../kotlin/parsing/AbstractKotlinParsing.java |  4 +-
 .../parsing/KotlinExpressionParsing.java      |  6 +--
 ...SemanticWhitespaceAwarePsiBuilderImpl.java |  4 +-
 .../org/jetbrains/kotlin/psi/KtPsiUtil.java   |  4 +-
 .../KtPlaceHolderStubElementType.java         |  5 +-
 .../stubs/elements/KtStubElementTypes.java    | 50 +++++++++----------
 .../kotlin/resolve/AnalyzingUtils.java        |  2 +-
 .../resolve/AnnotationResolverImpl.java       |  2 +-
 .../kotlin/resolve/BindingContext.java        | 39 +++++++--------
 .../kotlin/resolve/BindingContextUtils.java   |  2 +-
 .../kotlin/resolve/BodyResolver.java          |  4 +-
 .../kotlin/resolve/DescriptorResolver.java    |  8 +--
 .../resolve/TopDownAnalysisContext.java       |  2 +-
 .../resolve/calls/ArgumentTypeResolver.java   |  4 +-
 .../kotlin/resolve/calls/CallResolver.java    | 14 +++---
 .../ValueArgumentsToParametersMapper.java     |  2 +-
 .../resolve/calls/checkers/InlineChecker.java |  2 +-
 .../CallCandidateResolutionContext.java       |  6 +--
 .../calls/inference/ConstraintsUtil.java      |  2 +-
 .../model/DataFlowInfoForArgumentsImpl.java   |  4 +-
 .../resolve/calls/model/ResolvedCallImpl.java |  8 +--
 .../OverloadResolutionResultsImpl.java        | 16 +++---
 .../results/ResolutionResultsHandler.java     |  4 +-
 .../calls/tasks/ResolutionCandidate.java      | 10 ++--
 .../kotlin/resolve/calls/util/CallMaker.java  |  2 +-
 .../diagnostics/DiagnosticsElementsCache.java |  2 +-
 .../DiagnosticsWithSuppression.java           |  3 +-
 .../kotlin/resolve/lazy/ResolveSession.java   |  2 +-
 .../resolve/lazy/ResolveSessionUtils.java     |  2 +-
 .../lazy/descriptors/LazyClassDescriptor.java |  4 +-
 .../LazyTypeParameterDescriptor.java          |  4 +-
 .../kotlin/types/BoundsSubstitutor.java       |  2 +-
 .../kotlin/types/CommonSupertypes.java        | 31 ++++++------
 .../jetbrains/kotlin/types/DeferredType.java  |  4 +-
 .../kotlin/types/TypeIntersector.java         |  8 +--
 .../BasicExpressionTypingVisitor.java         |  2 +-
 .../ControlStructureTypingUtils.java          |  2 +-
 .../ControlStructureTypingVisitor.java        |  2 +-
 .../types/expressions/DataFlowAnalyzer.java   |  2 +-
 .../expressions/ExpressionTypingUtils.java    |  2 +-
 .../kotlin/util/slicedMap/SlicedMapImpl.java  |  2 +-
 .../kotlin/util/slicedMap/Slices.java         | 12 ++---
 .../util/slicedMap/TrackingSlicedMap.java     |  6 +--
 .../asJava/builder/StubClassBuilder.java      |  2 +-
 .../asJava/finder/JavaElementFinder.java      |  4 +-
 .../ProfilingInstrumenterExample.java         |  9 ++--
 .../InterceptionInstrumenter.java             | 32 ++++++------
 .../preloading/ClassPreloadingUtils.java      | 10 ++--
 .../preloading/MemoryBasedClassLoader.java    |  4 +-
 .../kotlin/preloading/Preloader.java          |  4 +-
 .../checkers/KotlinMultiFileTestWithJava.java |  2 +-
 .../codegen/AbstractBlackBoxCodegenTest.java  |  4 +-
 .../AbstractCheckLocalVariablesTableTest.java |  2 +-
 ...bstractCompileKotlinAgainstKotlinTest.java |  2 +-
 .../codegen/AbstractLineNumberTest.java       |  8 ++-
 ...AbstractTopLevelMembersInvocationTest.java |  2 +-
 .../kotlin/codegen/CodegenTestCase.java       |  8 +--
 .../kotlin/codegen/CodegenTestFiles.java      |  4 +-
 .../kotlin/codegen/CodegenTestUtil.java       |  4 +-
 .../codegen/flags/AbstractWriteFlagsTest.java |  2 +-
 .../forTestCompile/ForTestCompileRuntime.java | 10 ++--
 .../jvm/compiler/ExpectedLoadErrorsUtil.java  |  4 +-
 .../jvm/compiler/LoadDescriptorUtil.java      |  4 +-
 .../resolve/ExpectedResolveDataUtil.java      |  6 +--
 .../kotlin/test/InTextDirectivesUtils.java    |  6 +--
 .../kotlin/test/JUnit3RunnerWithInners.java   | 10 ++--
 .../kotlin/test/KotlinTestUtils.java          |  8 +--
 .../kotlin/test/MockLibraryUtil.java          | 12 ++---
 .../test/testFramework/KtUsefulTestCase.java  | 14 +++---
 .../testFramework/mock/MockPsiManager.java    |  2 +-
 .../util/RecursiveDescriptorComparator.java   |  2 +-
 .../util/RecursiveDescriptorProcessor.java    |  2 +-
 .../kotlin/cfg/AbstractControlFlowTest.java   |  2 +-
 .../kotlin/cfg/CFGraphToDotFilePrinter.java   |  2 +-
 .../jetbrains/kotlin/cli/AbstractCliTest.java |  4 +-
 .../kotlin/codegen/InnerClassInfoGenTest.java |  2 +-
 .../kotlin/codegen/PackageGenTest.java        |  6 +--
 .../integration/CompilerSmokeTestBase.java    |  2 +-
 ...ompileKotlinAgainstCustomBinariesTest.java |  8 +--
 .../org/jetbrains/kotlin/name/FqNameTest.java |  2 +-
 .../kotlin/storage/StorageManagerTest.java    |  4 +-
 .../kotlin/types/KotlinTypeCheckerTest.java   |  4 +-
 .../org/jetbrains/kotlin/utils/Interner.java  |  2 +-
 .../org/jetbrains/kotlin/utils/Profiler.java  |  2 +-
 .../frontend/GenerateKeywordStrings.java      |  2 +-
 .../tests/generator/SimpleTestClassModel.java |  4 +-
 .../jetbrains/kotlin/js/config/JsConfig.java  |  8 +--
 .../js/translate/utils/AnnotationsUtils.java  |  2 +-
 .../jetbrains/kotlin/js/inline/JsInliner.java |  6 +--
 .../kotlin/integration/AntTaskJsTest.java     |  2 +-
 .../jetbrains/kotlin/js/test/BasicTest.java   |  2 +-
 .../CompileMavenGeneratedJSLibrary.java       |  2 +-
 .../js/test/semantics/JsUnitTestBase.java     |  2 +-
 .../kotlin/js/test/semantics/StdLibTest.java  |  2 +-
 .../kotlin/js/test/utils/CallCounter.java     |  8 +--
 .../js/test/utils/DirectiveTestUtils.java     | 14 +++---
 .../kotlin/js/test/utils/JsTestUtils.java     |  2 +-
 .../kotlin/js/facade/FacadeUtils.java         |  2 +-
 .../kotlin/js/facade/K2JSTranslator.java      |  6 +--
 .../sourceMap/JsSourceGenerationVisitor.java  |  2 +-
 .../js/sourceMap/SourceMap3Builder.java       |  2 +-
 .../js/translate/context/StaticContext.java   | 24 ++++-----
 .../translate/context/TranslationContext.java |  4 +-
 .../declaration/JsDataClassGenerator.java     |  2 +-
 .../DestructuringDeclarationTranslator.java   |  2 +-
 .../expression/ExpressionVisitor.java         |  2 +-
 .../expression/StringTemplateTranslator.java  |  2 +-
 .../translate/expression/WhenTranslator.java  |  2 +-
 .../js/translate/general/Translation.java     |  2 +-
 .../ClassInitializerTranslator.java           |  6 +--
 .../functions/FunctionIntrinsics.java         |  2 +-
 .../factories/KotlinFunctionIntrinsic.java    |  2 +-
 .../OverloadedAssignmentTranslator.java       |  2 +-
 .../reference/AccessTranslationUtils.java     |  2 +-
 .../reference/ArrayAccessTranslator.java      |  2 +-
 .../reference/CallExpressionTranslator.java   |  2 +-
 .../utils/FunctionBodyTranslator.java         |  4 +-
 .../kotlin/js/translate/utils/JsAstUtils.java | 10 ++--
 .../js/translate/utils/TranslationUtils.java  |  2 +-
 187 files changed, 512 insertions(+), 533 deletions(-)

diff --git a/build-common/src/org/jetbrains/kotlin/compilerRunner/ArgumentUtils.java b/build-common/src/org/jetbrains/kotlin/compilerRunner/ArgumentUtils.java
index fdcf4cce51b..dd59d5c012f 100644
--- a/build-common/src/org/jetbrains/kotlin/compilerRunner/ArgumentUtils.java
+++ b/build-common/src/org/jetbrains/kotlin/compilerRunner/ArgumentUtils.java
@@ -33,7 +33,7 @@ public class ArgumentUtils {
     @NotNull
     public static List<String> convertArgumentsToStringList(@NotNull CommonCompilerArguments arguments)
             throws InstantiationException, IllegalAccessException {
-        List<String> result = new ArrayList<String>();
+        List<String> result = new ArrayList<>();
         convertArgumentsToStringList(arguments, arguments.getClass().newInstance(), arguments.getClass(), result);
         result.addAll(arguments.freeArgs);
         return result;
diff --git a/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/ant/AntRunner.java b/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/ant/AntRunner.java
index 8f8430aeed6..128ea1fb06b 100644
--- a/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/ant/AntRunner.java
+++ b/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/ant/AntRunner.java
@@ -31,7 +31,7 @@ public class AntRunner {
     private final List<String> listOfAntCommands;
 
     public AntRunner(PathManager pathManager) {
-        listOfAntCommands = new ArrayList<String>();
+        listOfAntCommands = new ArrayList<>();
         String antCmdName = SystemInfo.isWindows ? "ant.bat" : "ant";
         listOfAntCommands.add(pathManager.getAntBinDirectory() + "/" + antCmdName);
         listOfAntCommands.add("-Dsdk.dir=" + pathManager.getAndroidSdkRoot());
diff --git a/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/gradle/GradleRunner.java b/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/gradle/GradleRunner.java
index 84d0d714daf..861ec87b475 100644
--- a/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/gradle/GradleRunner.java
+++ b/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/gradle/GradleRunner.java
@@ -30,7 +30,7 @@ public class GradleRunner {
     private final List<String> listOfCommands;
 
     public GradleRunner(PathManager pathManager) {
-        listOfCommands = new ArrayList<String>();
+        listOfCommands = new ArrayList<>();
         String cmdName = SystemInfo.isWindows ? "gradle.bat" : "gradle";
         listOfCommands.add(pathManager.getGradleBinFolder() + "/" + cmdName);
         listOfCommands.add("--build-file");
diff --git a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java
index b355f39cb99..7a10a7bd6af 100644
--- a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java
+++ b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java
@@ -142,7 +142,7 @@ public class CodegenTestsOnAndroidGenerator extends KtUsefulTestCase {
         private final boolean isFullJdkAndRuntime;
         private final boolean inheritMultifileParts;
 
-        public List<KtFile> files = new ArrayList<KtFile>();
+        public List<KtFile> files = new ArrayList<>();
         private KotlinCoreEnvironment environment;
 
         private FilesWriter(boolean isFullJdkAndRuntime, boolean inheritMultifileParts) {
@@ -175,7 +175,7 @@ public class CodegenTestsOnAndroidGenerator extends KtUsefulTestCase {
 
         public void writeFilesOnDisk() {
             writeFiles(files);
-            files = new ArrayList<KtFile>();
+            files = new ArrayList<>();
             environment = createEnvironment(isFullJdkAndRuntime);
         }
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AbstractClassBuilder.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AbstractClassBuilder.java
index d5fb78823d7..18894119676 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AbstractClassBuilder.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AbstractClassBuilder.java
@@ -37,7 +37,7 @@ public abstract class AbstractClassBuilder implements ClassBuilder {
 
     private final JvmSerializationBindings serializationBindings = new JvmSerializationBindings();
 
-    private final List<FileMapping> fileMappings = new ArrayList<FileMapping>();
+    private final List<FileMapping> fileMappings = new ArrayList<>();
 
     private String sourceName;
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java
index 3fb89d4d796..d10ac35b5e2 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java
@@ -56,7 +56,7 @@ public class AccessorForFunctionDescriptor extends AbstractAccessorForFunctionDe
 
         setSuspend(descriptor.isSuspend());
         if (descriptor.getUserData(CoroutineCodegenUtilKt.INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION) != null) {
-            userDataMap = new LinkedHashMap<UserDataKey<?>, Object>();
+            userDataMap = new LinkedHashMap<>();
             userDataMap.put(
                     CoroutineCodegenUtilKt.INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION,
                     descriptor.getUserData(CoroutineCodegenUtilKt.INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION)
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java
index fc3473c3a67..9c04353521d 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java
@@ -27,9 +27,11 @@ import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.resolve.AnnotationChecker;
 import org.jetbrains.kotlin.resolve.constants.*;
-import org.jetbrains.kotlin.resolve.constants.StringValue;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
-import org.jetbrains.kotlin.types.*;
+import org.jetbrains.kotlin.types.FlexibleType;
+import org.jetbrains.kotlin.types.FlexibleTypesKt;
+import org.jetbrains.kotlin.types.KotlinType;
+import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.org.objectweb.asm.*;
 
 import java.lang.annotation.*;
@@ -87,7 +89,7 @@ public abstract class AnnotationCodegen {
             return;
         }
 
-        Set<String> annotationDescriptorsAlreadyPresent = new HashSet<String>();
+        Set<String> annotationDescriptorsAlreadyPresent = new HashSet<>();
 
         Annotations annotations = annotated.getAnnotations();
 
@@ -200,8 +202,7 @@ public abstract class AnnotationCodegen {
         generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotationClass);
     }
 
-    private static final Map<KotlinTarget, ElementType> annotationTargetMap =
-            new EnumMap<KotlinTarget, ElementType>(KotlinTarget.class);
+    private static final Map<KotlinTarget, ElementType> annotationTargetMap = new EnumMap<>(KotlinTarget.class);
 
     static {
         annotationTargetMap.put(KotlinTarget.CLASS, ElementType.TYPE);
@@ -418,8 +419,7 @@ public abstract class AnnotationCodegen {
         value.accept(argumentVisitor, null);
     }
 
-    private static final Map<KotlinRetention, RetentionPolicy> annotationRetentionMap =
-            new EnumMap<KotlinRetention, RetentionPolicy>(KotlinRetention.class);
+    private static final Map<KotlinRetention, RetentionPolicy> annotationRetentionMap = new EnumMap<>(KotlinRetention.class);
 
     static {
         annotationRetentionMap.put(KotlinRetention.SOURCE, RetentionPolicy.SOURCE);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java
index 1dc3b825a74..829f0beb956 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java
@@ -445,7 +445,7 @@ public class AsmUtil {
     }
 
     public static void genClosureFields(@NotNull CalculatedClosure closure, ClassBuilder v, KotlinTypeMapper typeMapper) {
-        List<Pair<String, Type>> allFields = new ArrayList<Pair<String, Type>>();
+        List<Pair<String, Type>> allFields = new ArrayList<>();
 
         ClassifierDescriptor captureThis = closure.getCaptureThis();
         if (captureThis != null) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java
index 7872cb03582..a63fe746699 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java
@@ -54,7 +54,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
 
     @Override
     protected void generateBody() {
-        List<KtObjectDeclaration> companions = new ArrayList<KtObjectDeclaration>();
+        List<KtObjectDeclaration> companions = new ArrayList<>();
         if (kind != OwnerKind.DEFAULT_IMPLS) {
             //generate nested classes first and only then generate class body. It necessary to access to nested CodegenContexts
             for (KtDeclaration declaration : myClass.getDeclarations()) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java
index cd0fe845cfd..5e93da4ecb7 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java
@@ -42,12 +42,12 @@ import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.getMappingFileName;
 public class ClassFileFactory implements OutputFileCollection {
     private final GenerationState state;
     private final ClassBuilderFactory builderFactory;
-    private final Map<String, OutAndSourceFileList> generators = new LinkedHashMap<String, OutAndSourceFileList>();
+    private final Map<String, OutAndSourceFileList> generators = new LinkedHashMap<>();
 
     private boolean isDone = false;
 
-    private final Set<File> packagePartSourceFiles = new HashSet<File>();
-    private final Map<String, PackageParts> partsGroupedByPackage = new LinkedHashMap<String, PackageParts>();
+    private final Set<File> packagePartSourceFiles = new HashSet<>();
+    private final Map<String, PackageParts> partsGroupedByPackage = new LinkedHashMap<>();
 
     public ClassFileFactory(@NotNull GenerationState state, @NotNull ClassBuilderFactory builderFactory) {
         this.state = state;
@@ -153,7 +153,7 @@ public class ClassFileFactory implements OutputFileCollection {
     @NotNull
     @TestOnly
     public Map<String, String> createTextForEachFile() {
-        Map<String, String> answer = new LinkedHashMap<String, String>();
+        Map<String, String> answer = new LinkedHashMap<>();
         for (OutputFile file : asList()) {
             answer.put(file.getRelativePath(), file.asText());
         }
@@ -188,7 +188,7 @@ public class ClassFileFactory implements OutputFileCollection {
 
     @NotNull
     private static List<File> toIoFilesIgnoringNonPhysical(@NotNull Collection<? extends PsiFile> psiFiles) {
-        List<File> result = new ArrayList<File>(psiFiles.size());
+        List<File> result = new ArrayList<>(psiFiles.size());
         for (PsiFile psiFile : psiFiles) {
             VirtualFile virtualFile = psiFile.getVirtualFile();
             // We ignore non-physical files here, because this code is needed to tell the make what inputs affect which outputs
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java
index 3d3ee4ddc20..be1dd432955 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java
@@ -100,7 +100,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
         this.strategy = strategy;
 
         if (samType == null) {
-            this.superInterfaceTypes = new ArrayList<KotlinType>();
+            this.superInterfaceTypes = new ArrayList<>();
 
             KotlinType superClassType = null;
             for (KotlinType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
@@ -252,7 +252,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
     @NotNull
     private static FunctionDescriptor createFreeLambdaDescriptor(@NotNull FunctionDescriptor descriptor) {
         FunctionDescriptor.CopyBuilder<? extends FunctionDescriptor> builder = descriptor.newCopyBuilder();
-        List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(0);
+        List<TypeParameterDescriptor> typeParameters = new ArrayList<>(0);
         builder.setTypeParameters(typeParameters);
 
         DeclarationDescriptor container = descriptor.getContainingDeclaration();
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java
index 1715b58b0bc..d4ae9304e3d 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java
@@ -130,7 +130,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
     private final TailRecursionCodegen tailRecursionCodegen;
     public final CallGenerator defaultCallGenerator = new CallGenerator.DefaultCallGenerator(this);
 
-    private final Stack<BlockStackElement> blockStackElements = new Stack<BlockStackElement>();
+    private final Stack<BlockStackElement> blockStackElements = new Stack<>();
 
     /*
      * When we create a temporary variable to hold some value not to compute it many times
@@ -189,7 +189,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
     }
 
     static class FinallyBlockStackElement extends BlockStackElement {
-        List<Label> gaps = new ArrayList<Label>();
+        List<Label> gaps = new ArrayList<>();
 
         final KtTryExpression expression;
 
@@ -571,7 +571,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             // We handle this case separately because otherwise such variable will be out of the frame map after the block ends
             List<KtExpression> doWhileStatements = ((KtBlockExpression) body).getStatements();
 
-            List<KtExpression> statements = new ArrayList<KtExpression>(doWhileStatements.size() + 1);
+            List<KtExpression> statements = new ArrayList<>(doWhileStatements.size() + 1);
             statements.addAll(doWhileStatements);
             statements.add(condition);
 
@@ -1444,7 +1444,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         }
 
         if (!shouldInlineConstVals && !takeUpConstValsAsConst && compileTimeValue.getUsesVariableAsConstant()) {
-            Ref<Boolean> containsNonInlinedVals = new Ref<Boolean>(false);
+            Ref<Boolean> containsNonInlinedVals = new Ref<>(false);
             KtVisitor constantChecker = new KtVisitor() {
                 @Override
                 public Object visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression, Object data) {
@@ -1648,9 +1648,9 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                         .format("Incorrect number of mapped parameters vs arguments: %d < %d for %s",
                                 superMappedTypes.size(), params, classDescriptor);
 
-                List<ResolvedValueArgument> valueArguments = new ArrayList<ResolvedValueArgument>(params);
-                List<ValueParameterDescriptor> valueParameters = new ArrayList<ValueParameterDescriptor>(params);
-                List<Type> mappedTypes = new ArrayList<Type>(params);
+                List<ResolvedValueArgument> valueArguments = new ArrayList<>(params);
+                List<ValueParameterDescriptor> valueParameters = new ArrayList<>(params);
+                List<Type> mappedTypes = new ArrayList<>(params);
                 for (ValueParameterDescriptor parameter : superValueParameters) {
                     ResolvedValueArgument argument = superCall.getValueArguments().get(parameter);
                     if (!(argument instanceof DefaultValueArgument)) {
@@ -2810,7 +2810,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         DefaultCallArgs defaultArgs =
                 argumentGenerator.generate(
                         valueArguments,
-                        new ArrayList<ResolvedValueArgument>(resolvedCall.getValueArguments().values()),
+                        new ArrayList<>(resolvedCall.getValueArguments().values()),
                         resolvedCall.getResultingDescriptor()
                 );
 
@@ -3041,9 +3041,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         TypeParameterDescriptor parameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(type);
         if (parameterDescriptor == null) return null;
 
-        return new Pair<TypeParameterDescriptor, ReificationArgument>(
-                parameterDescriptor,
-                new ReificationArgument(parameterDescriptor.getName().asString(), isNullable, arrayDepth));
+        return new Pair<>(parameterDescriptor, new ReificationArgument(parameterDescriptor.getName().asString(), isNullable, arrayDepth));
     }
 
     @NotNull
@@ -4542,9 +4540,9 @@ The "returned" value of try expression with no finally is either the last expres
             @NotNull Label blockEnd
     ) {
         List<Label> gapsInBlock =
-                finallyBlockStackElement != null ? new ArrayList<Label>(finallyBlockStackElement.gaps) : Collections.<Label>emptyList();
+                finallyBlockStackElement != null ? new ArrayList<>(finallyBlockStackElement.gaps) : Collections.emptyList();
         assert gapsInBlock.size() % 2 == 0;
-        List<Label> blockRegions = new ArrayList<Label>(gapsInBlock.size() + 2);
+        List<Label> blockRegions = new ArrayList<>(gapsInBlock.size() + 2);
         blockRegions.add(blockStart);
         blockRegions.addAll(gapsInBlock);
         blockRegions.add(blockEnd);
@@ -4809,7 +4807,7 @@ The "returned" value of try expression with no finally is either the last expres
     }
 
     public Stack<BlockStackElement> getBlockStackElements() {
-        return new Stack<BlockStackElement>(blockStackElements);
+        return new Stack<>(blockStackElements);
     }
 
     public void addBlockStackElementsForNonLocalReturns(@NotNull Stack<BlockStackElement> elements, int finallyDepth) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FrameMap.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FrameMap.java
index f75c8315fd1..05776a1e7ac 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FrameMap.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FrameMap.java
@@ -28,8 +28,8 @@ import java.util.Comparator;
 import java.util.List;
 
 public class FrameMap {
-    private final TObjectIntHashMap<DeclarationDescriptor> myVarIndex = new TObjectIntHashMap<DeclarationDescriptor>();
-    private final TObjectIntHashMap<DeclarationDescriptor> myVarSizes = new TObjectIntHashMap<DeclarationDescriptor>();
+    private final TObjectIntHashMap<DeclarationDescriptor> myVarIndex = new TObjectIntHashMap<>();
+    private final TObjectIntHashMap<DeclarationDescriptor> myVarSizes = new TObjectIntHashMap<>();
     private int myMaxIndex = 0;
 
     public int enter(DeclarationDescriptor descriptor, Type type) {
@@ -81,7 +81,7 @@ public class FrameMap {
         }
 
         public void dropTo() {
-            List<DeclarationDescriptor> descriptorsToDrop = new ArrayList<DeclarationDescriptor>();
+            List<DeclarationDescriptor> descriptorsToDrop = new ArrayList<>();
             TObjectIntIterator<DeclarationDescriptor> iterator = myVarIndex.iterator();
             while (iterator.hasNext()) {
                 iterator.advance();
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java
index d42beeb6d53..1d939c862ab 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java
@@ -35,7 +35,10 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.isObject;
 
@@ -88,7 +91,7 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat
 
             private final Map<ValueParameterDescriptor, ResolvedValueArgument> argumentMap;
             {
-                argumentMap = new LinkedHashMap<ValueParameterDescriptor, ResolvedValueArgument>(fakeArguments.size());
+                argumentMap = new LinkedHashMap<>(fakeArguments.size());
                 int index = 0;
                 List<ValueParameterDescriptor> parameters = functionDescriptor.getValueParameters();
                 for (ValueArgument argument : fakeArguments) {
@@ -112,7 +115,7 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat
             @NotNull
             @Override
             public List<ResolvedValueArgument> getValueArgumentsByIndex() {
-                return new ArrayList<ResolvedValueArgument>(argumentMap.values());
+                return new ArrayList<>(argumentMap.values());
             }
 
             @NotNull
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java
index ba5123c5fc2..90181bb8032 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java
@@ -100,8 +100,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
     private final DelegationFieldsInfo delegationFieldsInfo;
 
-    private final List<Function2<ImplementationBodyCodegen, ClassBuilder, Unit>> additionalTasks =
-            new ArrayList<Function2<ImplementationBodyCodegen, ClassBuilder, Unit>>();
+    private final List<Function2<ImplementationBodyCodegen, ClassBuilder, Unit>> additionalTasks = new ArrayList<>();
 
     public ImplementationBodyCodegen(
             @NotNull KtPureClassOrObject aClass,
@@ -255,7 +254,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         }
     }
 
-    private static final Map<FqName, String> KOTLIN_MARKER_INTERFACES = new HashMap<FqName, String>();
+    private static final Map<FqName, String> KOTLIN_MARKER_INTERFACES = new HashMap<>();
     static {
         KOTLIN_MARKER_INTERFACES.put(FQ_NAMES.iterator, "kotlin/jvm/internal/markers/KMappedMarker");
         KOTLIN_MARKER_INTERFACES.put(FQ_NAMES.iterable, "kotlin/jvm/internal/markers/KMappedMarker");
@@ -302,8 +301,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         }
         sw.writeSuperclassEnd();
 
-        LinkedHashSet<String> superInterfaces = new LinkedHashSet<String>();
-        Set<String> kotlinMarkerInterfaces = new LinkedHashSet<String>();
+        LinkedHashSet<String> superInterfaces = new LinkedHashSet<>();
+        Set<String> kotlinMarkerInterfaces = new LinkedHashSet<>();
 
         for (KotlinType supertype : descriptor.getTypeConstructor().getSupertypes()) {
             if (isJvmInterface(supertype.getConstructor().getDeclarationDescriptor())) {
@@ -330,7 +329,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         superInterfaces.addAll(kotlinMarkerInterfaces);
 
         return new JvmClassSignature(classAsmType.getInternalName(), superClassInfo.getType().getInternalName(),
-                                     new ArrayList<String>(superInterfaces), sw.makeJavaGenericSignature());
+                                     new ArrayList<>(superInterfaces), sw.makeJavaGenericSignature());
     }
 
     private void getSuperClass() {
@@ -1089,7 +1088,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 return StackValue.field(type, classAsmType, name, false, StackValue.none());
             }
         }
-        private final Map<KtDelegatedSuperTypeEntry, Field> fields = new HashMap<KtDelegatedSuperTypeEntry, Field>();
+        private final Map<KtDelegatedSuperTypeEntry, Field> fields = new HashMap<>();
 
         @NotNull
         public Field getInfo(KtDelegatedSuperTypeEntry specifier) {
@@ -1266,7 +1265,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     private void generateTraitMethods() {
         if (isAnnotationOrJvmInterfaceWithoutDefaults(descriptor, state)) return;
 
-        List<FunctionDescriptor> restrictedInheritance = new ArrayList<FunctionDescriptor>();
+        List<FunctionDescriptor> restrictedInheritance = new ArrayList<>();
         for (Map.Entry<FunctionDescriptor, FunctionDescriptor> entry : CodegenUtil.getNonPrivateTraitMethods(descriptor).entrySet()) {
             FunctionDescriptor interfaceFun = entry.getKey();
             //skip java 8 default methods
@@ -1625,7 +1624,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
     public void addCompanionObjectPropertyToCopy(@NotNull PropertyDescriptor descriptor, Object defaultValue) {
         if (companionObjectPropertiesToCopy == null) {
-            companionObjectPropertiesToCopy = new ArrayList<PropertyAndDefaultValue>();
+            companionObjectPropertiesToCopy = new ArrayList<>();
         }
         companionObjectPropertiesToCopy.add(new PropertyAndDefaultValue(descriptor, defaultValue));
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/KotlinCodegenFacade.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/KotlinCodegenFacade.java
index d70ccbdeefd..997c7636bca 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/KotlinCodegenFacade.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/KotlinCodegenFacade.java
@@ -49,8 +49,8 @@ public class KotlinCodegenFacade {
             @NotNull GenerationState state,
             @NotNull CompilationErrorHandler errorHandler
     ) {
-        MultiMap<FqName, KtFile> filesInPackages = new MultiMap<FqName, KtFile>();
-        MultiMap<FqName, KtFile> filesInMultifileClasses = new MultiMap<FqName, KtFile>();
+        MultiMap<FqName, KtFile> filesInPackages = new MultiMap<>();
+        MultiMap<FqName, KtFile> filesInMultifileClasses = new MultiMap<>();
 
         for (KtFile file : files) {
             if (file == null) throw new IllegalArgumentException("A null file given for compilation");
@@ -65,13 +65,13 @@ public class KotlinCodegenFacade {
             }
         }
 
-        Set<FqName> obsoleteMultifileClasses = new HashSet<FqName>(state.getObsoleteMultifileClasses());
+        Set<FqName> obsoleteMultifileClasses = new HashSet<>(state.getObsoleteMultifileClasses());
         for (FqName multifileClassFqName : Sets.union(filesInMultifileClasses.keySet(), obsoleteMultifileClasses)) {
             doCheckCancelled(state);
             generateMultifileClass(state, multifileClassFqName, filesInMultifileClasses.get(multifileClassFqName), errorHandler);
         }
 
-        Set<FqName> packagesWithObsoleteParts = new HashSet<FqName>(state.getPackagesWithObsoleteParts());
+        Set<FqName> packagesWithObsoleteParts = new HashSet<>(state.getPackagesWithObsoleteParts());
         for (FqName packageFqName : Sets.union(packagesWithObsoleteParts, filesInPackages.keySet())) {
             doCheckCancelled(state);
             generatePackage(state, packageFqName, filesInPackages.get(packageFqName), errorHandler);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java
index e8b25364f14..3f7dca36840 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java
@@ -92,7 +92,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     private final JvmFileClassesProvider fileClassesProvider;
     private final MemberCodegen<?> parentCodegen;
     private final ReifiedTypeParametersUsages reifiedTypeParametersUsages = new ReifiedTypeParametersUsages();
-    private final Collection<ClassDescriptor> innerClasses = new LinkedHashSet<ClassDescriptor>();
+    private final Collection<ClassDescriptor> innerClasses = new LinkedHashSet<>();
 
     private ExpressionCodegen clInit;
     private NameGenerator inlineNameGenerator;
@@ -579,7 +579,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     }
 
     protected void generatePropertyMetadataArrayFieldIfNeeded(@NotNull Type thisAsmType) {
-        List<KtProperty> delegatedProperties = new ArrayList<KtProperty>();
+        List<KtProperty> delegatedProperties = new ArrayList<>();
         for (KtDeclaration declaration : ((KtDeclarationContainer) element).getDeclarations()) {
             if (declaration instanceof KtProperty) {
                 KtProperty property = (KtProperty) declaration;
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegenImpl.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegenImpl.java
index 7b1cd9836fe..dcc29e50272 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegenImpl.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegenImpl.java
@@ -99,7 +99,7 @@ public class PackageCodegenImpl implements PackageCodegen {
 
         boolean generatePackagePart = false;
 
-        List<KtClassOrObject> classOrObjects = new ArrayList<KtClassOrObject>();
+        List<KtClassOrObject> classOrObjects = new ArrayList<>();
 
         for (KtDeclaration declaration : file.getDeclarations()) {
             if (declaration.hasModifier(KtTokens.HEADER_KEYWORD)) continue;
@@ -135,7 +135,7 @@ public class PackageCodegenImpl implements PackageCodegen {
 
     @Nullable
     private PackageFragmentDescriptor getOnlyPackageFragment(@NotNull FqName expectedPackageFqName) {
-        SmartList<PackageFragmentDescriptor> fragments = new SmartList<PackageFragmentDescriptor>();
+        SmartList<PackageFragmentDescriptor> fragments = new SmartList<>();
         for (KtFile file : files) {
             PackageFragmentDescriptor fragment = state.getBindingContext().get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file);
             assert fragment != null : "package fragment is null for " + file + "\n" + file.getText();
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java
index 4bfc42340d9..d39bcf45ffd 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java
@@ -75,7 +75,7 @@ public class PackagePartCodegen extends MemberCodegen<KtFile> {
     }
 
     private void generateAnnotationsForPartClass() {
-        List<AnnotationDescriptor> fileAnnotationDescriptors = new ArrayList<AnnotationDescriptor>();
+        List<AnnotationDescriptor> fileAnnotationDescriptors = new ArrayList<>();
         for (KtAnnotationEntry annotationEntry : element.getAnnotationEntries()) {
             AnnotationDescriptor annotationDescriptor = state.getBindingContext().get(BindingContext.ANNOTATION, annotationEntry);
             if (annotationDescriptor != null) {
@@ -103,7 +103,7 @@ public class PackagePartCodegen extends MemberCodegen<KtFile> {
 
     @Override
     protected void generateKotlinMetadataAnnotation() {
-        List<DeclarationDescriptor> members = new ArrayList<DeclarationDescriptor>();
+        List<DeclarationDescriptor> members = new ArrayList<>();
         for (KtDeclaration declaration : element.getDeclarations()) {
             if (declaration instanceof KtNamedFunction) {
                 SimpleFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, declaration);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/TransformationMethodVisitor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/TransformationMethodVisitor.java
index 9c457ce9978..85138557e43 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/TransformationMethodVisitor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/TransformationMethodVisitor.java
@@ -45,7 +45,7 @@ public abstract class TransformationMethodVisitor extends MethodVisitor {
         super(Opcodes.ASM5);
         this.delegate = delegate;
         this.methodNode = new MethodNode(access, name, desc, signature, exceptions);
-        this.methodNode.localVariables = new ArrayList<LocalVariableNode>(5);
+        this.methodNode.localVariables = new ArrayList<>(5);
         this.mv = InlineCodegenUtil.wrapWithMaxLocalCalc(methodNode);
     }
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java
index a02b373c013..26b4f12b138 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java
@@ -70,10 +70,10 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
             TokenSet.create(PLUS, MINUS, MUL, DIV, PERC, RANGE, LT, GT, LTEQ, GTEQ, IDENTIFIER)
     );
 
-    private final Map<String, Integer> anonymousSubclassesCount = new HashMap<String, Integer>();
+    private final Map<String, Integer> anonymousSubclassesCount = new HashMap<>();
 
-    private final Stack<ClassDescriptor> classStack = new Stack<ClassDescriptor>();
-    private final Stack<String> nameStack = new Stack<String>();
+    private final Stack<ClassDescriptor> classStack = new Stack<>();
+    private final Stack<String> nameStack = new Stack<>();
 
     private final BindingTrace bindingTrace;
     private final BindingContext bindingContext;
@@ -638,7 +638,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         String currentClassName = getCurrentTopLevelClassOrPackagePartInternalName(expression.getContainingKtFile());
 
         if (bindingContext.get(MAPPINGS_FOR_WHENS_BY_ENUM_IN_CLASS_FILE, currentClassName) == null) {
-            bindingTrace.record(MAPPINGS_FOR_WHENS_BY_ENUM_IN_CLASS_FILE, currentClassName, new ArrayList<WhenByEnumsMapping>(1));
+            bindingTrace.record(MAPPINGS_FOR_WHENS_BY_ENUM_IN_CLASS_FILE, currentClassName, new ArrayList<>(1));
         }
 
         List<WhenByEnumsMapping> mappings = bindingContext.get(MAPPINGS_FOR_WHENS_BY_ENUM_IN_CLASS_FILE, currentClassName);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java
index d6c432ee77b..c741084072e 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java
@@ -181,7 +181,7 @@ public class CodegenBinding {
     ) {
         Collection<ClassDescriptor> innerClasses = bindingTrace.get(INNER_CLASSES, outer);
         if (innerClasses == null) {
-            innerClasses = new ArrayList<ClassDescriptor>(1);
+            innerClasses = new ArrayList<>(1);
             bindingTrace.record(INNER_CLASSES, outer, innerClasses);
         }
         innerClasses.add(inner);
@@ -192,14 +192,14 @@ public class CodegenBinding {
         // todo: we use Set and add given files but ignoring other scripts because something non-clear kept in binding
         // for scripts especially in case of REPL
 
-        Set<FqName> names = new HashSet<FqName>();
+        Set<FqName> names = new HashSet<>();
         for (KtFile file : files) {
             if (!file.isScript()) {
                 names.add(file.getPackageFqName());
             }
         }
 
-        Set<KtFile> answer = new HashSet<KtFile>();
+        Set<KtFile> answer = new HashSet<>();
         answer.addAll(files);
 
         for (FqName name : names) {
@@ -209,7 +209,7 @@ public class CodegenBinding {
             }
         }
 
-        List<KtFile> sortedAnswer = new ArrayList<KtFile>(answer);
+        List<KtFile> sortedAnswer = new ArrayList<>(answer);
 
         sortedAnswer.sort(Comparator.comparing((KtFile file) -> {
             VirtualFile virtualFile = file.getVirtualFile();
@@ -234,9 +234,9 @@ public class CodegenBinding {
         Collection<ClassDescriptor> innerClasses = bindingContext.get(INNER_CLASSES, outermostClass);
         if (innerClasses == null || innerClasses.isEmpty()) return Collections.emptySet();
 
-        Set<ClassDescriptor> allInnerClasses = new HashSet<ClassDescriptor>();
+        Set<ClassDescriptor> allInnerClasses = new HashSet<>();
 
-        Deque<ClassDescriptor> stack = new ArrayDeque<ClassDescriptor>(innerClasses);
+        Deque<ClassDescriptor> stack = new ArrayDeque<>(innerClasses);
         do {
             ClassDescriptor currentClass = stack.pop();
             if (allInnerClasses.add(currentClass)) {
@@ -247,7 +247,8 @@ public class CodegenBinding {
                     }
                 }
             }
-        } while (!stack.isEmpty());
+        }
+        while (!stack.isEmpty());
 
         return allInnerClasses;
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/MutableClosure.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/MutableClosure.java
index ff362a6b019..d5394e97d09 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/MutableClosure.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/MutableClosure.java
@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.codegen.binding;
 import com.intellij.openapi.util.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.codegen.StackValue;
 import org.jetbrains.kotlin.codegen.context.EnclosedValueDescriptor;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.types.KotlinType;
@@ -140,23 +139,23 @@ public final class MutableClosure implements CalculatedClosure {
 
     private void recordField(String name, Type type) {
         if (recordedFields == null) {
-            recordedFields = new LinkedList<Pair<String, Type>>();
+            recordedFields = new LinkedList<>();
         }
-        recordedFields.add(new Pair<String, Type>(name, type));
+        recordedFields.add(new Pair<>(name, type));
     }
 
     public void captureVariable(EnclosedValueDescriptor value) {
         recordField(value.getFieldName(), value.getType());
 
         if (captureVariables == null) {
-            captureVariables = new LinkedHashMap<DeclarationDescriptor, EnclosedValueDescriptor>();
+            captureVariables = new LinkedHashMap<>();
         }
         captureVariables.put(value.getDescriptor(), value);
     }
 
     public void setCapturedParameterOffsetInConstructor(DeclarationDescriptor descriptor, int offset) {
         if (parameterOffsetInConstructor == null) {
-            parameterOffsetInConstructor = new LinkedHashMap<DeclarationDescriptor, Integer>();
+            parameterOffsetInConstructor = new LinkedHashMap<>();
         }
         parameterOffsetInConstructor.put(descriptor, offset);
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java
index 6f2bd36e608..e6140e7af06 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java
@@ -425,10 +425,10 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
             boolean setterAccessorRequired
     ) {
         if (accessors == null) {
-            accessors = new LinkedHashMap<AccessorKey, AccessorForCallableDescriptor<?>>();
+            accessors = new LinkedHashMap<>();
         }
         if (propertyAccessorFactories == null) {
-            propertyAccessorFactories = new LinkedHashMap<AccessorKey, AccessorForPropertyDescriptorFactory>();
+            propertyAccessorFactories = new LinkedHashMap<>();
         }
 
         D descriptor = (D) possiblySubstitutedDescriptor.getOriginal();
@@ -661,7 +661,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
     private void addChild(@NotNull CodegenContext child) {
         if (shouldAddChild(child.contextDescriptor)) {
             if (childContexts == null) {
-                childContexts = new HashMap<DeclarationDescriptor, CodegenContext>();
+                childContexts = new HashMap<>();
             }
             DeclarationDescriptor childContextDescriptor = child.getContextDescriptor();
             childContexts.put(childContextDescriptor, child);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/FieldOwnerContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/FieldOwnerContext.java
index a4140565a92..2321e17ae85 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/FieldOwnerContext.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/FieldOwnerContext.java
@@ -32,7 +32,7 @@ import java.util.Map;
 
 public abstract class FieldOwnerContext<T extends DeclarationDescriptor> extends CodegenContext<T> {
     //default property name -> map<property descriptor -> bytecode name>
-    private final Map<String, Map<PropertyDescriptor, String>> fieldNames = new HashMap<String, Map<PropertyDescriptor, String>>();
+    private final Map<String, Map<PropertyDescriptor, String>> fieldNames = new HashMap<>();
 
     public FieldOwnerContext(
             @NotNull T contextDescriptor,
@@ -56,8 +56,7 @@ public abstract class FieldOwnerContext<T extends DeclarationDescriptor> extends
 
         String defaultPropertyName = KotlinTypeMapper.mapDefaultFieldName(descriptor, isDelegated);
 
-        Map<PropertyDescriptor, String> descriptor2Name =
-                fieldNames.computeIfAbsent(defaultPropertyName, unused -> new HashMap<PropertyDescriptor, String>());
+        Map<PropertyDescriptor, String> descriptor2Name = fieldNames.computeIfAbsent(defaultPropertyName, unused -> new HashMap<>());
 
         String actualName = descriptor2Name.get(descriptor);
         if (actualName != null) return actualName;
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java
index 5221e9d5796..99de43e10c1 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java
@@ -37,7 +37,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
     private final InliningContext inliningContext;
     private final Type oldObjectType;
     private final boolean isSameModule;
-    private final Map<String, List<String>> fieldNames = new HashMap<String, List<String>>();
+    private final Map<String, List<String>> fieldNames = new HashMap<>();
 
     private MethodNode constructor;
     private String sourceInfo;
@@ -58,9 +58,9 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
     @Override
     @NotNull
     public InlineResult doTransform(@NotNull FieldRemapper parentRemapper) {
-        List<InnerClassNode> innerClassNodes = new ArrayList<InnerClassNode>();
+        List<InnerClassNode> innerClassNodes = new ArrayList<>();
         ClassBuilder classBuilder = createRemappingClassBuilderViaFactory(inliningContext);
-        List<MethodNode> methodsToTransform = new ArrayList<MethodNode>();
+        List<MethodNode> methodsToTransform = new ArrayList<>();
 
         createClassReader().accept(new ClassVisitor(InlineCodegenUtil.API, classBuilder.getVisitor()) {
             @Override
@@ -139,7 +139,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
         List<CapturedParamInfo> additionalFakeParams =
                 extractParametersMappingAndPatchConstructor(constructor, allCapturedParamBuilder, constructorParamBuilder,
                                                             transformationInfo, parentRemapper);
-        List<DeferredMethodVisitor> deferringMethods = new ArrayList<DeferredMethodVisitor>();
+        List<DeferredMethodVisitor> deferringMethods = new ArrayList<>();
 
         generateConstructorAndFields(classBuilder, allCapturedParamBuilder, constructorParamBuilder, parentRemapper, additionalFakeParams);
 
@@ -243,7 +243,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
             @NotNull FieldRemapper parentRemapper,
             @NotNull List<CapturedParamInfo> constructorAdditionalFakeParams
     ) {
-        List<Type> descTypes = new ArrayList<Type>();
+        List<Type> descTypes = new ArrayList<>();
 
         Parameters constructorParams = constructorInlineBuilder.buildParameters();
         int[] capturedIndexes = new int[constructorParams.getParameters().size()];
@@ -364,10 +364,10 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
             @NotNull AnonymousObjectTransformationInfo transformationInfo,
             @NotNull FieldRemapper parentFieldRemapper
     ) {
-        Set<LambdaInfo> capturedLambdas = new LinkedHashSet<LambdaInfo>(); //captured var of inlined parameter
-        List<CapturedParamInfo> constructorAdditionalFakeParams = new ArrayList<CapturedParamInfo>();
+        Set<LambdaInfo> capturedLambdas = new LinkedHashSet<>(); //captured var of inlined parameter
+        List<CapturedParamInfo> constructorAdditionalFakeParams = new ArrayList<>();
         Map<Integer, LambdaInfo> indexToLambda = transformationInfo.getLambdasToInline();
-        Set<Integer> capturedParams = new HashSet<Integer>();
+        Set<Integer> capturedParams = new HashSet<>();
 
         //load captured parameters and patch instruction list (NB: there is also could be object fields)
         AbstractInsnNode cur = constructor.instructions.getFirst();
@@ -436,12 +436,12 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
 
         //For all inlined lambdas add their captured parameters
         //TODO: some of such parameters could be skipped - we should perform additional analysis
-        Map<String, LambdaInfo> capturedLambdasToInline = new HashMap<String, LambdaInfo>(); //captured var of inlined parameter
-        List<CapturedParamDesc> allRecapturedParameters = new ArrayList<CapturedParamDesc>();
+        Map<String, LambdaInfo> capturedLambdasToInline = new HashMap<>(); //captured var of inlined parameter
+        List<CapturedParamDesc> allRecapturedParameters = new ArrayList<>();
         boolean addCapturedNotAddOuter =
                 parentFieldRemapper.isRoot() ||
                 (parentFieldRemapper instanceof InlinedLambdaRemapper && parentFieldRemapper.getParent().isRoot());
-        Map<String, CapturedParamInfo> alreadyAdded = new HashMap<String, CapturedParamInfo>();
+        Map<String, CapturedParamInfo> alreadyAdded = new HashMap<>();
         for (LambdaInfo info : capturedLambdas) {
             if (addCapturedNotAddOuter) {
                 for (CapturedParamDesc desc : info.getCapturedVars()) {
@@ -524,7 +524,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
 
     @NotNull
     private String addUniqueField(@NotNull String name) {
-        List<String> existNames = fieldNames.computeIfAbsent(name, unused -> new LinkedList<String>());
+        List<String> existNames = fieldNames.computeIfAbsent(name, unused -> new LinkedList<>());
         String suffix = existNames.isEmpty() ? "" : "$" + existNames.size();
         String newName = name + suffix;
         existNames.add(newName);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineAdapter.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineAdapter.java
index a0963a05620..ec1cd1cbb40 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineAdapter.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineAdapter.java
@@ -29,7 +29,7 @@ import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil.getLoadStore
 
 public class InlineAdapter extends InstructionAdapter {
     private final SourceMapper sourceMapper;
-    private final List<CatchBlock> blocks = new ArrayList<CatchBlock>();
+    private final List<CatchBlock> blocks = new ArrayList<>();
 
     private boolean isLambdaInlining = false;
     private int nextLocalIndex = 0;
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java
index df20d590af1..2a2373e3eb7 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java
@@ -88,7 +88,7 @@ public class InlineCodegen extends CallGenerator {
     private final boolean isSameModule;
 
     private final ParametersBuilder invocationParamBuilder = ParametersBuilder.newBuilder();
-    private final Map<Integer, LambdaInfo> expressionMap = new HashMap<Integer, LambdaInfo>();
+    private final Map<Integer, LambdaInfo> expressionMap = new HashMap<>();
 
     private final ReifiedTypeInliner reifiedTypeInliner;
 
@@ -819,7 +819,7 @@ public class InlineCodegen extends CallGenerator {
 
     @NotNull
     public static Set<String> getDeclarationLabels(@Nullable PsiElement lambdaOrFun, @NotNull DeclarationDescriptor descriptor) {
-        Set<String> result = new HashSet<String>();
+        Set<String> result = new HashSet<>();
 
         if (lambdaOrFun != null) {
             Name label = LabelResolver.INSTANCE.getLabelNameIfAny(lambdaOrFun);
@@ -944,8 +944,7 @@ public class InlineCodegen extends CallGenerator {
     ) {
         if (!codegen.hasFinallyBlocks()) return;
 
-        Map<AbstractInsnNode, MethodInliner.PointForExternalFinallyBlocks> extensionPoints =
-                new HashMap<AbstractInsnNode, MethodInliner.PointForExternalFinallyBlocks>();
+        Map<AbstractInsnNode, MethodInliner.PointForExternalFinallyBlocks> extensionPoints = new HashMap<>();
         for (MethodInliner.PointForExternalFinallyBlocks insertPoint : insertPoints) {
             extensionPoints.put(insertPoint.beforeIns, insertPoint);
         }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.java
index d6edb98e76d..b9436ef8171 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.java
@@ -35,8 +35,7 @@ public class InliningContext {
     public final ReifiedTypeInliner reifiedTypeInliner;
     public final boolean isInliningLambda;
     public final boolean classRegeneration;
-    public final Map<String, AnonymousObjectTransformationInfo> internalNameToAnonymousObjectTransformationInfo =
-            new HashMap<String, AnonymousObjectTransformationInfo>();
+    public final Map<String, AnonymousObjectTransformationInfo> internalNameToAnonymousObjectTransformationInfo = new HashMap<>();
 
     private boolean isContinuation;
 
@@ -67,7 +66,7 @@ public class InliningContext {
 
     @NotNull
     public InliningContext subInlineLambda(@NotNull LambdaInfo lambdaInfo) {
-        Map<String, String> map = new HashMap<String, String>();
+        Map<String, String> map = new HashMap<>();
         map.put(lambdaInfo.getLambdaClassType().getInternalName(), null); //mark lambda inlined
         return subInline(nameGenerator.subGenerator("lambda"), map, true);
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InternalFinallyBlockInliner.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InternalFinallyBlockInliner.java
index c207fc5b188..b5e1d9c0617 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InternalFinallyBlockInliner.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InternalFinallyBlockInliner.java
@@ -67,12 +67,12 @@ public class InternalFinallyBlockInliner extends CoveringTryCatchNodeProcessor {
 
     public static void processInlineFunFinallyBlocks(@NotNull MethodNode inlineFun, int lambdaTryCatchBlockNodes, int finallyParamOffset) {
         int index = 0;
-        List<TryCatchBlockNodeInfo> inlineFunTryBlockInfo = new ArrayList<TryCatchBlockNodeInfo>();
+        List<TryCatchBlockNodeInfo> inlineFunTryBlockInfo = new ArrayList<>();
         for (TryCatchBlockNode block : inlineFun.tryCatchBlocks) {
             inlineFunTryBlockInfo.add(new TryCatchBlockNodeInfo(block, index++ < lambdaTryCatchBlockNodes));
         }
 
-        List<LocalVarNodeWrapper> localVars = new ArrayList<LocalVarNodeWrapper>();
+        List<LocalVarNodeWrapper> localVars = new ArrayList<>();
         for (LocalVariableNode var : inlineFun.localVariables) {
             localVars.add(new LocalVarNodeWrapper(var));
         }
@@ -132,7 +132,7 @@ public class InternalFinallyBlockInliner extends CoveringTryCatchNodeProcessor {
             }
 
             List<TryCatchBlockNodeInfo> currentCoveringNodesFromInnermost =
-                    sortTryCatchBlocks(new ArrayList<TryCatchBlockNodeInfo>(getTryBlocksMetaInfo().getCurrentIntervals()));
+                    sortTryCatchBlocks(new ArrayList<>(getTryBlocksMetaInfo().getCurrentIntervals()));
             checkCoveringBlocksInvariant(Lists.reverse(currentCoveringNodesFromInnermost));
 
             if (currentCoveringNodesFromInnermost.isEmpty() ||
@@ -285,7 +285,7 @@ public class InternalFinallyBlockInliner extends CoveringTryCatchNodeProcessor {
 
     @NotNull
     private static Set<LabelNode> rememberOriginalLabelNodes(@NotNull FinallyBlockInfo finallyInfo) {
-        Set<LabelNode> labelsInsideFinally = new HashSet<LabelNode>();
+        Set<LabelNode> labelsInsideFinally = new HashSet<>();
         for (AbstractInsnNode currentIns = finallyInfo.startIns; currentIns != finallyInfo.endInsExclusive; currentIns = currentIns.getNext()) {
             if (currentIns instanceof LabelNode) {
                 labelsInsideFinally.add((LabelNode) currentIns);
@@ -305,7 +305,7 @@ public class InternalFinallyBlockInliner extends CoveringTryCatchNodeProcessor {
 
         //copy tryCatchFinallies that totally in finally block
         List<TryBlockCluster<TryCatchBlockNodePosition>> clusters = TryBlockClusteringKt.doClustering(tryCatchBlockPresentInFinally);
-        Map<LabelNode, TryBlockCluster<TryCatchBlockNodePosition>> handler2Cluster = new HashMap<LabelNode, TryBlockCluster<TryCatchBlockNodePosition>>();
+        Map<LabelNode, TryBlockCluster<TryCatchBlockNodePosition>> handler2Cluster = new HashMap<>();
 
         IntervalMetaInfo<TryCatchBlockNodeInfo> tryBlocksMetaInfo = getTryBlocksMetaInfo();
         for (TryBlockCluster<TryCatchBlockNodePosition> cluster : clusters) {
@@ -418,7 +418,7 @@ public class InternalFinallyBlockInliner extends CoveringTryCatchNodeProcessor {
             @NotNull TryCatchBlockNodeInfo tryCatchBlock,
             @ReadOnly @NotNull List<TryCatchBlockNodeInfo> tryCatchBlocks
     ) {
-        List<TryCatchBlockNodeInfo> sameDefaultHandler = new ArrayList<TryCatchBlockNodeInfo>();
+        List<TryCatchBlockNodeInfo> sameDefaultHandler = new ArrayList<>();
         LabelNode defaultHandler = null;
         boolean afterStartBlock = false;
         for (TryCatchBlockNodeInfo block : tryCatchBlocks) {
@@ -486,8 +486,8 @@ public class InternalFinallyBlockInliner extends CoveringTryCatchNodeProcessor {
 
     @NotNull
     private List<TryCatchBlockNodePosition> findTryCatchBlocksInlinedInFinally(@NotNull FinallyBlockInfo finallyInfo) {
-        List<TryCatchBlockNodePosition> result = new ArrayList<TryCatchBlockNodePosition>();
-        Map<TryCatchBlockNodeInfo, TryCatchBlockNodePosition> processedBlocks = new HashMap<TryCatchBlockNodeInfo, TryCatchBlockNodePosition>();
+        List<TryCatchBlockNodePosition> result = new ArrayList<>();
+        Map<TryCatchBlockNodeInfo, TryCatchBlockNodePosition> processedBlocks = new HashMap<>();
 
         for (AbstractInsnNode curInstr = finallyInfo.startIns; curInstr != finallyInfo.endInsExclusive; curInstr = curInstr.getNext()) {
             if (!(curInstr instanceof LabelNode)) continue;
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java
index df2db844212..241fdc58dc7 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java
@@ -128,7 +128,7 @@ public class LambdaInfo implements LabelOwner {
     public List<CapturedParamDesc> getCapturedVars() {
         //lazy initialization cause it would be calculated after object creation
         if (capturedVars == null) {
-            capturedVars = new ArrayList<CapturedParamDesc>();
+            capturedVars = new ArrayList<>();
 
             if (closure.getCaptureThis() != null) {
                 Type type = typeMapper.mapType(closure.getCaptureThis());
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MaxStackFrameSizeAndLocalsCalculator.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MaxStackFrameSizeAndLocalsCalculator.java
index 00bc8f6cce8..b3ccb089c34 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MaxStackFrameSizeAndLocalsCalculator.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MaxStackFrameSizeAndLocalsCalculator.java
@@ -104,9 +104,8 @@ public class MaxStackFrameSizeAndLocalsCalculator extends MaxLocalsCalculator {
      */
     private int maxStack;
 
-
-    private final Collection<ExceptionHandler> exceptionHandlers = new LinkedList<ExceptionHandler>();
-    private final Map<Label, LabelWrapper> labelWrappersMap = new HashMap<Label, LabelWrapper>();
+    private final Collection<ExceptionHandler> exceptionHandlers = new LinkedList<>();
+    private final Map<Label, LabelWrapper> labelWrappersMap = new HashMap<>();
 
     public MaxStackFrameSizeAndLocalsCalculator(int api, int access, String descriptor, MethodVisitor mv) {
         super(api, access, descriptor, mv);
@@ -331,8 +330,8 @@ public class MaxStackFrameSizeAndLocalsCalculator extends MaxLocalsCalculator {
          * stack sizes of these blocks.
          */
         int max = 0;
-        Stack<LabelWrapper> stack = new Stack<LabelWrapper>();
-        Set<LabelWrapper> pushed = new HashSet<LabelWrapper>();
+        Stack<LabelWrapper> stack = new Stack<>();
+        Set<LabelWrapper> pushed = new HashSet<>();
 
         stack.push(firstLabel);
         pushed.add(firstLabel);
@@ -411,7 +410,7 @@ public class MaxStackFrameSizeAndLocalsCalculator extends MaxLocalsCalculator {
     private static class LabelWrapper {
         private final Label label;
         private LabelWrapper nextLabel = null;
-        private final Collection<ControlFlowEdge> successors = new LinkedList<ControlFlowEdge>();
+        private final Collection<ControlFlowEdge> successors = new LinkedList<>();
 
         private int outputStackMax = 0;
         private int inputStackSize = 0;
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/NameGenerator.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/NameGenerator.java
index 0be34e825cb..ede4d75e35d 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/NameGenerator.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/NameGenerator.java
@@ -29,7 +29,7 @@ public class NameGenerator {
     private int nextLambdaIndex = 1;
     private int nextWhenIndex = 1;
 
-    private final Map<String, NameGenerator> subGenerators = new HashMap<String, NameGenerator>();
+    private final Map<String, NameGenerator> subGenerators = new HashMap<>();
 
     public NameGenerator(String generatorClass) {
         this.generatorClass = generatorClass;
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxedValuesCollection.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxedValuesCollection.java
index 848062dfd7b..d906515c41f 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxedValuesCollection.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxedValuesCollection.java
@@ -23,7 +23,7 @@ import java.util.Iterator;
 import java.util.Set;
 
 public class RedundantBoxedValuesCollection implements Iterable<BoxedValueDescriptor> {
-    private final Set<BoxedValueDescriptor> safeToDeleteValues = new HashSet<BoxedValueDescriptor>();
+    private final Set<BoxedValueDescriptor> safeToDeleteValues = new HashSet<>();
 
     public void add(@NotNull BoxedValueDescriptor descriptor) {
         safeToDeleteValues.add(descriptor);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingMethodTransformer.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingMethodTransformer.java
index c243648b1e7..d6ee81866be 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingMethodTransformer.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingMethodTransformer.java
@@ -153,7 +153,7 @@ public class RedundantBoxingMethodTransformer extends MethodTransformer {
             @NotNull MethodNode node,
             @NotNull Frame<BasicValue>[] frames
     ) {
-        List<BasicValue> values = new ArrayList<BasicValue>();
+        List<BasicValue> values = new ArrayList<>();
         InsnList insnList = node.instructions;
         int from = insnList.indexOf(localVariableNode.start) + 1;
         int to = insnList.indexOf(localVariableNode.end) - 1;
@@ -192,7 +192,7 @@ public class RedundantBoxingMethodTransformer extends MethodTransformer {
 
     @NotNull
     private static int[] buildVariablesRemapping(@NotNull RedundantBoxedValuesCollection values, @NotNull MethodNode node) {
-        Set<Integer> doubleSizedVars = new HashSet<Integer>();
+        Set<Integer> doubleSizedVars = new HashSet<>();
         for (BoxedValueDescriptor valueDescriptor : values) {
             if (valueDescriptor.isDoubleSize()) {
                 doubleSizedVars.addAll(valueDescriptor.getVariablesIndexes());
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/transformer/MethodTransformer.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/transformer/MethodTransformer.java
index 1952be2fca3..a767672b920 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/transformer/MethodTransformer.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/transformer/MethodTransformer.java
@@ -41,7 +41,7 @@ public abstract class MethodTransformer {
             @NotNull MethodNode node,
             @NotNull Interpreter<V> interpreter
     ) {
-        return runAnalyzer(new Analyzer<V>(interpreter), internalClassName, node);
+        return runAnalyzer(new Analyzer<>(interpreter), internalClassName, node);
     }
 
     public abstract void transform(@NotNull String internalClassName, @NotNull MethodNode methodNode);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializationBindings.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializationBindings.java
index 8b70c2fd7d2..b438fc7078f 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializationBindings.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializationBindings.java
@@ -40,7 +40,7 @@ public final class JvmSerializationBindings {
 
         @NotNull
         public static <K, V> SerializationMappingSlice<K, V> create() {
-            return new SerializationMappingSlice<K, V>();
+            return new SerializationMappingSlice<>();
         }
     }
 
@@ -51,7 +51,7 @@ public final class JvmSerializationBindings {
 
         @NotNull
         public static <K> SerializationMappingSetSlice<K> create() {
-            return new SerializationMappingSetSlice<K>();
+            return new SerializationMappingSetSlice<>();
         }
     }
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/BothSignatureWriter.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/BothSignatureWriter.java
index 3881dfd06ef..c0819f2a01b 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/BothSignatureWriter.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/BothSignatureWriter.java
@@ -49,7 +49,7 @@ public class BothSignatureWriter extends JvmSignatureWriter {
         this.signatureVisitor = new CheckSignatureAdapter(mode.asmType, signatureWriter);
     }
 
-    private final Stack<SignatureVisitor> visitors = new Stack<SignatureVisitor>();
+    private final Stack<SignatureVisitor> visitors = new Stack<>();
 
     private void push(SignatureVisitor visitor) {
         visitors.push(visitor);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/JvmSignatureWriter.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/JvmSignatureWriter.java
index 341100dfc15..5b0486226da 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/JvmSignatureWriter.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/JvmSignatureWriter.java
@@ -32,7 +32,7 @@ import java.util.List;
 
 public class JvmSignatureWriter extends JvmDescriptorTypeWriter<Type> {
 
-    private final List<JvmMethodParameterSignature> kotlinParameterTypes = new ArrayList<JvmMethodParameterSignature>();
+    private final List<JvmMethodParameterSignature> kotlinParameterTypes = new ArrayList<>();
 
     private Type jvmReturnType;
 
@@ -149,7 +149,7 @@ public class JvmSignatureWriter extends JvmDescriptorTypeWriter<Type> {
 
     @NotNull
     public JvmMethodGenericSignature makeJvmMethodSignature(@NotNull String name) {
-        List<Type> types = new ArrayList<Type>(kotlinParameterTypes.size());
+        List<Type> types = new ArrayList<>(kotlinParameterTypes.size());
         for (JvmMethodParameterSignature parameter : kotlinParameterTypes) {
             types.add(parameter.getAsmType());
         }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingsClassesForWhenByEnum.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingsClassesForWhenByEnum.java
index 5ed81927b6a..01f2fb25878 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingsClassesForWhenByEnum.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingsClassesForWhenByEnum.java
@@ -28,7 +28,7 @@ import java.util.Set;
 
 public class MappingsClassesForWhenByEnum {
     private final GenerationState state;
-    private final Set<String> generatedMappingClasses = new HashSet<String>();
+    private final Set<String> generatedMappingClasses = new HashSet<>();
     private final MappingClassesForWhenByEnumCodegen mappingsCodegen;
 
     public MappingsClassesForWhenByEnum(@NotNull GenerationState state) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/StringSwitchCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/StringSwitchCodegen.java
index 6fbdb25a981..62cb7383d5a 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/StringSwitchCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/StringSwitchCodegen.java
@@ -55,12 +55,10 @@ public class StringSwitchCodegen extends SwitchCodegen {
 
         if (!transitionsTable.containsKey(hashCode)) {
             transitionsTable.put(hashCode, new Label());
-            hashCodesToStringAndEntryLabel.put(hashCode, new ArrayList<Pair<String, Label>>());
+            hashCodesToStringAndEntryLabel.put(hashCode, new ArrayList<>());
         }
 
-        hashCodesToStringAndEntryLabel.get(hashCode).add(
-                new Pair<String, Label>(((StringValue) constant).getValue(), entryLabel)
-        );
+        hashCodesToStringAndEntryLabel.get(hashCode).add(new Pair<>(((StringValue) constant).getValue(), entryLabel));
     }
 
     @Override
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegen.java
index 12978a17ecc..25776548b79 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegen.java
@@ -43,8 +43,8 @@ abstract public class SwitchCodegen {
     protected final Type resultType;
     protected final InstructionAdapter v;
 
-    protected final NavigableMap<Integer, Label> transitionsTable = new TreeMap<Integer, Label>();
-    protected final List<Label> entryLabels = new ArrayList<Label>();
+    protected final NavigableMap<Integer, Label> transitionsTable = new TreeMap<>();
+    protected final List<Label> entryLabels = new ArrayList<>();
     protected Label elseLabel = new Label();
     protected Label endLabel = new Label();
     protected Label defaultLabel;
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenUtil.java
index 543989efbff..b2489ae995d 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenUtil.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenUtil.java
@@ -66,7 +66,7 @@ public class SwitchCodegenUtil {
             @NotNull BindingContext bindingContext,
             boolean shouldInlineConstVals
     ) {
-        List<ConstantValue<?>> result = new ArrayList<ConstantValue<?>>();
+        List<ConstantValue<?>> result = new ArrayList<>();
 
         for (KtWhenEntry entry : expression.getEntries()) {
             addConstantsFromEntry(result, entry, bindingContext, shouldInlineConstVals);
@@ -97,7 +97,7 @@ public class SwitchCodegenUtil {
             @NotNull BindingContext bindingContext,
             boolean shouldInlineConstVals
     ) {
-        List<ConstantValue<?>> result = new ArrayList<ConstantValue<?>>();
+        List<ConstantValue<?>> result = new ArrayList<>();
         addConstantsFromEntry(result, entry, bindingContext, shouldInlineConstVals);
         return result;
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/WhenByEnumsMapping.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/WhenByEnumsMapping.java
index ec4ce719443..9b92224d004 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/WhenByEnumsMapping.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/WhenByEnumsMapping.java
@@ -27,7 +27,7 @@ public class WhenByEnumsMapping {
     public static final String MAPPING_ARRAY_FIELD_PREFIX = "$EnumSwitchMapping$";
     public static final String MAPPINGS_CLASS_NAME_POSTFIX = "$WhenMappings";
 
-    private final Map<EnumValue, Integer> map = new LinkedHashMap<EnumValue, Integer>();
+    private final Map<EnumValue, Integer> map = new LinkedHashMap<>();
     private final ClassDescriptor enumClassDescriptor;
     private final String outerClassInternalNameForExpression;
     private final String mappingsClassInternalName;
diff --git a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.java b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.java
index 7acdae33189..6b3d3a8bf86 100644
--- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.java
+++ b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.java
@@ -95,9 +95,9 @@ public abstract class CommonCompilerArguments implements Serializable {
     @ValueDescription(PLUGIN_OPTION_FORMAT)
     public String[] pluginOptions;
 
-    public List<String> freeArgs = new SmartList<String>();
+    public List<String> freeArgs = new SmartList<>();
 
-    public List<String> unknownExtraFlags = new SmartList<String>();
+    public List<String> unknownExtraFlags = new SmartList<>();
 
     @NotNull
     public static CommonCompilerArguments createDefaultInstance() {
diff --git a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/messages/GroupingMessageCollector.java b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/messages/GroupingMessageCollector.java
index 99befeddcb7..61462dd3d3d 100644
--- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/messages/GroupingMessageCollector.java
+++ b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/messages/GroupingMessageCollector.java
@@ -82,7 +82,7 @@ public class GroupingMessageCollector implements MessageCollector {
 
     @NotNull
     private Collection<String> sortedKeys() {
-        List<String> sortedKeys = new ArrayList<String>(groupedMessages.keySet());
+        List<String> sortedKeys = new ArrayList<>(groupedMessages.keySet());
         // ensure that messages with no location i.e. perf, incomplete hierarchy are always reported first
         sortedKeys.sort((o1, o2) -> {
             if (o1 == o2) return 0;
diff --git a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/modules/ModuleXmlParser.java b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/modules/ModuleXmlParser.java
index bac2db4278f..614683dc5b6 100644
--- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/modules/ModuleXmlParser.java
+++ b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/modules/ModuleXmlParser.java
@@ -75,7 +75,7 @@ public class ModuleXmlParser {
     }
 
     private final MessageCollector messageCollector;
-    private final List<Module> modules = new SmartList<Module>();
+    private final List<Module> modules = new SmartList<>();
     private DefaultHandler currentState;
 
     private ModuleXmlParser(@NotNull MessageCollector messageCollector) {
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.java b/compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.java
index 80b191320f9..f3798403a46 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.java
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.java
@@ -261,7 +261,7 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> {
             );
         }
 
-        Map<LanguageFeature, LanguageFeature.State> extraLanguageFeatures = new HashMap<LanguageFeature, LanguageFeature.State>(0);
+        Map<LanguageFeature, LanguageFeature.State> extraLanguageFeatures = new HashMap<>(0);
         if (arguments.multiPlatform) {
             extraLanguageFeatures.put(LanguageFeature.MultiPlatformProjects, LanguageFeature.State.ENABLED);
         }
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java b/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java
index 1be3e8df569..a7fe3f86544 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java
@@ -69,7 +69,7 @@ import static org.jetbrains.kotlin.cli.common.UtilsKt.checkKotlinPackageUsage;
 import static org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation.NO_LOCATION;
 
 public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
-    private static final Map<String, ModuleKind> moduleKindMap = new HashMap<String, ModuleKind>();
+    private static final Map<String, ModuleKind> moduleKindMap = new HashMap<>();
 
     static {
         moduleKindMap.put(K2JsArgumentConstants.MODULE_PLAIN, ModuleKind.PLAIN);
@@ -273,7 +273,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
             configuration.put(JSConfigurationKeys.META_INFO, true);
         }
 
-        List<String> libraries = new SmartList<String>();
+        List<String> libraries = new SmartList<>();
         if (!arguments.noStdlib) {
             libraries.add(0, PathUtil.getKotlinPathsForCompiler().getJsStdLibJarPath().getAbsolutePath());
         }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java
index c4339e8a5ca..5f4c574b6dc 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java
@@ -45,7 +45,7 @@ public class SingleAbstractMethodUtils {
 
     @NotNull
     public static List<CallableMemberDescriptor> getAbstractMembers(@NotNull KotlinType type) {
-        List<CallableMemberDescriptor> abstractMembers = new ArrayList<CallableMemberDescriptor>();
+        List<CallableMemberDescriptor> abstractMembers = new ArrayList<>();
         for (DeclarationDescriptor member : DescriptorUtils.getAllDescriptors(type.getMemberScope())) {
             if (member instanceof CallableMemberDescriptor && ((CallableMemberDescriptor) member).getModality() == Modality.ABSTRACT) {
                 abstractMembers.add((CallableMemberDescriptor) member);
@@ -104,8 +104,8 @@ public class SingleAbstractMethodUtils {
         KotlinType returnType = function.getReturnType();
         assert returnType != null : "function is not initialized: " + function;
         List<ValueParameterDescriptor> valueParameters = function.getValueParameters();
-        List<KotlinType> parameterTypes = new ArrayList<KotlinType>(valueParameters.size());
-        List<Name> parameterNames = new ArrayList<Name>(valueParameters.size());
+        List<KotlinType> parameterTypes = new ArrayList<>(valueParameters.size());
+        List<Name> parameterNames = new ArrayList<>(valueParameters.size());
 
         int startIndex = 0;
         KotlinType receiverType = null;
@@ -297,7 +297,7 @@ public class SingleAbstractMethodUtils {
             @NotNull TypeSubstitutor substitutor
     ) {
         List<ValueParameterDescriptor> originalValueParameters = original.getValueParameters();
-        List<ValueParameterDescriptor> valueParameters = new ArrayList<ValueParameterDescriptor>(originalValueParameters.size());
+        List<ValueParameterDescriptor> valueParameters = new ArrayList<>(originalValueParameters.size());
         for (ValueParameterDescriptor originalParam : originalValueParameters) {
             KotlinType originalType = originalParam.getType();
             KotlinType functionType = getFunctionTypeForSamType(originalType);
@@ -343,7 +343,7 @@ public class SingleAbstractMethodUtils {
             funTypeParameter.setInitialized();
         }
 
-        List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(traitToFunTypeParameters.values());
+        List<TypeParameterDescriptor> typeParameters = new ArrayList<>(traitToFunTypeParameters.values());
         return new TypeParameters(typeParameters, typeParametersSubstitutor);
     }
 
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierTypeImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierTypeImpl.java
index 30dd3474dff..4113bec8372 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierTypeImpl.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierTypeImpl.java
@@ -98,7 +98,7 @@ public class JavaClassifierTypeImpl extends JavaTypeImpl<PsiClassType> implement
 
         PsiSubstitutor substitutor = getSubstitutor();
 
-        List<JavaType> result = new ArrayList<JavaType>(parameters.size());
+        List<JavaType> result = new ArrayList<>(parameters.size());
         for (PsiTypeParameter typeParameter : parameters) {
             PsiType substitutedType = substitutor.substitute(typeParameter);
             result.add(substitutedType == null ? null : JavaTypeImpl.create(substitutedType));
@@ -124,7 +124,7 @@ public class JavaClassifierTypeImpl extends JavaTypeImpl<PsiClassType> implement
         while (currentOwner != null) {
             PsiTypeParameter[] typeParameters = currentOwner.getTypeParameters();
             if (typeParameters.length > 0) {
-                if (result == null) result = new ArrayList<PsiTypeParameter>(typeParameters.length);
+                if (result == null) result = new ArrayList<>(typeParameters.length);
                 Collections.addAll(result, typeParameters);
             }
 
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java
index acfbbdbcf44..7a849868a60 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java
@@ -69,7 +69,7 @@ public abstract class FileBasedKotlinClass implements KotlinJvmBinaryClass {
 
         public void add(@NotNull String name, @Nullable String outerName, @Nullable String innerName) {
             if (map == null) {
-                map = new HashMap<String, OuterAndInnerName>();
+                map = new HashMap<>();
             }
             map.put(name, new OuterAndInnerName(outerName, innerName));
         }
@@ -276,7 +276,7 @@ public abstract class FileBasedKotlinClass implements KotlinJvmBinaryClass {
             return ClassId.topLevel(new FqName(name.replace('/', '.')));
         }
 
-        List<String> classes = new ArrayList<String>(1);
+        List<String> classes = new ArrayList<>(1);
         boolean local = false;
         
         while (true) {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/AsmTypes.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/AsmTypes.java
index 757fc6530a1..57d9d32a909 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/AsmTypes.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/AsmTypes.java
@@ -24,7 +24,7 @@ import java.util.HashMap;
 import java.util.Map;
 
 public class AsmTypes {
-    private static final Map<Class<?>, Type> TYPES_MAP = new HashMap<Class<?>, Type>();
+    private static final Map<Class<?>, Type> TYPES_MAP = new HashMap<>();
 
     public static final Type OBJECT_TYPE = getType(Object.class);
     public static final Type JAVA_STRING_TYPE = getType(String.class);
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JavaResolverUtils.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JavaResolverUtils.java
index b3b90476ef6..4bd3efa48b8 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JavaResolverUtils.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JavaResolverUtils.java
@@ -22,13 +22,15 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.SourceElement;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
-import org.jetbrains.kotlin.load.java.structure.*;
 import org.jetbrains.kotlin.types.TypeConstructor;
 import org.jetbrains.kotlin.types.TypeProjection;
 import org.jetbrains.kotlin.types.TypeProjectionImpl;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 
-import java.util.*;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 
 public class JavaResolverUtils {
     private JavaResolverUtils() {
@@ -39,8 +41,7 @@ public class JavaResolverUtils {
             @Nullable DeclarationDescriptor newOwner
     ) {
         // LinkedHashMap to save the order of type parameters
-        Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> result =
-                new LinkedHashMap<TypeParameterDescriptor, TypeParameterDescriptorImpl>();
+        Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> result = new LinkedHashMap<>();
         for (TypeParameterDescriptor typeParameter : originalParameters) {
             result.put(typeParameter,
                        TypeParameterDescriptorImpl.createForFurtherModification(
@@ -61,7 +62,7 @@ public class JavaResolverUtils {
     public static TypeSubstitutor createSubstitutorForTypeParameters(
             @NotNull Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> originalToAltTypeParameters
     ) {
-        Map<TypeConstructor, TypeProjection> typeSubstitutionContext = new HashMap<TypeConstructor, TypeProjection>();
+        Map<TypeConstructor, TypeProjection> typeSubstitutionContext = new HashMap<>();
         for (Map.Entry<TypeParameterDescriptor, TypeParameterDescriptorImpl> originalToAltTypeParameter : originalToAltTypeParameters.entrySet()) {
             typeSubstitutionContext.put(originalToAltTypeParameter.getKey().getTypeConstructor(),
                                         new TypeProjectionImpl(originalToAltTypeParameter.getValue().getDefaultType()));
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/KotlinJavaPsiFacade.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/KotlinJavaPsiFacade.java
index 79935631d70..f4531859f52 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/KotlinJavaPsiFacade.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/KotlinJavaPsiFacade.java
@@ -197,7 +197,7 @@ public class KotlinJavaPsiFacade {
 
     @NotNull
     private KotlinPsiElementFinderWrapper[] calcFinders() {
-        List<KotlinPsiElementFinderWrapper> elementFinders = new ArrayList<KotlinPsiElementFinderWrapper>();
+        List<KotlinPsiElementFinderWrapper> elementFinders = new ArrayList<>();
         JavaFileManager javaFileManager = findJavaFileManager(project);
         elementFinders.add(
                 javaFileManager instanceof KotlinCliJavaFileManager
@@ -230,10 +230,10 @@ public class KotlinJavaPsiFacade {
     public PsiPackage findPackage(@NotNull String qualifiedName, GlobalSearchScope searchScope) {
         PackageCache cache = SoftReference.dereference(packageCache);
         if (cache == null) {
-            packageCache = new SoftReference<PackageCache>(cache = new PackageCache());
+            packageCache = new SoftReference<>(cache = new PackageCache());
         }
 
-        Pair<String, GlobalSearchScope> key = new Pair<String, GlobalSearchScope>(qualifiedName, searchScope);
+        Pair<String, GlobalSearchScope> key = new Pair<>(qualifiedName, searchScope);
         PsiPackage aPackage = cache.packageInScopeCache.get(key);
         if (aPackage != null) {
             return aPackage;
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java
index d5d98786aaa..813e89ab55f 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java
@@ -28,7 +28,7 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
 
     private static final DiagnosticParameterRenderer<ConflictingJvmDeclarationsData> CONFLICTING_JVM_DECLARATIONS_DATA =
             (data, context) -> {
-                List<DeclarationDescriptor> renderedDescriptors = new ArrayList<DeclarationDescriptor>();
+                List<DeclarationDescriptor> renderedDescriptors = new ArrayList<>();
                 for (JvmDeclarationOrigin origin : data.getSignatureOrigins()) {
                     DeclarationDescriptor descriptor = origin.getDescriptor();
                     if (descriptor != null) {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java
index ec3638cf7a5..fb99890befd 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java
@@ -48,7 +48,7 @@ public class SignaturesPropagationData {
     ).iterator().next();
 
     private final ValueParameters modifiedValueParameters;
-    private final List<String> signatureErrors = new ArrayList<String>(0);
+    private final List<String> signatureErrors = new ArrayList<>(0);
     private final List<FunctionDescriptor> superFunctions;
 
     public SignaturesPropagationData(
@@ -120,7 +120,7 @@ public class SignaturesPropagationData {
 
     private ValueParameters modifyValueParametersAccordingToSuperMethods(@NotNull List<ValueParameterDescriptor> parameters) {
         KotlinType resultReceiverType = null;
-        List<ValueParameterDescriptor> resultParameters = new ArrayList<ValueParameterDescriptor>(parameters.size());
+        List<ValueParameterDescriptor> resultParameters = new ArrayList<>(parameters.size());
 
         boolean shouldBeExtension = checkIfShouldBeExtension();
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/checkers/CheckerTestUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/checkers/CheckerTestUtil.java
index 4771dfd737a..9bbeeb8b636 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/checkers/CheckerTestUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/checkers/CheckerTestUtil.java
@@ -124,7 +124,7 @@ public class CheckerTestUtil {
             @Nullable List<DeclarationDescriptor> dynamicCallDescriptors,
             @Nullable String platform
     ) {
-        List<ActualDiagnostic> diagnostics = new ArrayList<ActualDiagnostic>();
+        List<ActualDiagnostic> diagnostics = new ArrayList<>();
         for (Diagnostic diagnostic : bindingContext.getDiagnostics().all()) {
             if (PsiTreeUtil.isAncestor(root, diagnostic.getPsiElement(), false)) {
                 diagnostics.add(new ActualDiagnostic(diagnostic, platform));
@@ -148,7 +148,7 @@ public class CheckerTestUtil {
             @Nullable List<DeclarationDescriptor> dynamicCallDescriptors,
             @Nullable String platform
     ) {
-        List<ActualDiagnostic> debugAnnotations = new ArrayList<ActualDiagnostic>();
+        List<ActualDiagnostic> debugAnnotations = new ArrayList<>();
 
         DebugInfoUtil.markDebugAnnotations(root, bindingContext, new DebugInfoUtil.DebugInfoReporter() {
             @Override
@@ -214,7 +214,7 @@ public class CheckerTestUtil {
             Collection<ActualDiagnostic> actual,
             DiagnosticDiffCallbacks callbacks
     ) {
-        Map<ActualDiagnostic, TextDiagnostic> diagnosticToExpectedDiagnostic = new HashMap<ActualDiagnostic, TextDiagnostic>();
+        Map<ActualDiagnostic, TextDiagnostic> diagnosticToExpectedDiagnostic = new HashMap<>();
 
         assertSameFile(actual);
 
@@ -358,7 +358,7 @@ public class CheckerTestUtil {
     public static String parseDiagnosedRanges(String text, List<DiagnosedRange> result) {
         Matcher matcher = RANGE_START_OR_END_PATTERN.matcher(text);
 
-        Stack<DiagnosedRange> opened = new Stack<DiagnosedRange>();
+        Stack<DiagnosedRange> opened = new Stack<>();
 
         int offsetCompensation = 0;
 
@@ -405,7 +405,7 @@ public class CheckerTestUtil {
         if (!diagnostics.isEmpty()) {
             List<DiagnosticDescriptor> diagnosticDescriptors = getSortedDiagnosticDescriptors(diagnostics);
 
-            Stack<DiagnosticDescriptor> opened = new Stack<DiagnosticDescriptor>();
+            Stack<DiagnosticDescriptor> opened = new Stack<>();
             ListIterator<DiagnosticDescriptor> iterator = diagnosticDescriptors.listIterator();
             DiagnosticDescriptor currentDescriptor = iterator.next();
 
@@ -623,7 +623,7 @@ public class CheckerTestUtil {
         }
 
         public Map<ActualDiagnostic, TextDiagnostic> getTextDiagnosticsMap() {
-            Map<ActualDiagnostic, TextDiagnostic> diagnosticMap = new HashMap<ActualDiagnostic, TextDiagnostic>();
+            Map<ActualDiagnostic, TextDiagnostic> diagnosticMap = new HashMap<>();
             for (ActualDiagnostic diagnostic : diagnostics) {
                 diagnosticMap.put(diagnostic, TextDiagnostic.asTextDiagnostic(diagnostic));
             }
@@ -700,7 +700,7 @@ public class CheckerTestUtil {
                 return new TextDiagnostic(name, platform, null);
             }
 
-            List<String> parsedParameters = new SmartList<String>();
+            List<String> parsedParameters = new SmartList<>();
             Matcher parametersMatcher = INDIVIDUAL_PARAMETER_PATTERN.matcher(parameters);
             while (parametersMatcher.find())
                 parsedParameters.add(unescape(parametersMatcher.group().trim()));
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/config/CompilerConfiguration.java b/compiler/frontend/src/org/jetbrains/kotlin/config/CompilerConfiguration.java
index 0beffb455ae..6600731d4a9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/config/CompilerConfiguration.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/config/CompilerConfiguration.java
@@ -26,7 +26,7 @@ import java.util.*;
 public class CompilerConfiguration {
     public static CompilerConfiguration EMPTY = new CompilerConfiguration();
 
-    private final Map<Key, Object> map = new HashMap<Key, Object>();
+    private final Map<Key, Object> map = new HashMap<>();
     private boolean readOnly = false;
 
     static {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/config/CompilerConfigurationKey.java b/compiler/frontend/src/org/jetbrains/kotlin/config/CompilerConfigurationKey.java
index 8970cfb5e50..62792e059e5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/config/CompilerConfigurationKey.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/config/CompilerConfigurationKey.java
@@ -29,7 +29,7 @@ public class CompilerConfigurationKey<T> {
 
     @NotNull
     public static <T> CompilerConfigurationKey<T> create(@NotNull @NonNls String name) {
-        return new CompilerConfigurationKey<T>(name);
+        return new CompilerConfigurationKey<>(name);
     }
 
     @Override
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory0.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory0.java
index 605ca6d4b2c..5b2771e38d6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory0.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory0.java
@@ -30,11 +30,11 @@ public class DiagnosticFactory0<E extends PsiElement> extends DiagnosticFactoryW
     }
 
     public static <T extends PsiElement> DiagnosticFactory0<T> create(Severity severity, PositioningStrategy<? super T> positioningStrategy) {
-        return new DiagnosticFactory0<T>(severity, positioningStrategy);
+        return new DiagnosticFactory0<>(severity, positioningStrategy);
     }
 
     @NotNull
     public SimpleDiagnostic<E> on(@NotNull E element) {
-        return new SimpleDiagnostic<E>(element, this, getSeverity());
+        return new SimpleDiagnostic<>(element, this, getSeverity());
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory1.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory1.java
index 9343ad7de2c..59dac2b1b81 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory1.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory1.java
@@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull;
 public class DiagnosticFactory1<E extends PsiElement, A> extends DiagnosticFactoryWithPsiElement<E, DiagnosticWithParameters1<E, A>> {
     @NotNull
     public ParametrizedDiagnostic<E> on(@NotNull E element, @NotNull A argument) {
-        return new DiagnosticWithParameters1<E, A>(element, argument, this, getSeverity());
+        return new DiagnosticWithParameters1<>(element, argument, this, getSeverity());
     }
 
     protected DiagnosticFactory1(Severity severity, PositioningStrategy<? super E> positioningStrategy) {
@@ -30,7 +30,7 @@ public class DiagnosticFactory1<E extends PsiElement, A> extends DiagnosticFacto
     }
 
     public static <T extends PsiElement, A> DiagnosticFactory1<T, A> create(Severity severity, PositioningStrategy<? super T> positioningStrategy) {
-        return new DiagnosticFactory1<T, A>(severity, positioningStrategy);
+        return new DiagnosticFactory1<>(severity, positioningStrategy);
     }
 
     public static <T extends PsiElement, A> DiagnosticFactory1<T, A> create(Severity severity) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory2.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory2.java
index 5a4f6f63916..df67b0eeb08 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory2.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory2.java
@@ -23,7 +23,7 @@ public class DiagnosticFactory2<E extends PsiElement, A, B> extends DiagnosticFa
 
     @NotNull
     public ParametrizedDiagnostic<E> on(@NotNull E element, @NotNull A a, @NotNull B b) {
-        return new DiagnosticWithParameters2<E, A, B>(element, a, b, this, getSeverity());
+        return new DiagnosticWithParameters2<>(element, a, b, this, getSeverity());
     }
 
     private DiagnosticFactory2(Severity severity, PositioningStrategy<? super E> positioningStrategy) {
@@ -31,11 +31,11 @@ public class DiagnosticFactory2<E extends PsiElement, A, B> extends DiagnosticFa
     }
 
     public static <T extends PsiElement, A, B> DiagnosticFactory2<T, A, B> create(Severity severity, PositioningStrategy<? super T> positioningStrategy) {
-        return new DiagnosticFactory2<T, A, B>(severity, positioningStrategy);
+        return new DiagnosticFactory2<>(severity, positioningStrategy);
     }
 
     public static <T extends PsiElement, A, B> DiagnosticFactory2<T, A, B> create(Severity severity) {
-        return new DiagnosticFactory2<T, A, B>(severity, PositioningStrategies.DEFAULT);
+        return new DiagnosticFactory2<>(severity, PositioningStrategies.DEFAULT);
     }
 
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory3.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory3.java
index 19dfe33a089..ae87aba7a3d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory3.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory3.java
@@ -30,11 +30,11 @@ public class DiagnosticFactory3<E extends PsiElement, A, B, C> extends Diagnosti
     }
 
     public static <T extends PsiElement, A, B, C> DiagnosticFactory3<T, A, B, C> create(Severity severity, PositioningStrategy<? super T> positioningStrategy) {
-        return new DiagnosticFactory3<T, A, B, C>(severity, positioningStrategy);
+        return new DiagnosticFactory3<>(severity, positioningStrategy);
     }
 
     @NotNull
     public ParametrizedDiagnostic<E> on(@NotNull E element, @NotNull A a, @NotNull B b, @NotNull C c) {
-        return new DiagnosticWithParameters3<E, A, B, C>(element, a, b, c, this, getSeverity());
+        return new DiagnosticWithParameters3<>(element, a, b, c, this, getSeverity());
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
index ddd876e7b66..85c3bfc08db 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
@@ -53,7 +53,7 @@ public class DefaultErrorMessages {
     private static final MappedExtensionProvider<Extension, List<DiagnosticFactoryToRendererMap>> RENDERER_MAPS = MappedExtensionProvider.create(
             Extension.EP_NAME,
             extensions -> {
-                List<DiagnosticFactoryToRendererMap> result = new ArrayList<DiagnosticFactoryToRendererMap>(extensions.size() + 1);
+                List<DiagnosticFactoryToRendererMap> result = new ArrayList<>(extensions.size() + 1);
                 for (Extension extension : extensions) {
                     result.add(extension.getMap());
                 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticFactoryToRendererMap.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticFactoryToRendererMap.java
index 86c55e78d23..c8ec0d03734 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticFactoryToRendererMap.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticFactoryToRendererMap.java
@@ -25,7 +25,7 @@ import java.util.HashMap;
 import java.util.Map;
 
 public final class DiagnosticFactoryToRendererMap {
-    private final Map<DiagnosticFactory<?>, DiagnosticRenderer<?>> map = new HashMap<DiagnosticFactory<?>, DiagnosticRenderer<?>>();
+    private final Map<DiagnosticFactory<?>, DiagnosticRenderer<?>> map = new HashMap<>();
     private boolean immutable = false;
 
     // TO catch EA-75872
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java
index 8c2279ca967..5f92c2741cc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java
@@ -225,7 +225,7 @@ public class TabledDescriptorRenderer {
 
     @NotNull
     protected static RenderingContext computeRenderingContext(@NotNull TableRenderer table) {
-        ArrayList<Object> toRender = new ArrayList<Object>();
+        ArrayList<Object> toRender = new ArrayList<>();
         for (TableRow row : table.rows) {
             if (row instanceof DescriptorRow) {
                 toRender.add(((DescriptorRow) row).descriptor);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/lexer/_JetLexer.java b/compiler/frontend/src/org/jetbrains/kotlin/lexer/_JetLexer.java
index 2467044ceb2..695a9609373 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/lexer/_JetLexer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/lexer/_JetLexer.java
@@ -18,13 +18,10 @@
 
 package org.jetbrains.kotlin.lexer;
 
-import java.util.*;
-import com.intellij.lexer.*;
-import com.intellij.psi.*;
+import com.intellij.lexer.FlexLexer;
+import com.intellij.psi.TokenType;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.util.containers.Stack;
-import org.jetbrains.kotlin.lexer.KotlinLexerException;
-import org.jetbrains.kotlin.lexer.KtTokens;
 
 
 /**
@@ -649,7 +646,7 @@ class _JetLexer implements FlexLexer {
         }
     }
 
-    private final Stack<State> states = new Stack<State>();
+    private final Stack<State> states = new Stack<>();
     private int lBraceCount;
 
     private int commentStart;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java
index af0575f230c..0af6879e70c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java
@@ -33,7 +33,7 @@ import java.util.Map;
 import static org.jetbrains.kotlin.lexer.KtTokens.*;
 
 /*package*/ abstract class AbstractKotlinParsing {
-    private static final Map<String, KtKeywordToken> SOFT_KEYWORD_TEXTS = new HashMap<String, KtKeywordToken>();
+    private static final Map<String, KtKeywordToken> SOFT_KEYWORD_TEXTS = new HashMap<>();
 
     static {
         for (IElementType type : KtTokens.SOFT_KEYWORDS.getTypes()) {
@@ -302,7 +302,7 @@ import static org.jetbrains.kotlin.lexer.KtTokens.*;
 
     protected int matchTokenStreamPredicate(TokenStreamPattern pattern) {
         PsiBuilder.Marker currentPosition = mark();
-        Stack<IElementType> opens = new Stack<IElementType>();
+        Stack<IElementType> opens = new Stack<>();
         int openAngleBrackets = 0;
         int openBraces = 0;
         int openParentheses = 0;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java
index cd4fdf7cc2c..c2e7c364a2e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java
@@ -237,7 +237,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing {
     public static final TokenSet ALL_OPERATIONS;
 
     static {
-        Set<IElementType> operations = new HashSet<IElementType>();
+        Set<IElementType> operations = new HashSet<>();
         Precedence[] values = Precedence.values();
         for (Precedence precedence : values) {
             operations.addAll(Arrays.asList(precedence.getOperations().getTypes()));
@@ -247,9 +247,9 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing {
 
     static {
         IElementType[] operations = OPERATIONS.getTypes();
-        Set<IElementType> opSet = new HashSet<IElementType>(Arrays.asList(operations));
+        Set<IElementType> opSet = new HashSet<>(Arrays.asList(operations));
         IElementType[] usedOperations = ALL_OPERATIONS.getTypes();
-        Set<IElementType> usedSet = new HashSet<IElementType>(Arrays.asList(usedOperations));
+        Set<IElementType> usedSet = new HashSet<>(Arrays.asList(usedOperations));
 
         if (opSet.size() > usedSet.size()) {
             opSet.removeAll(usedSet);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java
index 50163a07150..3066c3a262c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java
@@ -31,9 +31,9 @@ import static org.jetbrains.kotlin.lexer.KtTokens.*;
 
 public class SemanticWhitespaceAwarePsiBuilderImpl extends PsiBuilderAdapter implements SemanticWhitespaceAwarePsiBuilder {
     private final TokenSet complexTokens = TokenSet.create(SAFE_ACCESS, ELVIS, EXCLEXCL);
-    private final Stack<Boolean> joinComplexTokens = new Stack<Boolean>();
+    private final Stack<Boolean> joinComplexTokens = new Stack<>();
 
-    private final Stack<Boolean> newlinesEnabled = new Stack<Boolean>();
+    private final Stack<Boolean> newlinesEnabled = new Stack<>();
 
     private final PsiBuilderImpl delegateImpl;
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiUtil.java
index eb5e619d539..e1c9eca8ce1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiUtil.java
@@ -108,8 +108,8 @@ public class KtPsiUtil {
 
     @NotNull
     public static Set<KtElement> findRootExpressions(@NotNull Collection<KtElement> unreachableElements) {
-        Set<KtElement> rootElements = new HashSet<KtElement>();
-        Set<KtElement> shadowedElements = new HashSet<KtElement>();
+        Set<KtElement> rootElements = new HashSet<>();
+        Set<KtElement> shadowedElements = new HashSet<>();
         KtVisitorVoid shadowAllChildren = new KtVisitorVoid() {
             @Override
             public void visitKtElement(@NotNull KtElement element) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPlaceHolderStubElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPlaceHolderStubElementType.java
index b79734d61ac..386b010d8d8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPlaceHolderStubElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPlaceHolderStubElementType.java
@@ -29,14 +29,13 @@ import java.io.IOException;
 
 public class KtPlaceHolderStubElementType<T extends KtElementImplStub<? extends StubElement<?>>> extends
                                                                                                  KtStubElementType<KotlinPlaceHolderStub<T>, T> {
-
     public KtPlaceHolderStubElementType(@NotNull @NonNls String debugName, @NotNull Class<T> psiClass) {
         super(debugName, psiClass, KotlinPlaceHolderStub.class);
     }
 
     @Override
     public KotlinPlaceHolderStub<T> createStub(@NotNull T psi, StubElement parentStub) {
-        return new KotlinPlaceHolderStubImpl<T>(parentStub, this);
+        return new KotlinPlaceHolderStubImpl<>(parentStub, this);
     }
 
     @Override
@@ -47,6 +46,6 @@ public class KtPlaceHolderStubElementType<T extends KtElementImplStub<? extends
     @NotNull
     @Override
     public KotlinPlaceHolderStub<T> deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
-        return new KotlinPlaceHolderStubImpl<T>(parentStub, this);
+        return new KotlinPlaceHolderStubImpl<>(parentStub, this);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtStubElementTypes.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtStubElementTypes.java
index 1b1a6c88647..6df4c7b0865 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtStubElementTypes.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtStubElementTypes.java
@@ -31,89 +31,89 @@ public interface KtStubElementTypes {
     KtClassElementType ENUM_ENTRY = new KtClassElementType("ENUM_ENTRY");
     KtObjectElementType OBJECT_DECLARATION = new KtObjectElementType("OBJECT_DECLARATION");
     KtPlaceHolderStubElementType<KtClassInitializer> CLASS_INITIALIZER =
-            new KtPlaceHolderStubElementType<KtClassInitializer>("CLASS_INITIALIZER", KtClassInitializer.class);
+            new KtPlaceHolderStubElementType<>("CLASS_INITIALIZER", KtClassInitializer.class);
     KtPlaceHolderStubElementType<KtSecondaryConstructor> SECONDARY_CONSTRUCTOR =
-            new KtPlaceHolderStubElementType<KtSecondaryConstructor>("SECONDARY_CONSTRUCTOR", KtSecondaryConstructor.class);
+            new KtPlaceHolderStubElementType<>("SECONDARY_CONSTRUCTOR", KtSecondaryConstructor.class);
     KtPlaceHolderStubElementType<KtPrimaryConstructor> PRIMARY_CONSTRUCTOR =
-            new KtPlaceHolderStubElementType<KtPrimaryConstructor>("PRIMARY_CONSTRUCTOR", KtPrimaryConstructor.class);
+            new KtPlaceHolderStubElementType<>("PRIMARY_CONSTRUCTOR", KtPrimaryConstructor.class);
 
     KtParameterElementType VALUE_PARAMETER = new KtParameterElementType("VALUE_PARAMETER");
     KtPlaceHolderStubElementType<KtParameterList> VALUE_PARAMETER_LIST =
-            new KtPlaceHolderStubElementType<KtParameterList>("VALUE_PARAMETER_LIST", KtParameterList.class);
+            new KtPlaceHolderStubElementType<>("VALUE_PARAMETER_LIST", KtParameterList.class);
 
     KtTypeParameterElementType TYPE_PARAMETER = new KtTypeParameterElementType("TYPE_PARAMETER");
     KtPlaceHolderStubElementType<KtTypeParameterList> TYPE_PARAMETER_LIST =
-            new KtPlaceHolderStubElementType<KtTypeParameterList>("TYPE_PARAMETER_LIST", KtTypeParameterList.class);
+            new KtPlaceHolderStubElementType<>("TYPE_PARAMETER_LIST", KtTypeParameterList.class);
 
     KtAnnotationEntryElementType ANNOTATION_ENTRY = new KtAnnotationEntryElementType("ANNOTATION_ENTRY");
     KtPlaceHolderStubElementType<KtAnnotation> ANNOTATION =
-            new KtPlaceHolderStubElementType<KtAnnotation>("ANNOTATION", KtAnnotation.class);
+            new KtPlaceHolderStubElementType<>("ANNOTATION", KtAnnotation.class);
 
     KtAnnotationUseSiteTargetElementType ANNOTATION_TARGET = new KtAnnotationUseSiteTargetElementType("ANNOTATION_TARGET");
 
     KtPlaceHolderStubElementType<KtClassBody> CLASS_BODY =
-            new KtPlaceHolderStubElementType<KtClassBody>("CLASS_BODY", KtClassBody.class);
+            new KtPlaceHolderStubElementType<>("CLASS_BODY", KtClassBody.class);
 
     KtPlaceHolderStubElementType<KtImportList> IMPORT_LIST =
-            new KtPlaceHolderStubElementType<KtImportList>("IMPORT_LIST", KtImportList.class);
+            new KtPlaceHolderStubElementType<>("IMPORT_LIST", KtImportList.class);
 
     KtPlaceHolderStubElementType<KtFileAnnotationList> FILE_ANNOTATION_LIST =
-            new KtPlaceHolderStubElementType<KtFileAnnotationList>("FILE_ANNOTATION_LIST", KtFileAnnotationList.class);
+            new KtPlaceHolderStubElementType<>("FILE_ANNOTATION_LIST", KtFileAnnotationList.class);
 
     KtImportDirectiveElementType IMPORT_DIRECTIVE = new KtImportDirectiveElementType("IMPORT_DIRECTIVE");
 
     KtPlaceHolderStubElementType<KtPackageDirective> PACKAGE_DIRECTIVE =
-            new KtPlaceHolderStubElementType<KtPackageDirective>("PACKAGE_DIRECTIVE", KtPackageDirective.class);
+            new KtPlaceHolderStubElementType<>("PACKAGE_DIRECTIVE", KtPackageDirective.class);
 
     KtModifierListElementType<KtDeclarationModifierList> MODIFIER_LIST =
-            new KtModifierListElementType<KtDeclarationModifierList>("MODIFIER_LIST", KtDeclarationModifierList.class);
+            new KtModifierListElementType<>("MODIFIER_LIST", KtDeclarationModifierList.class);
 
     KtPlaceHolderStubElementType<KtTypeConstraintList> TYPE_CONSTRAINT_LIST =
-            new KtPlaceHolderStubElementType<KtTypeConstraintList>("TYPE_CONSTRAINT_LIST", KtTypeConstraintList.class);
+            new KtPlaceHolderStubElementType<>("TYPE_CONSTRAINT_LIST", KtTypeConstraintList.class);
 
     KtPlaceHolderStubElementType<KtTypeConstraint> TYPE_CONSTRAINT =
-            new KtPlaceHolderStubElementType<KtTypeConstraint>("TYPE_CONSTRAINT", KtTypeConstraint.class);
+            new KtPlaceHolderStubElementType<>("TYPE_CONSTRAINT", KtTypeConstraint.class);
 
     KtPlaceHolderStubElementType<KtNullableType> NULLABLE_TYPE =
-            new KtPlaceHolderStubElementType<KtNullableType>("NULLABLE_TYPE", KtNullableType.class);
+            new KtPlaceHolderStubElementType<>("NULLABLE_TYPE", KtNullableType.class);
 
     KtPlaceHolderStubElementType<KtTypeReference> TYPE_REFERENCE =
-            new KtPlaceHolderStubElementType<KtTypeReference>("TYPE_REFERENCE", KtTypeReference.class);
+            new KtPlaceHolderStubElementType<>("TYPE_REFERENCE", KtTypeReference.class);
 
     KtUserTypeElementType USER_TYPE = new KtUserTypeElementType("USER_TYPE");
     KtPlaceHolderStubElementType<KtDynamicType> DYNAMIC_TYPE =
-            new KtPlaceHolderStubElementType<KtDynamicType>("DYNAMIC_TYPE", KtDynamicType.class);
+            new KtPlaceHolderStubElementType<>("DYNAMIC_TYPE", KtDynamicType.class);
 
     KtPlaceHolderStubElementType<KtFunctionType> FUNCTION_TYPE =
-            new KtPlaceHolderStubElementType<KtFunctionType>("FUNCTION_TYPE", KtFunctionType.class);
+            new KtPlaceHolderStubElementType<>("FUNCTION_TYPE", KtFunctionType.class);
 
     KtTypeProjectionElementType TYPE_PROJECTION = new KtTypeProjectionElementType("TYPE_PROJECTION");
 
     KtPlaceHolderStubElementType<KtFunctionTypeReceiver> FUNCTION_TYPE_RECEIVER =
-            new KtPlaceHolderStubElementType<KtFunctionTypeReceiver>("FUNCTION_TYPE_RECEIVER", KtFunctionTypeReceiver.class);
+            new KtPlaceHolderStubElementType<>("FUNCTION_TYPE_RECEIVER", KtFunctionTypeReceiver.class);
 
     KtNameReferenceExpressionElementType REFERENCE_EXPRESSION = new KtNameReferenceExpressionElementType("REFERENCE_EXPRESSION");
     KtDotQualifiedExpressionElementType DOT_QUALIFIED_EXPRESSION = new KtDotQualifiedExpressionElementType("DOT_QUALIFIED_EXPRESSION");
     KtEnumEntrySuperClassReferenceExpressionElementType
             ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION = new KtEnumEntrySuperClassReferenceExpressionElementType("ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION");
     KtPlaceHolderStubElementType<KtTypeArgumentList> TYPE_ARGUMENT_LIST =
-            new KtPlaceHolderStubElementType<KtTypeArgumentList>("TYPE_ARGUMENT_LIST", KtTypeArgumentList.class);
+            new KtPlaceHolderStubElementType<>("TYPE_ARGUMENT_LIST", KtTypeArgumentList.class);
 
     KtPlaceHolderStubElementType<KtSuperTypeList> SUPER_TYPE_LIST =
-            new KtPlaceHolderStubElementType<KtSuperTypeList>("SUPER_TYPE_LIST", KtSuperTypeList.class);
+            new KtPlaceHolderStubElementType<>("SUPER_TYPE_LIST", KtSuperTypeList.class);
 
     KtPlaceHolderStubElementType<KtInitializerList> INITIALIZER_LIST =
-            new KtPlaceHolderStubElementType<KtInitializerList>("INITIALIZER_LIST", KtInitializerList.class);
+            new KtPlaceHolderStubElementType<>("INITIALIZER_LIST", KtInitializerList.class);
 
     KtPlaceHolderStubElementType<KtDelegatedSuperTypeEntry> DELEGATED_SUPER_TYPE_ENTRY =
-            new KtPlaceHolderStubElementType<KtDelegatedSuperTypeEntry>("DELEGATED_SUPER_TYPE_ENTRY", KtDelegatedSuperTypeEntry.class);
+            new KtPlaceHolderStubElementType<>("DELEGATED_SUPER_TYPE_ENTRY", KtDelegatedSuperTypeEntry.class);
 
     KtPlaceHolderStubElementType<KtSuperTypeCallEntry> SUPER_TYPE_CALL_ENTRY =
-            new KtPlaceHolderStubElementType<KtSuperTypeCallEntry>("SUPER_TYPE_CALL_ENTRY", KtSuperTypeCallEntry.class);
+            new KtPlaceHolderStubElementType<>("SUPER_TYPE_CALL_ENTRY", KtSuperTypeCallEntry.class);
     KtPlaceHolderStubElementType<KtSuperTypeEntry> SUPER_TYPE_ENTRY =
-            new KtPlaceHolderStubElementType<KtSuperTypeEntry>("SUPER_TYPE_ENTRY", KtSuperTypeEntry.class);
+            new KtPlaceHolderStubElementType<>("SUPER_TYPE_ENTRY", KtSuperTypeEntry.class);
     KtPlaceHolderStubElementType<KtConstructorCalleeExpression> CONSTRUCTOR_CALLEE =
-            new KtPlaceHolderStubElementType<KtConstructorCalleeExpression>("CONSTRUCTOR_CALLEE", KtConstructorCalleeExpression.class);
+            new KtPlaceHolderStubElementType<>("CONSTRUCTOR_CALLEE", KtConstructorCalleeExpression.class);
 
     KtScriptElementType SCRIPT = new KtScriptElementType("SCRIPT");
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzingUtils.java
index b468b661afb..1d5a9a9c814 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzingUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzingUtils.java
@@ -51,7 +51,7 @@ public class AnalyzingUtils {
     }
     
     public static List<PsiErrorElement> getSyntaxErrorRanges(@NotNull PsiElement root) {
-        List<PsiErrorElement> r = new ArrayList<PsiErrorElement>();
+        List<PsiErrorElement> r = new ArrayList<>();
         root.acceptChildren(new PsiErrorElementVisitor() {
             @Override
             public void visitErrorElement(@NotNull PsiErrorElement element) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolverImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolverImpl.java
index 5011d835dd1..4e9436ef077 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolverImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolverImpl.java
@@ -79,7 +79,7 @@ public class AnnotationResolverImpl extends AnnotationResolver {
             boolean shouldResolveArguments
     ) {
         if (annotationEntryElements.isEmpty()) return Annotations.Companion.getEMPTY();
-        List<AnnotationWithTarget> result = new ArrayList<AnnotationWithTarget>(0);
+        List<AnnotationWithTarget> result = new ArrayList<>(0);
 
         for (KtAnnotationEntry entryElement : annotationEntryElements) {
             AnnotationDescriptor descriptor = trace.get(BindingContext.ANNOTATION, entryElement);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java
index fd775952da8..c0019378ed9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java
@@ -97,10 +97,10 @@ public interface BindingContext {
 
     WritableSlice<KtTypeReference, KotlinType> TYPE = Slices.createSimpleSlice();
     WritableSlice<KtTypeReference, KotlinType> ABBREVIATED_TYPE = Slices.createSimpleSlice();
-    WritableSlice<KtExpression, KotlinTypeInfo> EXPRESSION_TYPE_INFO = new BasicWritableSlice<KtExpression, KotlinTypeInfo>(DO_NOTHING);
-    WritableSlice<KtExpression, DataFlowInfo> DATA_FLOW_INFO_BEFORE = new BasicWritableSlice<KtExpression, DataFlowInfo>(DO_NOTHING);
-    WritableSlice<KtExpression, KotlinType> EXPECTED_EXPRESSION_TYPE = new BasicWritableSlice<KtExpression, KotlinType>(DO_NOTHING);
-    WritableSlice<KtFunction, KotlinType> EXPECTED_RETURN_TYPE = new BasicWritableSlice<KtFunction, KotlinType>(DO_NOTHING);
+    WritableSlice<KtExpression, KotlinTypeInfo> EXPRESSION_TYPE_INFO = new BasicWritableSlice<>(DO_NOTHING);
+    WritableSlice<KtExpression, DataFlowInfo> DATA_FLOW_INFO_BEFORE = new BasicWritableSlice<>(DO_NOTHING);
+    WritableSlice<KtExpression, KotlinType> EXPECTED_EXPRESSION_TYPE = new BasicWritableSlice<>(DO_NOTHING);
+    WritableSlice<KtFunction, KotlinType> EXPECTED_RETURN_TYPE = new BasicWritableSlice<>(DO_NOTHING);
     WritableSlice<KtExpression, DataFlowInfo> DATAFLOW_INFO_AFTER_CONDITION = Slices.createSimpleSlice();
     WritableSlice<VariableDescriptor, DataFlowValue> BOUND_INITIALIZER_VALUE = Slices.createSimpleSlice();
     WritableSlice<KtExpression, LeakingThisDescriptor> LEAKING_THIS = Slices.createSimpleSlice();
@@ -108,26 +108,24 @@ public interface BindingContext {
     /**
      * A qualifier corresponds to a receiver expression (if any). For 'A.B' qualifier is recorded for 'A'.
      */
-    WritableSlice<KtExpression, Qualifier> QUALIFIER = new BasicWritableSlice<KtExpression, Qualifier>(DO_NOTHING);
+    WritableSlice<KtExpression, Qualifier> QUALIFIER = new BasicWritableSlice<>(DO_NOTHING);
 
-    WritableSlice<KtExpression, DoubleColonLHS> DOUBLE_COLON_LHS = new BasicWritableSlice<KtExpression, DoubleColonLHS>(DO_NOTHING);
+    WritableSlice<KtExpression, DoubleColonLHS> DOUBLE_COLON_LHS = new BasicWritableSlice<>(DO_NOTHING);
 
-    WritableSlice<KtSuperExpression, KotlinType> THIS_TYPE_FOR_SUPER_EXPRESSION =
-            new BasicWritableSlice<KtSuperExpression, KotlinType>(DO_NOTHING);
+    WritableSlice<KtSuperExpression, KotlinType> THIS_TYPE_FOR_SUPER_EXPRESSION = new BasicWritableSlice<>(DO_NOTHING);
 
-    WritableSlice<KtReferenceExpression, DeclarationDescriptor> REFERENCE_TARGET =
-            new BasicWritableSlice<KtReferenceExpression, DeclarationDescriptor>(DO_NOTHING);
+    WritableSlice<KtReferenceExpression, DeclarationDescriptor> REFERENCE_TARGET = new BasicWritableSlice<>(DO_NOTHING);
     // if 'A' really means 'A.Companion' then this slice stores class descriptor for A, REFERENCE_TARGET stores descriptor Companion in this case
     WritableSlice<KtReferenceExpression, ClassifierDescriptorWithTypeParameters> SHORT_REFERENCE_TO_COMPANION_OBJECT =
-            new BasicWritableSlice<KtReferenceExpression, ClassifierDescriptorWithTypeParameters>(DO_NOTHING);
+            new BasicWritableSlice<>(DO_NOTHING);
 
-    WritableSlice<Call, ResolvedCall<?>> RESOLVED_CALL = new BasicWritableSlice<Call, ResolvedCall<?>>(DO_NOTHING);
+    WritableSlice<Call, ResolvedCall<?>> RESOLVED_CALL = new BasicWritableSlice<>(DO_NOTHING);
     WritableSlice<Call, TailRecursionKind> TAIL_RECURSION_CALL = Slices.createSimpleSlice();
-    WritableSlice<KtElement, ConstraintSystemCompleter> CONSTRAINT_SYSTEM_COMPLETER = new BasicWritableSlice<KtElement, ConstraintSystemCompleter>(DO_NOTHING);
-    WritableSlice<KtElement, Call> CALL = new BasicWritableSlice<KtElement, Call>(DO_NOTHING);
+    WritableSlice<KtElement, ConstraintSystemCompleter> CONSTRAINT_SYSTEM_COMPLETER = new BasicWritableSlice<>(DO_NOTHING);
+    WritableSlice<KtElement, Call> CALL = new BasicWritableSlice<>(DO_NOTHING);
 
     WritableSlice<KtExpression, Collection<? extends DeclarationDescriptor>> AMBIGUOUS_REFERENCE_TARGET =
-            new BasicWritableSlice<KtExpression, Collection<? extends DeclarationDescriptor>>(DO_NOTHING);
+            new BasicWritableSlice<>(DO_NOTHING);
 
     WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_ITERATOR_RESOLVED_CALL = Slices.createSimpleSlice();
 
@@ -151,9 +149,9 @@ public interface BindingContext {
 
     WritableSlice<KtCollectionLiteralExpression, ResolvedCall<FunctionDescriptor>> COLLECTION_LITERAL_CALL = Slices.createSimpleSlice();
 
-    WritableSlice<KtExpression, ExplicitSmartCasts> SMARTCAST = new BasicWritableSlice<KtExpression, ExplicitSmartCasts>(DO_NOTHING);
+    WritableSlice<KtExpression, ExplicitSmartCasts> SMARTCAST = new BasicWritableSlice<>(DO_NOTHING);
     WritableSlice<KtExpression, Boolean> SMARTCAST_NULL = Slices.createSimpleSlice();
-    WritableSlice<KtExpression, ImplicitSmartCasts> IMPLICIT_RECEIVER_SMARTCAST = new BasicWritableSlice<KtExpression, ImplicitSmartCasts>(DO_NOTHING);
+    WritableSlice<KtExpression, ImplicitSmartCasts> IMPLICIT_RECEIVER_SMARTCAST = new BasicWritableSlice<>(DO_NOTHING);
 
     WritableSlice<KtWhenExpression, Boolean> EXHAUSTIVE_WHEN = Slices.createSimpleSlice();
     WritableSlice<KtWhenExpression, Boolean> IMPLICIT_EXHAUSTIVE_WHEN = Slices.createSimpleSlice();
@@ -173,8 +171,8 @@ public interface BindingContext {
     WritableSlice<KtElement, Boolean> USED_AS_RESULT_OF_LAMBDA = Slices.createSimpleSetSlice();
     WritableSlice<KtElement, Boolean> UNREACHABLE_CODE = Slices.createSimpleSetSlice();
 
-    WritableSlice<VariableDescriptor, CaptureKind> CAPTURED_IN_CLOSURE = new BasicWritableSlice<VariableDescriptor, CaptureKind>(DO_NOTHING);
-    WritableSlice<KtDeclaration, PreliminaryDeclarationVisitor> PRELIMINARY_VISITOR = new BasicWritableSlice<KtDeclaration, PreliminaryDeclarationVisitor>(DO_NOTHING);
+    WritableSlice<VariableDescriptor, CaptureKind> CAPTURED_IN_CLOSURE = new BasicWritableSlice<>(DO_NOTHING);
+    WritableSlice<KtDeclaration, PreliminaryDeclarationVisitor> PRELIMINARY_VISITOR = new BasicWritableSlice<>(DO_NOTHING);
 
     WritableSlice<Box<DeferredType>, Boolean> DEFERRED_TYPE = Slices.createCollectiveSetSlice();
 
@@ -255,8 +253,7 @@ public interface BindingContext {
     WritableSlice<ValueParameterDescriptor, FunctionDescriptor> DATA_CLASS_COMPONENT_FUNCTION = Slices.createSimpleSlice();
     WritableSlice<ClassDescriptor, FunctionDescriptor> DATA_CLASS_COPY_FUNCTION = Slices.createSimpleSlice();
 
-    WritableSlice<FqNameUnsafe, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR =
-            new BasicWritableSlice<FqNameUnsafe, ClassDescriptor>(DO_NOTHING, true);
+    WritableSlice<FqNameUnsafe, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR = new BasicWritableSlice<>(DO_NOTHING, true);
     WritableSlice<KtFile, PackageFragmentDescriptor> FILE_TO_PACKAGE_FRAGMENT = Slices.createSimpleSlice();
     WritableSlice<FqName, Collection<KtFile>> PACKAGE_TO_FILES = Slices.createSimpleSlice();
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java
index b6757a9daf7..43416da6256 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java
@@ -218,7 +218,7 @@ public class BindingContextUtils {
                     .getSourceFromDescriptor(containingFunctionDescriptor) : null;
         }
 
-        return new Pair<FunctionDescriptor, PsiElement>(containingFunctionDescriptor, containingFunction);
+        return new Pair<>(containingFunctionDescriptor, containingFunction);
     }
 
     @Nullable
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
index 9ea0de83893..66869225dc0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
@@ -447,7 +447,7 @@ public class BodyResolver {
                 currentDescriptor = (ClassDescriptor) currentDescriptor.getContainingDeclaration();
                 if (DescriptorUtils.isSealedClass(currentDescriptor)) {
                     if (parentEnumOrSealed.isEmpty()) {
-                        parentEnumOrSealed = new HashSet<TypeConstructor>();
+                        parentEnumOrSealed = new HashSet<>();
                     }
                     parentEnumOrSealed.add(currentDescriptor.getTypeConstructor());
                 }
@@ -891,7 +891,7 @@ public class BodyResolver {
             return;
         }
         // +1 is a work around against new Queue(0).addLast(...) bug // stepan.koltsov@ 2011-11-21
-        Queue<DeferredType> queue = new Queue<DeferredType>(deferredTypes.size() + 1);
+        Queue<DeferredType> queue = new Queue<>(deferredTypes.size() + 1);
         trace.addHandler(DEFERRED_TYPE, (deferredTypeKeyDeferredTypeWritableSlice, key, value) -> queue.addLast(key.getData()));
         for (Box<DeferredType> deferredType : deferredTypes) {
             queue.addLast(deferredType.getData());
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
index 820f521c612..c2031d8425c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
@@ -425,7 +425,7 @@ public class DescriptorResolver {
                containingDescriptor instanceof TypeAliasDescriptor
                 : "This method should be called for functions, properties, or type aliases, got " + containingDescriptor;
 
-        List<TypeParameterDescriptorImpl> result = new ArrayList<TypeParameterDescriptorImpl>();
+        List<TypeParameterDescriptorImpl> result = new ArrayList<>();
         for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) {
             KtTypeParameter typeParameter = typeParameters.get(i);
             result.add(resolveTypeParameterForDescriptor(containingDescriptor, scopeForAnnotationsResolve, typeParameter, i, trace));
@@ -558,8 +558,8 @@ public class DescriptorResolver {
     public static void checkUpperBoundTypes(@NotNull BindingTrace trace, @NotNull List<UpperBoundCheckRequest> requests) {
         if (requests.isEmpty()) return;
 
-        Set<Name> classBoundEncountered = new HashSet<Name>();
-        Set<Pair<Name, TypeConstructor>> allBounds = new HashSet<Pair<Name, TypeConstructor>>();
+        Set<Name> classBoundEncountered = new HashSet<>();
+        Set<Pair<Name, TypeConstructor>> allBounds = new HashSet<>();
 
         for (UpperBoundCheckRequest request : requests) {
             Name typeParameterName = request.typeParameterName;
@@ -567,7 +567,7 @@ public class DescriptorResolver {
             KtTypeReference upperBoundElement = request.upperBound;
 
             if (!upperBound.isError()) {
-                if (!allBounds.add(new Pair<Name, TypeConstructor>(typeParameterName, upperBound.getConstructor()))) {
+                if (!allBounds.add(new Pair<>(typeParameterName, upperBound.getConstructor()))) {
                     trace.report(REPEATED_BOUND.on(upperBoundElement));
                 }
                 else {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java
index 94bcf4b8772..504c6792278 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java
@@ -39,7 +39,7 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
 
     private final Map<KtClassOrObject, ClassDescriptorWithResolutionScopes> classes = Maps.newLinkedHashMap();
     private final Map<KtAnonymousInitializer, ClassDescriptorWithResolutionScopes> anonymousInitializers = Maps.newLinkedHashMap();
-    private final Set<KtFile> files = new LinkedHashSet<KtFile>();
+    private final Set<KtFile> files = new LinkedHashSet<>();
     private final Map<KtSecondaryConstructor, ClassConstructorDescriptor> secondaryConstructors = Maps.newLinkedHashMap();
 
     private final Map<KtNamedFunction, SimpleFunctionDescriptor> functions = Maps.newLinkedHashMap();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java
index f184b056226..0a9ae586bd1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java
@@ -317,8 +317,8 @@ public class ArgumentTypeResolver {
         List<KtParameter> valueParameters = function.getValueParameters();
         TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(
                 trace, "trace to resolve function literal parameter types");
-        List<KotlinType> parameterTypes = new ArrayList<KotlinType>(valueParameters.size());
-        List<Name> parameterNames = new ArrayList<Name>(valueParameters.size());
+        List<KotlinType> parameterTypes = new ArrayList<>(valueParameters.size());
+        List<Name> parameterNames = new ArrayList<>(valueParameters.size());
         for (KtParameter parameter : valueParameters) {
             parameterTypes.add(resolveTypeRefWithDefault(parameter.getTypeReference(), scope, temporaryTrace, DONT_CARE));
             Name name = parameter.getNameAsName();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
index 549150ecde2..c175b8bc776 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
@@ -295,7 +295,7 @@ public class CallResolver {
         KotlinType expectedType = NO_EXPECTED_TYPE;
         if (calleeExpression instanceof KtLambdaExpression) {
             int parameterNumber = ((KtLambdaExpression) calleeExpression).getValueParameters().size();
-            List<KotlinType> parameterTypes = new ArrayList<KotlinType>(parameterNumber);
+            List<KotlinType> parameterTypes = new ArrayList<>(parameterNumber);
             for (int i = 0; i < parameterNumber; i++) {
                 parameterTypes.add(NO_EXPECTED_TYPE);
             }
@@ -452,8 +452,7 @@ public class CallResolver {
             @NotNull BasicCallResolutionContext context
     ) {
         if (!(superType.getConstructor().getDeclarationDescriptor() instanceof ClassDescriptor)) {
-            return new Pair<Collection<ResolutionCandidate<ConstructorDescriptor>>, BasicCallResolutionContext>(
-                    Collections.<ResolutionCandidate<ConstructorDescriptor>>emptyList(), context);
+            return new Pair<>(Collections.<ResolutionCandidate<ConstructorDescriptor>>emptyList(), context);
         }
 
         // If any constructor has type parameter (currently it only can be true for ones from Java), try to infer arguments for them
@@ -470,7 +469,7 @@ public class CallResolver {
                         context.scope, context.call, superType, !anyConstructorHasDeclaredTypeParameters
                 );
 
-        return new Pair<Collection<ResolutionCandidate<ConstructorDescriptor>>, BasicCallResolutionContext>(candidates, context);
+        return new Pair<>(candidates, context);
     }
 
     private static boolean anyConstructorHasDeclaredTypeParameters(@Nullable ClassifierDescriptor classDescriptor) {
@@ -495,10 +494,9 @@ public class CallResolver {
 
             Set<ResolutionCandidate<FunctionDescriptor>> candidates = Collections.singleton(candidate);
 
-            ResolutionTask<FunctionDescriptor> resolutionTask =
-                    new ResolutionTask<FunctionDescriptor>(
-                            new NewResolutionOldInference.ResolutionKind.GivenCandidates<FunctionDescriptor>(), null, candidates
-                    );
+            ResolutionTask<FunctionDescriptor> resolutionTask = new ResolutionTask<>(
+                    new NewResolutionOldInference.ResolutionKind.GivenCandidates<>(), null, candidates
+            );
 
             return doResolveCallOrGetCachedResults(basicCallResolutionContext, resolutionTask, tracing);
         });
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ValueArgumentsToParametersMapper.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ValueArgumentsToParametersMapper.java
index 0bb73eb772f..cb4ca85f276 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ValueArgumentsToParametersMapper.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ValueArgumentsToParametersMapper.java
@@ -73,7 +73,7 @@ public class ValueArgumentsToParametersMapper {
             @NotNull MutableResolvedCall<D> candidateCall
     ) {
         //return new ValueArgumentsToParametersMapper().process(call, tracing, candidateCall, unmappedArguments);
-        Processor<D> processor = new Processor<D>(call, candidateCall, tracing);
+        Processor<D> processor = new Processor<>(call, candidateCall, tracing);
         processor.process();
         return processor.status;
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java
index 71924fe8d91..c62c9832405 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java
@@ -49,7 +49,7 @@ import static org.jetbrains.kotlin.resolve.inline.InlineUtil.checkNonLocalReturn
 
 class InlineChecker implements CallChecker {
     private final FunctionDescriptor descriptor;
-    private final Set<CallableDescriptor> inlinableParameters = new LinkedHashSet<CallableDescriptor>();
+    private final Set<CallableDescriptor> inlinableParameters = new LinkedHashSet<>();
     private final EffectiveVisibility inlineFunEffectiveVisibility;
     private final boolean isEffectivelyPrivateApiFunction;
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java
index e4e9c435989..fed3cfd68a6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java
@@ -72,7 +72,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
             @NotNull TracingStrategy tracing, @NotNull Call call,
             @NotNull CandidateResolveMode candidateResolveMode
     ) {
-        return new CallCandidateResolutionContext<D>(
+        return new CallCandidateResolutionContext<>(
                 candidateCall, tracing, trace, context.scope, call, context.expectedType,
                 context.dataFlowInfo, context.contextDependency, context.checkArguments,
                 context.resolutionResultsCache, context.dataFlowInfoForArguments,
@@ -85,7 +85,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
     public static <D extends CallableDescriptor> CallCandidateResolutionContext<D> createForCallBeingAnalyzed(
             @NotNull MutableResolvedCall<D> candidateCall, @NotNull BasicCallResolutionContext context, @NotNull TracingStrategy tracing
     ) {
-        return new CallCandidateResolutionContext<D>(
+        return new CallCandidateResolutionContext<>(
                 candidateCall, tracing, context.trace, context.scope, context.call, context.expectedType,
                 context.dataFlowInfo, context.contextDependency, context.checkArguments, context.resolutionResultsCache,
                 context.dataFlowInfoForArguments, context.statementFilter,
@@ -106,7 +106,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
             @NotNull CallPosition callPosition,
             @NotNull Function1<KtExpression, KtExpression> expressionContextProvider
     ) {
-        return new CallCandidateResolutionContext<D>(
+        return new CallCandidateResolutionContext<>(
                 candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
                 resolutionResultsCache, dataFlowInfoForArguments, statementFilter,
                 candidateResolveMode, isAnnotationContext, isDebuggerContext, collectAllCandidates, callPosition, expressionContextProvider);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintsUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintsUtil.java
index 2848813025a..ce37100cb72 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintsUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintsUtil.java
@@ -66,7 +66,7 @@ public class ConstraintsUtil {
                 context.put(typeVariable.getOriginalTypeParameter().getTypeConstructor(), typeProjection);
             }
         }
-        Collection<TypeSubstitutor> typeSubstitutors = new ArrayList<TypeSubstitutor>(substitutionContexts.size());
+        Collection<TypeSubstitutor> typeSubstitutors = new ArrayList<>(substitutionContexts.size());
         for (Map<TypeConstructor, TypeProjection> context : substitutionContexts) {
             typeSubstitutors.add(TypeSubstitutor.create(context));
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/DataFlowInfoForArgumentsImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/DataFlowInfoForArgumentsImpl.java
index 5fbd1b29ebd..78f997d5410 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/DataFlowInfoForArgumentsImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/DataFlowInfoForArgumentsImpl.java
@@ -44,7 +44,7 @@ public class DataFlowInfoForArgumentsImpl extends MutableDataFlowInfoForArgument
             ValueArgument argument = iterator.next();
             if (prev != null) {
                 if (nextArgument == null) {
-                    nextArgument = new HashMap<ValueArgument, ValueArgument>();
+                    nextArgument = new HashMap<>();
                 }
                 nextArgument.put(prev, argument);
             }
@@ -67,7 +67,7 @@ public class DataFlowInfoForArgumentsImpl extends MutableDataFlowInfoForArgument
         ValueArgument next = nextArgument == null ? null : nextArgument.get(valueArgument);
         if (next != null) {
             if (infoMap == null) {
-                infoMap = new HashMap<ValueArgument, DataFlowInfo>();
+                infoMap = new HashMap<>();
             }
             infoMap.put(next, dataFlowInfo);
             return;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java
index b11a67f86b7..6cb4b7971d9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java
@@ -53,7 +53,7 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
             @NotNull TracingStrategy tracing,
             @NotNull MutableDataFlowInfoForArguments dataFlowInfoForArguments
     ) {
-        return new ResolvedCallImpl<D>(candidate, trace, tracing, dataFlowInfoForArguments);
+        return new ResolvedCallImpl<>(candidate, trace, tracing, dataFlowInfoForArguments);
     }
 
     private final Call call;
@@ -212,7 +212,7 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
         List<ValueParameterDescriptor> substitutedParameters = resultingDescriptor.getValueParameters();
 
         Collection<Map.Entry<ValueParameterDescriptor, ResolvedValueArgument>> valueArgumentsBeforeSubstitution =
-                new SmartList<Map.Entry<ValueParameterDescriptor, ResolvedValueArgument>>(valueArguments.entrySet());
+                new SmartList<>(valueArguments.entrySet());
 
         valueArguments.clear();
 
@@ -223,7 +223,7 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
         }
 
         Collection<Map.Entry<ValueArgument, ArgumentMatchImpl>> unsubstitutedArgumentMappings =
-                new SmartList<Map.Entry<ValueArgument, ArgumentMatchImpl>>(argumentToParameterMap.entrySet());
+                new SmartList<>(argumentToParameterMap.entrySet());
 
         argumentToParameterMap.clear();
         for (Map.Entry<ValueArgument, ArgumentMatchImpl> entry : unsubstitutedArgumentMappings) {
@@ -283,7 +283,7 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
     @Nullable
     @Override
     public List<ResolvedValueArgument> getValueArgumentsByIndex() {
-        List<ResolvedValueArgument> arguments = new ArrayList<ResolvedValueArgument>(candidateDescriptor.getValueParameters().size());
+        List<ResolvedValueArgument> arguments = new ArrayList<>(candidateDescriptor.getValueParameters().size());
         for (int i = 0; i < candidateDescriptor.getValueParameters().size(); ++i) {
             arguments.add(null);
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadResolutionResultsImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadResolutionResultsImpl.java
index 83c5f02fc5d..d8e5783b90e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadResolutionResultsImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadResolutionResultsImpl.java
@@ -29,33 +29,33 @@ import java.util.Collections;
 public class OverloadResolutionResultsImpl<D extends CallableDescriptor> implements OverloadResolutionResults<D> {
 
     public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> success(@NotNull MutableResolvedCall<D> candidate) {
-        return new OverloadResolutionResultsImpl<D>(Code.SUCCESS, Collections.singleton(candidate));
+        return new OverloadResolutionResultsImpl<>(Code.SUCCESS, Collections.singleton(candidate));
     }
 
     public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> nameNotFound() {
-        OverloadResolutionResultsImpl<D> results = new OverloadResolutionResultsImpl<D>(
+        OverloadResolutionResultsImpl<D> results = new OverloadResolutionResultsImpl<>(
                 Code.NAME_NOT_FOUND, Collections.<MutableResolvedCall<D>>emptyList());
         results.setAllCandidates(Collections.<ResolvedCall<D>>emptyList());
         return results;
     }
 
     public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> singleFailedCandidate(MutableResolvedCall<D> candidate) {
-        return new OverloadResolutionResultsImpl<D>(Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH, Collections.singleton(candidate));
+        return new OverloadResolutionResultsImpl<>(Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH, Collections.singleton(candidate));
     }
     public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> manyFailedCandidates(Collection<MutableResolvedCall<D>> failedCandidates) {
-        return new OverloadResolutionResultsImpl<D>(Code.MANY_FAILED_CANDIDATES, failedCandidates);
+        return new OverloadResolutionResultsImpl<>(Code.MANY_FAILED_CANDIDATES, failedCandidates);
     }
 
     public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> candidatesWithWrongReceiver(Collection<MutableResolvedCall<D>> failedCandidates) {
-        return new OverloadResolutionResultsImpl<D>(Code.CANDIDATES_WITH_WRONG_RECEIVER, failedCandidates);
+        return new OverloadResolutionResultsImpl<>(Code.CANDIDATES_WITH_WRONG_RECEIVER, failedCandidates);
     }
 
     public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> ambiguity(Collection<MutableResolvedCall<D>> candidates) {
-        return new OverloadResolutionResultsImpl<D>(Code.AMBIGUITY, candidates);
+        return new OverloadResolutionResultsImpl<>(Code.AMBIGUITY, candidates);
     }
 
     public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> incompleteTypeInference(Collection<MutableResolvedCall<D>> candidates) {
-        return new OverloadResolutionResultsImpl<D>(Code.INCOMPLETE_TYPE_INFERENCE, candidates);
+        return new OverloadResolutionResultsImpl<>(Code.INCOMPLETE_TYPE_INFERENCE, candidates);
     }
 
     public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> incompleteTypeInference(MutableResolvedCall<D> candidate) {
@@ -148,7 +148,7 @@ public class OverloadResolutionResultsImpl<D extends CallableDescriptor> impleme
         assert isSingleResult() && getResultCode() == Code.INCOMPLETE_TYPE_INFERENCE :
                 "Only incomplete type inference status with one candidate can be changed to success: " +
                 getResultCode() + "\n" + getResultingCalls();
-        OverloadResolutionResultsImpl<D> newResults = new OverloadResolutionResultsImpl<D>(Code.SUCCESS, getResultingCalls());
+        OverloadResolutionResultsImpl<D> newResults = new OverloadResolutionResultsImpl<>(Code.SUCCESS, getResultingCalls());
         newResults.setAllCandidates(getAllCandidates());
         return newResults;
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java
index ec4b76002e8..3e0ea6f84d7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java
@@ -154,7 +154,7 @@ public class ResolutionResultsHandler {
                 if (severityLevel.contains(ARGUMENTS_MAPPING_ERROR)) {
                     @SuppressWarnings("unchecked")
                     OverloadingConflictResolver<MutableResolvedCall<D>> myResolver = (OverloadingConflictResolver) overloadingConflictResolver;
-                    return recordFailedInfo(tracing, trace, myResolver.filterOutEquivalentCalls(new LinkedHashSet<MutableResolvedCall<D>>(thisLevel)));
+                    return recordFailedInfo(tracing, trace, myResolver.filterOutEquivalentCalls(new LinkedHashSet<>(thisLevel)));
                 }
                 OverloadResolutionResultsImpl<D> results = chooseAndReportMaximallySpecific(
                         thisLevel, false, false, checkArgumentsMode, languageVersionSettings);
@@ -200,7 +200,7 @@ public class ResolutionResultsHandler {
 
         Set<MutableResolvedCall<D>> refinedCandidates = candidates;
         if (!languageVersionSettings.supportsFeature(LanguageFeature.RefinedSamAdaptersPriority)) {
-            Set<MutableResolvedCall<D>> nonSynthesized = new HashSet<MutableResolvedCall<D>>();
+            Set<MutableResolvedCall<D>> nonSynthesized = new HashSet<>();
             for (MutableResolvedCall<D> candidate : candidates) {
                 if (!TowerUtilsKt.isSynthesized(candidate.getCandidateDescriptor())) {
                     nonSynthesized.add(candidate);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionCandidate.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionCandidate.java
index c7b4527cfac..e732a09c35f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionCandidate.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionCandidate.java
@@ -45,15 +45,14 @@ public class ResolutionCandidate<D extends CallableDescriptor> {
     public static <D extends CallableDescriptor> ResolutionCandidate<D> create(
             @NotNull Call call, @NotNull D descriptor
     ) {
-        return new ResolutionCandidate<D>(call, descriptor, null, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, null);
+        return new ResolutionCandidate<>(call, descriptor, null, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, null);
     }
 
     public static <D extends CallableDescriptor> ResolutionCandidate<D> create(
             @NotNull Call call, @NotNull D descriptor, @Nullable TypeSubstitutor knownTypeParametersResultingSubstitutor
     ) {
-        return new ResolutionCandidate<D>(call, descriptor,
-                                          null, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER,
-                                          knownTypeParametersResultingSubstitutor);
+        return new ResolutionCandidate<>(call, descriptor, null, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER,
+                                         knownTypeParametersResultingSubstitutor);
     }
 
     public static <D extends CallableDescriptor> ResolutionCandidate<D> create(
@@ -61,8 +60,7 @@ public class ResolutionCandidate<D extends CallableDescriptor> {
             @NotNull ExplicitReceiverKind explicitReceiverKind,
             @Nullable TypeSubstitutor knownTypeParametersResultingSubstitutor
     ) {
-        return new ResolutionCandidate<D>(call, descriptor, dispatchReceiver, explicitReceiverKind,
-                                          knownTypeParametersResultingSubstitutor);
+        return new ResolutionCandidate<>(call, descriptor, dispatchReceiver, explicitReceiverKind, knownTypeParametersResultingSubstitutor);
     }
 
     public void setDispatchReceiver(@Nullable ReceiverValue dispatchReceiver) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/CallMaker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/CallMaker.java
index 42a8cdfe0a1..45e46499c81 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/CallMaker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/CallMaker.java
@@ -206,7 +206,7 @@ public class CallMaker {
             arguments = Collections.emptyList();
         }
         else {
-            arguments = new ArrayList<ValueArgument>(argumentExpressions.size());
+            arguments = new ArrayList<>(argumentExpressions.size());
             for (KtExpression argumentExpression : argumentExpressions) {
                 arguments.add(makeValueArgument(argumentExpression, calleeExpression));
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsElementsCache.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsElementsCache.java
index bc07515086e..c83d36b0c13 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsElementsCache.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsElementsCache.java
@@ -49,7 +49,7 @@ public class DiagnosticsElementsCache {
     }
 
     private static MultiMap<PsiElement, Diagnostic> buildElementToDiagnosticCache(Diagnostics diagnostics, Function1<Diagnostic, Boolean> filter) {
-        MultiMap<PsiElement, Diagnostic> elementToDiagnostic = new ConcurrentMultiMap<PsiElement, Diagnostic>();
+        MultiMap<PsiElement, Diagnostic> elementToDiagnostic = new ConcurrentMultiMap<>();
         for (Diagnostic diagnostic : diagnostics) {
             if (filter.invoke(diagnostic)) {
                 elementToDiagnostic.putValue(diagnostic.getPsiElement(), diagnostic);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsWithSuppression.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsWithSuppression.java
index 666342670b8..4034b27f304 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsWithSuppression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsWithSuppression.java
@@ -48,8 +48,7 @@ public class DiagnosticsWithSuppression implements Diagnostics {
     @NotNull
     @Override
     public Iterator<Diagnostic> iterator() {
-        return new FilteringIterator<Diagnostic, Diagnostic>(diagnostics.iterator(),
-                                                             diagnostic -> kotlinSuppressCache.getFilter().invoke(diagnostic));
+        return new FilteringIterator<>(diagnostics.iterator(), kotlinSuppressCache.getFilter()::invoke);
     }
 
     @NotNull
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java
index 9f11efeb5b6..9396a40cd9d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java
@@ -248,7 +248,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
         PackageMemberDeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(fqName.parent());
         if (provider == null) return Collections.emptyList();
 
-        Collection<ClassifierDescriptor> result = new SmartList<ClassifierDescriptor>();
+        Collection<ClassifierDescriptor> result = new SmartList<>();
 
         result.addAll(ContainerUtil.mapNotNull(
                 provider.getClassOrObjectDeclarations(fqName.shortName()),
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSessionUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSessionUtils.java
index fca54ee2af1..a9805565701 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSessionUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSessionUtils.java
@@ -54,7 +54,7 @@ public class ResolveSessionUtils {
     ) {
         if (fqName.isRoot()) return Collections.emptyList();
 
-        Collection<ClassDescriptor> result = new ArrayList<ClassDescriptor>(1);
+        Collection<ClassDescriptor> result = new ArrayList<>(1);
 
         FqName packageFqName = fqName.parent();
         while (true) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
index 2a2a004ab42..1adc92245a1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
@@ -166,7 +166,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
         this.isImpl = modifierList != null && modifierList.hasModifier(KtTokens.IMPL_KEYWORD);
 
         // Annotation entries are taken from both own annotations (if any) and object literal annotations (if any)
-        List<KtAnnotationEntry> annotationEntries = new ArrayList<KtAnnotationEntry>();
+        List<KtAnnotationEntry> annotationEntries = new ArrayList<>();
         if (classOrObject != null && classOrObject.getParent() instanceof KtObjectLiteralExpression) {
             // TODO: it would be better to have separate ObjectLiteralDescriptor without so much magic
             annotationEntries.addAll(KtPsiUtilKt.getAnnotationEntries((KtObjectLiteralExpression) classOrObject.getParent()));
@@ -241,7 +241,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
             List<KtTypeParameter> typeParameters = typeParameterList.getParameters();
             if (typeParameters.isEmpty()) return Collections.emptyList();
 
-            List<TypeParameterDescriptor> parameters = new ArrayList<TypeParameterDescriptor>(typeParameters.size());
+            List<TypeParameterDescriptor> parameters = new ArrayList<>(typeParameters.size());
 
             for (int i = 0; i < typeParameters.size(); i++) {
                 parameters.add(new LazyTypeParameterDescriptor(c, this, typeParameters.get(i), i));
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java
index cfcd6338e7e..f866e2fd7f4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java
@@ -73,7 +73,7 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri
     @NotNull
     @Override
     protected List<KotlinType> resolveUpperBounds() {
-        List<KotlinType> upperBounds = new ArrayList<KotlinType>(1);
+        List<KotlinType> upperBounds = new ArrayList<>(1);
 
         for (KtTypeReference typeReference : getAllUpperBounds()) {
             KotlinType resolvedType = resolveBoundType(typeReference);
@@ -99,7 +99,7 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri
     }
 
     private Collection<KtTypeReference> getUpperBoundsFromWhereClause() {
-        Collection<KtTypeReference> result = new ArrayList<KtTypeReference>();
+        Collection<KtTypeReference> result = new ArrayList<>();
 
         KtClassOrObject classOrObject = KtStubbedPsiUtil.getPsiOrStubParent(typeParameter, KtClassOrObject.class, true);
         if (classOrObject instanceof KtClass) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/BoundsSubstitutor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/BoundsSubstitutor.java
index 29d763ac17f..9f856bf39a6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/BoundsSubstitutor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/BoundsSubstitutor.java
@@ -52,7 +52,7 @@ public class BoundsSubstitutor {
 
     @NotNull
     private static TypeSubstitutor createUpperBoundsSubstitutor(@NotNull List<TypeParameterDescriptor> typeParameters) {
-        Map<TypeConstructor, TypeProjection> mutableSubstitution = new HashMap<TypeConstructor, TypeProjection>();
+        Map<TypeConstructor, TypeProjection> mutableSubstitution = new HashMap<>();
         TypeSubstitutor substitutor = TypeSubstitutor.create(mutableSubstitution);
 
         // todo assert: no loops
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/CommonSupertypes.java b/compiler/frontend/src/org/jetbrains/kotlin/types/CommonSupertypes.java
index b6f91326d8e..84f408eb739 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/CommonSupertypes.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/CommonSupertypes.java
@@ -80,8 +80,8 @@ public class CommonSupertypes {
     private static KotlinType findCommonSupertype(@NotNull Collection<KotlinType> types, int recursionDepth, int maxDepth) {
         assert recursionDepth <= maxDepth : "Recursion depth exceeded: " + recursionDepth + " > " + maxDepth + " for types " + types;
         boolean hasFlexible = false;
-        List<SimpleType> upper = new ArrayList<SimpleType>(types.size());
-        List<SimpleType> lower = new ArrayList<SimpleType>(types.size());
+        List<SimpleType> upper = new ArrayList<>(types.size());
+        List<SimpleType> lower = new ArrayList<>(types.size());
         for (KotlinType type : types) {
             UnwrappedType unwrappedType = type.unwrap();
             if (unwrappedType instanceof FlexibleType) {
@@ -110,7 +110,7 @@ public class CommonSupertypes {
     @NotNull
     private static SimpleType commonSuperTypeForInflexible(@NotNull Collection<SimpleType> types, int recursionDepth, int maxDepth) {
         assert !types.isEmpty();
-        Collection<SimpleType> typeSet = new HashSet<SimpleType>(types);
+        Collection<SimpleType> typeSet = new HashSet<>(types);
 
         // If any of the types is nullable, the result must be nullable
         // This also removed Nothing and Nothing? because they are subtypes of everything else
@@ -142,7 +142,7 @@ public class CommonSupertypes {
         // constructor of the supertype -> all of its instantiations occurring as supertypes
         Map<TypeConstructor, Set<SimpleType>> commonSupertypes = computeCommonRawSupertypes(typeSet);
         while (commonSupertypes.size() > 1) {
-            Set<SimpleType> merge = new HashSet<SimpleType>();
+            Set<SimpleType> merge = new HashSet<>();
             for (Set<SimpleType> supertypes : commonSupertypes.values()) {
                 merge.addAll(supertypes);
             }
@@ -164,12 +164,12 @@ public class CommonSupertypes {
     private static Map<TypeConstructor, Set<SimpleType>> computeCommonRawSupertypes(@NotNull Collection<SimpleType> types) {
         assert !types.isEmpty();
 
-        Map<TypeConstructor, Set<SimpleType>> constructorToAllInstances = new HashMap<TypeConstructor, Set<SimpleType>>();
+        Map<TypeConstructor, Set<SimpleType>> constructorToAllInstances = new HashMap<>();
         Set<TypeConstructor> commonSuperclasses = null;
 
         List<TypeConstructor> order = null;
         for (SimpleType type : types) {
-            Set<TypeConstructor> visited = new HashSet<TypeConstructor>();
+            Set<TypeConstructor> visited = new HashSet<>();
             order = topologicallySortSuperclassesAndRecordAllInstances(type, constructorToAllInstances, visited);
 
             if (commonSuperclasses == null) {
@@ -181,8 +181,8 @@ public class CommonSupertypes {
         }
         assert order != null;
 
-        Set<TypeConstructor> notSource = new HashSet<TypeConstructor>();
-        Map<TypeConstructor, Set<SimpleType>> result = new HashMap<TypeConstructor, Set<SimpleType>>();
+        Set<TypeConstructor> notSource = new HashSet<>();
+        Map<TypeConstructor, Set<SimpleType>> result = new HashMap<>();
         for (TypeConstructor superConstructor : order) {
             if (!commonSuperclasses.contains(superConstructor)) {
                 continue;
@@ -210,9 +210,9 @@ public class CommonSupertypes {
         }
 
         List<TypeParameterDescriptor> parameters = constructor.getParameters();
-        List<TypeProjection> newProjections = new ArrayList<TypeProjection>(parameters.size());
+        List<TypeProjection> newProjections = new ArrayList<>(parameters.size());
         for (TypeParameterDescriptor parameterDescriptor : parameters) {
-            Set<TypeProjection> typeProjections = new HashSet<TypeProjection>();
+            Set<TypeProjection> typeProjections = new HashSet<>();
             for (KotlinType type : types) {
                 typeProjections.add(type.getArguments().get(parameterDescriptor.getIndex()));
             }
@@ -255,8 +255,8 @@ public class CommonSupertypes {
             return TypeUtils.makeStarProjection(parameterDescriptor);
         }
 
-        Set<KotlinType> ins = new HashSet<KotlinType>();
-        Set<KotlinType> outs = new HashSet<KotlinType>();
+        Set<KotlinType> ins = new HashSet<>();
+        Set<KotlinType> outs = new HashSet<>();
 
         Variance variance = parameterDescriptor.getVariance();
         switch (variance) {
@@ -335,7 +335,7 @@ public class CommonSupertypes {
                 current -> {
                     TypeSubstitutor substitutor = TypeSubstitutor.create(current);
                     Collection<KotlinType> supertypes = current.getConstructor().getSupertypes();
-                    List<SimpleType> result = new ArrayList<SimpleType>(supertypes.size());
+                    List<SimpleType> result = new ArrayList<>(supertypes.size());
                     for (KotlinType supertype : supertypes) {
                         if (visited.contains(supertype.getConstructor())) {
                             continue;
@@ -348,9 +348,8 @@ public class CommonSupertypes {
                 new DFS.NodeHandlerWithListResult<SimpleType, TypeConstructor>() {
                     @Override
                     public boolean beforeChildren(SimpleType current) {
-                        Set<SimpleType> instances = constructorToAllInstances.computeIfAbsent(
-                                current.getConstructor(), k -> new HashSet<SimpleType>()
-                        );
+                        Set<SimpleType> instances =
+                                constructorToAllInstances.computeIfAbsent(current.getConstructor(), k -> new HashSet<>());
                         instances.add(current);
 
                         return true;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/DeferredType.java b/compiler/frontend/src/org/jetbrains/kotlin/types/DeferredType.java
index 4c682f46bea..5c7d348d7f2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/DeferredType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/DeferredType.java
@@ -40,7 +40,7 @@ public class DeferredType extends WrappedType {
             @NotNull Function0<KotlinType> compute
     ) {
         DeferredType deferredType = new DeferredType(storageManager.createLazyValue(compute));
-        trace.record(DEFERRED_TYPE, new Box<DeferredType>(deferredType));
+        trace.record(DEFERRED_TYPE, new Box<>(deferredType));
         return deferredType;
     }
     
@@ -53,7 +53,7 @@ public class DeferredType extends WrappedType {
         //noinspection unchecked
         DeferredType deferredType =
                 new DeferredType(storageManager.createLazyValueWithPostCompute(compute, RECURSION_PREVENTER, t -> null));
-        trace.record(DEFERRED_TYPE, new Box<DeferredType>(deferredType));
+        trace.record(DEFERRED_TYPE, new Box<>(deferredType));
         return deferredType;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/TypeIntersector.java b/compiler/frontend/src/org/jetbrains/kotlin/types/TypeIntersector.java
index dace818e7e1..b44931744c2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/TypeIntersector.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/TypeIntersector.java
@@ -37,7 +37,7 @@ import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getB
 public class TypeIntersector {
 
     public static boolean isIntersectionEmpty(@NotNull KotlinType typeA, @NotNull KotlinType typeB) {
-        return intersectTypes(KotlinTypeChecker.DEFAULT, new LinkedHashSet<KotlinType>(Arrays.asList(typeA, typeB))) == null;
+        return intersectTypes(KotlinTypeChecker.DEFAULT, new LinkedHashSet<>(Arrays.asList(typeA, typeB))) == null;
     }
 
     @Nullable
@@ -52,7 +52,7 @@ public class TypeIntersector {
         //   made nullable is they all were nullable
         KotlinType nothingOrNullableNothing = null;
         boolean allNullable = true;
-        List<KotlinType> nullabilityStripped = new ArrayList<KotlinType>(types.size());
+        List<KotlinType> nullabilityStripped = new ArrayList<>(types.size());
         for (KotlinType type : types) {
             if (type.isError()) continue;
 
@@ -73,7 +73,7 @@ public class TypeIntersector {
         }
 
         // Now we remove types that have subtypes in the list
-        List<KotlinType> resultingTypes = new ArrayList<KotlinType>();
+        List<KotlinType> resultingTypes = new ArrayList<>();
         outer:
         for (KotlinType type : nullabilityStripped) {
             if (!TypeUtils.canHaveSubtypes(typeChecker, type)) {
@@ -172,7 +172,7 @@ public class TypeIntersector {
 
         private static boolean unify(KotlinType withParameters, KotlinType expected) {
             // T -> how T is used
-            Map<TypeParameterDescriptor, Variance> parameters = new HashMap<TypeParameterDescriptor, Variance>();
+            Map<TypeParameterDescriptor, Variance> parameters = new HashMap<>();
             Function1<TypeParameterUsage, Unit> processor = parameterUsage -> {
                 Variance howTheTypeIsUsedBefore = parameters.get(parameterUsage.typeParameterDescriptor);
                 if (howTheTypeIsUsedBefore == null) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
index b02063cdee5..285e0d6f7b8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
@@ -251,7 +251,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         }
         else {
             Matcher matcher = FP_LITERAL_PARTS.matcher(text);
-            parts = new ArrayList<String>();
+            parts = new ArrayList<>();
             if (matcher.matches()) {
                 for (int i = 0; i < matcher.groupCount(); i++) {
                     parts.add(matcher.group(i + 1));
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java
index 31a9080fd83..40ccbd7658e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java
@@ -163,7 +163,7 @@ public class ControlStructureTypingUtils {
         KotlinType type = typeParameter.getDefaultType();
         KotlinType nullableType = TypeUtils.makeNullable(type);
 
-        List<ValueParameterDescriptor> valueParameters = new ArrayList<ValueParameterDescriptor>(argumentNames.size());
+        List<ValueParameterDescriptor> valueParameters = new ArrayList<>(argumentNames.size());
         for (int i = 0; i < argumentNames.size(); i++) {
             KotlinType argumentType = isArgumentNullable.get(i) ? nullableType : type;
             ValueParameterDescriptorImpl valueParameter = new ValueParameterDescriptorImpl(
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java
index 863b40efc79..45f7d430375 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java
@@ -481,7 +481,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
         KtExpression tryBlock = expression.getTryBlock();
         List<KtCatchClause> catchClauses = expression.getCatchClauses();
         KtFinallySection finallyBlock = expression.getFinallyBlock();
-        List<KotlinType> types = new ArrayList<KotlinType>();
+        List<KotlinType> types = new ArrayList<>();
         boolean nothingInAllCatchBranches = true;
         for (KtCatchClause catchClause : catchClauses) {
             KtParameter catchParameter = catchClause.getCatchParameter();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java
index 0ef8b54fe17..9e02b07c61e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java
@@ -124,7 +124,7 @@ public class DataFlowAnalyzer {
             ExpressionTypingContext context
     ) {
         if (condition == null) return context.dataFlowInfo;
-        Ref<DataFlowInfo> result = new Ref<DataFlowInfo>(null);
+        Ref<DataFlowInfo> result = new Ref<>(null);
         condition.accept(new KtVisitorVoid() {
             @Override
             public void visitIsExpression(@NotNull KtIsExpression expression) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java
index e9b002c9273..cfdf6af39e3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java
@@ -174,7 +174,7 @@ public class ExpressionTypingUtils {
 
     @NotNull
     public static List<KotlinType> getValueParametersTypes(@NotNull List<ValueParameterDescriptor> valueParameters) {
-        List<KotlinType> parameterTypes = new ArrayList<KotlinType>(valueParameters.size());
+        List<KotlinType> parameterTypes = new ArrayList<>(valueParameters.size());
         for (ValueParameterDescriptor parameter : valueParameters) {
             parameterTypes.add(parameter.getType());
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/SlicedMapImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/SlicedMapImpl.java
index 1682b55244c..07e8069e997 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/SlicedMapImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/SlicedMapImpl.java
@@ -35,7 +35,7 @@ public class SlicedMapImpl implements MutableSlicedMap {
         return new SlicedMapImpl();
     }
 
-    private final Map<Object, KeyFMap> map = new THashMap<Object, KeyFMap>(0);
+    private final Map<Object, KeyFMap> map = new THashMap<>(0);
     private Multimap<WritableSlice<?, ?>, Object> collectiveSliceKeys = null;
 
     @Override
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/Slices.java b/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/Slices.java
index 59247c25cac..d89a3312bde 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/Slices.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/Slices.java
@@ -51,23 +51,23 @@ public class Slices {
     }
 
     public static <K, V> SliceBuilder<K, V> sliceBuilder() {
-        return new SliceBuilder<K, V>(ONLY_REWRITE_TO_EQUAL);
+        return new SliceBuilder<>(ONLY_REWRITE_TO_EQUAL);
     }
 
     public static <K, V> WritableSlice<K, V> createSimpleSlice() {
-        return new BasicWritableSlice<K, V>(ONLY_REWRITE_TO_EQUAL);
+        return new BasicWritableSlice<>(ONLY_REWRITE_TO_EQUAL);
     }
 
     public static <K, V> WritableSlice<K, V> createCollectiveSlice() {
-        return new BasicWritableSlice<K, V>(ONLY_REWRITE_TO_EQUAL, true);
+        return new BasicWritableSlice<>(ONLY_REWRITE_TO_EQUAL, true);
     }
 
     public static <K> WritableSlice<K, Boolean> createSimpleSetSlice() {
-        return new SetSlice<K>(RewritePolicy.DO_NOTHING);
+        return new SetSlice<>(RewritePolicy.DO_NOTHING);
     }
 
     public static <K> WritableSlice<K, Boolean> createCollectiveSetSlice() {
-        return new SetSlice<K>(RewritePolicy.DO_NOTHING, true);
+        return new SetSlice<>(RewritePolicy.DO_NOTHING, true);
     }
 
     public static class SliceBuilder<K, V> {
@@ -115,7 +115,7 @@ public class Slices {
                     }
                 };
             }
-            return new BasicWritableSlice<K, V>(rewritePolicy);
+            return new BasicWritableSlice<>(rewritePolicy);
         }
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/TrackingSlicedMap.java b/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/TrackingSlicedMap.java
index 92d79c42ea8..3c98bfe8117 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/TrackingSlicedMap.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/TrackingSlicedMap.java
@@ -33,7 +33,7 @@ public class TrackingSlicedMap extends SlicedMapImpl {
     }
 
     private <K, V> SliceWithStackTrace<K, V> wrapSlice(ReadOnlySlice<K, V> slice) {
-        SliceWithStackTrace<?, ?> translated = sliceTranslationMap.computeIfAbsent(slice, k -> new SliceWithStackTrace<K, V>(slice));
+        SliceWithStackTrace<?, ?> translated = sliceTranslationMap.computeIfAbsent(slice, k -> new SliceWithStackTrace<>(slice));
         //noinspection unchecked
         return (SliceWithStackTrace) translated;
     }
@@ -58,7 +58,7 @@ public class TrackingSlicedMap extends SlicedMapImpl {
 
     @Override
     public <K, V> void put(WritableSlice<K, V> slice, K key, V value) {
-        super.put(wrapSlice(slice), key, new TrackableValue<V>(value, trackWithStackTraces));
+        super.put(wrapSlice(slice), key, new TrackableValue<>(value, trackWithStackTraces));
     }
 
     private static class TrackableValue<V> {
@@ -125,7 +125,7 @@ public class TrackingSlicedMap extends SlicedMapImpl {
 
         @Override
         public TrackableValue<V> computeValue(SlicedMap map, K key, TrackableValue<V> value, boolean valueNotFound) {
-            return new TrackableValue<V>(delegate.computeValue(map, key, value == null ? null : value.value, valueNotFound), trackWithStackTraces);
+            return new TrackableValue<>(delegate.computeValue(map, key, value == null ? null : value.value, valueNotFound), trackWithStackTraces);
         }
 
         @Override
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/StubClassBuilder.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/StubClassBuilder.java
index a833b9df6fa..c3d9f64d9ed 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/StubClassBuilder.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/StubClassBuilder.java
@@ -81,7 +81,7 @@ public class StubClassBuilder extends AbstractClassBuilder {
     ) {
         assert v == null : "defineClass() called twice?";
 
-        v = new StubBuildingVisitor<Object>(null, EMPTY_STRATEGY, parent, access, calculateShortName(name));
+        v = new StubBuildingVisitor<>(null, EMPTY_STRATEGY, parent, access, calculateShortName(name));
 
         super.defineClass(origin, version, access, name, signature, superName, interfaces);
 
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/finder/JavaElementFinder.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/finder/JavaElementFinder.java
index 7c4a85f9e7b..4f960012ae3 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/finder/JavaElementFinder.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/finder/JavaElementFinder.java
@@ -85,7 +85,7 @@ public class JavaElementFinder extends PsiElementFinder implements KotlinFinderM
             return PsiClass.EMPTY_ARRAY;
         }
 
-        List<PsiClass> answer = new SmartList<PsiClass>();
+        List<PsiClass> answer = new SmartList<>();
 
         FqName qualifiedName = new FqName(qualifiedNameString);
 
@@ -186,7 +186,7 @@ public class JavaElementFinder extends PsiElementFinder implements KotlinFinderM
     @NotNull
     @Override
     public PsiClass[] getClasses(@NotNull PsiPackage psiPackage, @NotNull GlobalSearchScope scope) {
-        List<PsiClass> answer = new SmartList<PsiClass>();
+        List<PsiClass> answer = new SmartList<>();
         FqName packageFQN = new FqName(psiPackage.getQualifiedName());
 
         answer.addAll(lightClassGenerationSupport.getFacadeClassesInPackage(packageFQN, scope));
diff --git a/compiler/preloader/instrumentation/src/org/jetbrains/kotlin/preloading/ProfilingInstrumenterExample.java b/compiler/preloader/instrumentation/src/org/jetbrains/kotlin/preloading/ProfilingInstrumenterExample.java
index c9be687583e..890fbef7b0e 100644
--- a/compiler/preloader/instrumentation/src/org/jetbrains/kotlin/preloading/ProfilingInstrumenterExample.java
+++ b/compiler/preloader/instrumentation/src/org/jetbrains/kotlin/preloading/ProfilingInstrumenterExample.java
@@ -84,15 +84,14 @@ public class ProfilingInstrumenterExample extends InterceptionInstrumenterAdapto
     public static Object c = new CollectFirstArguments();
 
     public static class CollectFirstArguments {
-
-        private final List<Object> arguments = new ArrayList<Object>(30000);
+        private final List<Object> arguments = new ArrayList<>(30000);
 
         public void enter(Object arg) {
             arguments.add(arg);
         }
 
         public void dump(PrintStream out) {
-            out.println("Different values: " + new HashSet<Object>(arguments).size());
+            out.println("Different values: " + new HashSet<>(arguments).size());
         }
     }
 
@@ -104,7 +103,7 @@ public class ProfilingInstrumenterExample extends InterceptionInstrumenterAdapto
     public static Object d = new MethodCollector();
 
     public static class MethodCollector {
-        private final Collection<String> collected = new LinkedHashSet<String>();
+        private final Collection<String> collected = new LinkedHashSet<>();
 
         public void enter(@ClassName String className, @MethodName String name, @MethodDesc String desc) {
             collected.add(className + "." + name + desc);
@@ -130,7 +129,7 @@ public class ProfilingInstrumenterExample extends InterceptionInstrumenterAdapto
     };
 
     public static abstract class FirstArgumentCollector {
-        private final Collection<Object> collected = new HashSet<Object>();
+        private final Collection<Object> collected = new HashSet<>();
 
         protected abstract boolean accept(Object arg);
 
diff --git a/compiler/preloader/instrumentation/src/org/jetbrains/kotlin/preloading/instrumentation/InterceptionInstrumenter.java b/compiler/preloader/instrumentation/src/org/jetbrains/kotlin/preloading/instrumentation/InterceptionInstrumenter.java
index 6f4164972a9..b00877dd34b 100644
--- a/compiler/preloader/instrumentation/src/org/jetbrains/kotlin/preloading/instrumentation/InterceptionInstrumenter.java
+++ b/compiler/preloader/instrumentation/src/org/jetbrains/kotlin/preloading/instrumentation/InterceptionInstrumenter.java
@@ -37,15 +37,15 @@ public class InterceptionInstrumenter {
     private static final Pattern ANYTHING = Pattern.compile(".*");
     private static final Type OBJECT_TYPE = Type.getType(Object.class);
 
-    private final Map<String, ClassMatcher> classPatterns = new LinkedHashMap<String, ClassMatcher>();
+    private final Map<String, ClassMatcher> classPatterns = new LinkedHashMap<>();
 
-    private final Set<String> neverMatchedClassPatterns = new LinkedHashSet<String>();
-    private final Set<MethodInstrumenter> neverMatchedInstrumenters = new LinkedHashSet<MethodInstrumenter>();
+    private final Set<String> neverMatchedClassPatterns = new LinkedHashSet<>();
+    private final Set<MethodInstrumenter> neverMatchedInstrumenters = new LinkedHashSet<>();
 
     interface DumpAction {
         void dump(PrintStream out);
     }
-    private final List<DumpAction> dumpTasks = new ArrayList<DumpAction>();
+    private final List<DumpAction> dumpTasks = new ArrayList<>();
 
     public InterceptionInstrumenter(List<Class<?>> handlerClasses) {
         for (Class<?> handlerClass : handlerClasses) {
@@ -75,10 +75,10 @@ public class InterceptionInstrumenter {
 
                 FieldData fieldData = getFieldData(field, interceptorClass);
 
-                List<MethodData> enterData = new ArrayList<MethodData>();
-                List<MethodData> normalReturnData = new ArrayList<MethodData>();
-                List<MethodData> exceptionData = new ArrayList<MethodData>();
-                List<Method> dumpMethods = new ArrayList<Method>();
+                List<MethodData> enterData = new ArrayList<>();
+                List<MethodData> normalReturnData = new ArrayList<>();
+                List<MethodData> exceptionData = new ArrayList<>();
+                List<Method> dumpMethods = new ArrayList<>();
                 for (Method method : interceptorClass.getMethods()) {
                     String name = method.getName();
                     MethodData methodData = getMethodData(fieldData, method);
@@ -237,7 +237,7 @@ public class InterceptionInstrumenter {
                 return data;
             }
 
-            List<MethodInstrumenter> applicableInstrumenters = new ArrayList<MethodInstrumenter>();
+            List<MethodInstrumenter> applicableInstrumenters = new ArrayList<>();
             for (Map.Entry<String, ClassMatcher> classPatternEntry : classPatterns.entrySet()) {
                 String classPattern = classPatternEntry.getKey();
                 ClassMatcher classMatcher = classPatternEntry.getValue();
@@ -266,7 +266,7 @@ public class InterceptionInstrumenter {
         ClassReader cr = new ClassReader(classData);
         ClassWriter cw = new ClassWriter(cr, 0);
         cr.accept(new ClassVisitor(ASM5, cw) {
-            private final Map<MethodInstrumenter, String> matchedMethods = new HashMap<MethodInstrumenter, String>();
+            private final Map<MethodInstrumenter, String> matchedMethods = new HashMap<>();
 
             @Override
             public MethodVisitor visitMethod(
@@ -280,7 +280,7 @@ public class InterceptionInstrumenter {
                 // Do not instrument synthetic methods
                 if ((access & (ACC_BRIDGE | ACC_SYNTHETIC)) != 0) return mv;
 
-                List<MethodInstrumenter> applicableInstrumenters = new ArrayList<MethodInstrumenter>();
+                List<MethodInstrumenter> applicableInstrumenters = new ArrayList<>();
                 for (MethodInstrumenter instrumenter : instrumenters) {
                     if (instrumenter.isApplicable(name, desc)) {
                         applicableInstrumenters.add(instrumenter);
@@ -294,9 +294,9 @@ public class InterceptionInstrumenter {
                 if (applicableInstrumenters.isEmpty()) return mv;
 
                 boolean dumpByteCode = false;
-                List<MethodData> normalReturnData = new ArrayList<MethodData>();
-                List<MethodData> enterData = new ArrayList<MethodData>();
-                List<MethodData> exceptionData = new ArrayList<MethodData>();
+                List<MethodData> normalReturnData = new ArrayList<>();
+                List<MethodData> enterData = new ArrayList<>();
+                List<MethodData> exceptionData = new ArrayList<>();
                 for (MethodInstrumenter instrumenter : applicableInstrumenters) {
                     enterData.addAll(instrumenter.getEnterData());
 
@@ -376,7 +376,7 @@ public class InterceptionInstrumenter {
             ) {
                 org.jetbrains.org.objectweb.asm.commons.Method methodBeingInstrumented = new org.jetbrains.org.objectweb.asm.commons.Method(name, desc);
 
-                List<MethodData> allData = new ArrayList<MethodData>();
+                List<MethodData> allData = new ArrayList<>();
                 allData.addAll(enterData);
                 allData.addAll(exceptionData);
                 allData.addAll(normalReturnData);
@@ -601,7 +601,7 @@ public class InterceptionInstrumenter {
 
     private static class ClassMatcher {
         private final Pattern classPattern;
-        private final List<MethodInstrumenter> instrumenters = new ArrayList<MethodInstrumenter>();
+        private final List<MethodInstrumenter> instrumenters = new ArrayList<>();
 
         private ClassMatcher(Pattern classPattern) {
             this.classPattern = classPattern;
diff --git a/compiler/preloader/src/org/jetbrains/kotlin/preloading/ClassPreloadingUtils.java b/compiler/preloader/src/org/jetbrains/kotlin/preloading/ClassPreloadingUtils.java
index 3d15d170dbb..ed9fd7eef24 100644
--- a/compiler/preloader/src/org/jetbrains/kotlin/preloading/ClassPreloadingUtils.java
+++ b/compiler/preloader/src/org/jetbrains/kotlin/preloading/ClassPreloadingUtils.java
@@ -57,7 +57,7 @@ public class ClassPreloadingUtils {
     }
 
     private static URLClassLoader createFallbackClassLoader(Collection<File> files) throws IOException {
-        List<URL> urls = new ArrayList<URL>(files.size());
+        List<URL> urls = new ArrayList<>(files.size());
         for (File file : files) {
             urls.add(file.toURI().toURL());
         }
@@ -76,7 +76,7 @@ public class ClassPreloadingUtils {
             return extractManifestClasspath((ResourceData) manifest);
         }
         else if (manifest instanceof ArrayList) {
-            List<File> result = new ArrayList<File>();
+            List<File> result = new ArrayList<>();
             for (ResourceData data : (ArrayList<ResourceData>) manifest) {
                 result.addAll(extractManifestClasspath(data));
             }
@@ -93,7 +93,7 @@ public class ClassPreloadingUtils {
         String classpathSpaceSeparated = (String) manifest.getMainAttributes().get(Attributes.Name.CLASS_PATH);
         if (classpathSpaceSeparated == null) return Collections.emptyList();
 
-        Collection<File> classpath = new ArrayList<File>(1);
+        Collection<File> classpath = new ArrayList<>(1);
         for (String jar : classpathSpaceSeparated.split(" ")) {
             if (".".equals(jar)) continue;
 
@@ -117,7 +117,7 @@ public class ClassPreloadingUtils {
             ClassHandler handler
     ) throws IOException {
         // 0.75 is HashMap.DEFAULT_LOAD_FACTOR
-        Map<String, Object> resources = new HashMap<String, Object>((int) (classNumberEstimate / 0.75));
+        Map<String, Object> resources = new HashMap<>((int) (classNumberEstimate / 0.75));
 
         for (File jarFile : jarFiles) {
             if (handler != null) {
@@ -154,7 +154,7 @@ public class ClassPreloadingUtils {
                         resources.put(name, resourceData);
                     }
                     else if (previous instanceof ResourceData) {
-                        List<ResourceData> list = new ArrayList<ResourceData>();
+                        List<ResourceData> list = new ArrayList<>();
                         list.add((ResourceData) previous);
                         list.add(resourceData);
                         resources.put(name, list);
diff --git a/compiler/preloader/src/org/jetbrains/kotlin/preloading/MemoryBasedClassLoader.java b/compiler/preloader/src/org/jetbrains/kotlin/preloading/MemoryBasedClassLoader.java
index 8b6efa9334c..316eaf41111 100644
--- a/compiler/preloader/src/org/jetbrains/kotlin/preloading/MemoryBasedClassLoader.java
+++ b/compiler/preloader/src/org/jetbrains/kotlin/preloading/MemoryBasedClassLoader.java
@@ -140,7 +140,7 @@ public class MemoryBasedClassLoader extends ClassLoader {
         Enumeration<URL> fromParent = parent.getResources(name);
         if (!own.hasMoreElements()) return fromParent;
 
-        List<URL> result = new ArrayList<URL>();
+        List<URL> result = new ArrayList<>();
         while (own.hasMoreElements()) {
             result.add(own.nextElement());
         }
@@ -163,7 +163,7 @@ public class MemoryBasedClassLoader extends ClassLoader {
         else {
             assert resources instanceof ArrayList : "Resource map should contain ResourceData or ArrayList<ResourceData>: " + name;
             List<ResourceData> resourceDatas = (ArrayList<ResourceData>) resources;
-            List<URL> urls = new ArrayList<URL>(resourceDatas.size());
+            List<URL> urls = new ArrayList<>(resourceDatas.size());
             for (ResourceData data : resourceDatas) {
                 urls.add(data.getURL());
             }
diff --git a/compiler/preloader/src/org/jetbrains/kotlin/preloading/Preloader.java b/compiler/preloader/src/org/jetbrains/kotlin/preloading/Preloader.java
index 4456af53450..a3f2047034a 100644
--- a/compiler/preloader/src/org/jetbrains/kotlin/preloading/Preloader.java
+++ b/compiler/preloader/src/org/jetbrains/kotlin/preloading/Preloader.java
@@ -91,7 +91,7 @@ public class Preloader {
         List<File> instrumenters = Collections.emptyList();
         int estimate = DEFAULT_CLASS_NUMBER_ESTIMATE;
         String mainClass = null;
-        List<String> arguments = new ArrayList<String>();
+        List<String> arguments = new ArrayList<>();
 
         for (int i = 0; i < args.length; i++) {
             String arg = args[i];
@@ -130,7 +130,7 @@ public class Preloader {
 
     private static List<File> parseClassPath(String classpath) {
         String[] paths = classpath.split(File.pathSeparator);
-        List<File> files = new ArrayList<File>(paths.length);
+        List<File> files = new ArrayList<>(paths.length);
         for (String path : paths) {
             File file = new File(path);
             if (!file.exists()) {
diff --git a/compiler/tests-common/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.java b/compiler/tests-common/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.java
index 1eaa78584ad..6da1571fc66 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.java
@@ -106,7 +106,7 @@ public abstract class KotlinMultiFileTestWithJava<M, F> extends KotlinTestWithEn
 
         String expectedText = KotlinTestUtils.doLoadFile(file);
 
-        Map<String, ModuleAndDependencies> modules = new HashMap<String, ModuleAndDependencies>();
+        Map<String, ModuleAndDependencies> modules = new HashMap<>();
 
         List<F> testFiles =
                 KotlinTestUtils.createTestFiles(file.getName(), expectedText, new KotlinTestUtils.TestFileFactory<M, F>() {
diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java
index 5b627cb13bc..64a251742aa 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java
@@ -45,7 +45,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
     protected void doMultiFileTest(@NotNull File wholeFile, @NotNull List<TestFile> files, @Nullable File javaFilesDir) throws Exception {
         TestJdkKind jdkKind = getJdkKind(files);
 
-        List<String> javacOptions = new ArrayList<String>(0);
+        List<String> javacOptions = new ArrayList<>(0);
         for (TestFile file : files) {
             if (InTextDirectivesUtils.isDirectiveDefined(file.content, "WITH_RUNTIME")) {
                 addRuntime = true;
@@ -79,7 +79,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
 
     @NotNull
     protected static List<String> findJavaSourcesInDirectory(@NotNull File directory) {
-        List<String> javaFilePaths = new ArrayList<String>(1);
+        List<String> javaFilePaths = new ArrayList<>(1);
 
         FileUtil.processFilesRecursively(directory, file -> {
             if (file.isFile() && FilesKt.getExtension(file).equals(JavaFileType.DEFAULT_EXTENSION)) {
diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java
index e765864b6e0..31066737455 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java
@@ -134,7 +134,7 @@ public abstract class AbstractCheckLocalVariablesTableTest extends TestCaseWithT
     @NotNull
     private static List<LocalVariable> readLocalVariable(ClassReader cr, String methodName) throws Exception {
         class Visitor extends ClassVisitor {
-            List<LocalVariable> readVariables = new ArrayList<LocalVariable>();
+            List<LocalVariable> readVariables = new ArrayList<>();
 
             public Visitor() {
                 super(Opcodes.ASM5);
diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java
index 01e084bea39..462d2d57d6e 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java
@@ -83,7 +83,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest
             System.out.println(result);
             throw ExceptionUtilsKt.rethrow(e);
         }
-        return new Pair<ClassFileFactory, ClassFileFactory>(factoryA, factoryB);
+        return new Pair<>(factoryA, factoryB);
     }
 
     private void invokeBox(@NotNull String className) throws Exception {
diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java
index 5614e4c9184..6eb282502b5 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java
@@ -82,9 +82,7 @@ public abstract class AbstractLineNumberTest extends TestCaseWithTmpdir {
             throw ExceptionUtilsKt.rethrow(e);
         }
 
-        return new Pair<KtFile, KotlinCoreEnvironment>(
-                KotlinTestUtils.createFile(file.getName(), text, environment.getProject()), environment
-        );
+        return new Pair<>(KotlinTestUtils.createFile(file.getName(), text, environment.getProject()), environment);
     }
 
     private void doTest(@NotNull String filename, boolean custom) {
@@ -206,8 +204,8 @@ public abstract class AbstractLineNumberTest extends TestCaseWithTmpdir {
 
     @NotNull
     private static List<String> readAllLineNumbers(@NotNull ClassReader reader) {
-        List<String> result = new ArrayList<String>();
-        Set<String> visitedLabels = new HashSet<String>();
+        List<String> result = new ArrayList<>();
+        Set<String> visitedLabels = new HashSet<>();
 
         reader.accept(new ClassVisitor(Opcodes.ASM5) {
             @Override
diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java
index d1aac9075a0..04de0b23f67 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java
@@ -39,7 +39,7 @@ public abstract class AbstractTopLevelMembersInvocationTest extends AbstractByte
     @Override
     public void doTest(@NotNull String filename) throws Exception {
         File root = new File(filename);
-        List<String> sourceFiles = new ArrayList<String>(2);
+        List<String> sourceFiles = new ArrayList<>(2);
 
         FileUtil.processFilesRecursively(root, file -> {
             if (file.getName().endsWith(".kt")) {
diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestCase.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestCase.java
index 0f8f3497c31..41a75223410 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestCase.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestCase.java
@@ -143,7 +143,7 @@ public abstract class CodegenTestCase extends KtUsefulTestCase {
             @NotNull List<TestFile> testFilesWithConfigurationDirectives,
             @NotNull CompilerConfiguration configuration
     ) {
-        List<String> kotlinConfigurationFlags = new ArrayList<String>(0);
+        List<String> kotlinConfigurationFlags = new ArrayList<>(0);
         LanguageVersion explicitLanguageVersion = null;
         for (TestFile testFile : testFilesWithConfigurationDirectives) {
             kotlinConfigurationFlags.addAll(InTextDirectivesUtils.findListWithPrefixes(testFile.content, "// KOTLIN_CONFIGURATION_FLAGS:"));
@@ -288,10 +288,10 @@ public abstract class CodegenTestCase extends KtUsefulTestCase {
     public static CodegenTestFiles loadMultiFiles(@NotNull List<TestFile> files, @NotNull Project project) {
         Collections.sort(files);
 
-        List<KtFile> ktFiles = new ArrayList<KtFile>(files.size());
+        List<KtFile> ktFiles = new ArrayList<>(files.size());
         for (TestFile file : files) {
             if (file.name.endsWith(".kt")) {
-                String content = CheckerTestUtil.parseDiagnosedRanges(file.content, new ArrayList<CheckerTestUtil.DiagnosedRange>(0));
+                String content = CheckerTestUtil.parseDiagnosedRanges(file.content, new ArrayList<>(0));
                 ktFiles.add(KotlinTestUtils.createFile(file.name, content, project));
             }
         }
@@ -436,7 +436,7 @@ public abstract class CodegenTestCase extends KtUsefulTestCase {
 
         SimpleVerifier verifier = new SimpleVerifier();
         verifier.setClassLoader(loader);
-        Analyzer<BasicValue> analyzer = new Analyzer<BasicValue>(verifier);
+        Analyzer<BasicValue> analyzer = new Analyzer<>(verifier);
 
         boolean noErrors = true;
         for (MethodNode method : classNode.methods) {
diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestFiles.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestFiles.java
index 31b65369d9f..340dd3f0d94 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestFiles.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestFiles.java
@@ -87,7 +87,7 @@ public class CodegenTestFiles {
     }
 
     public static CodegenTestFiles create(Project project, String[] names, String testDataPath) {
-        List<KtFile> files = new ArrayList<KtFile>(names.length);
+        List<KtFile> files = new ArrayList<>(names.length);
         for (String name : names) {
             try {
                 String content = KotlinTestUtils.doLoadFile(testDataPath + "/codegen/", name);
@@ -103,7 +103,7 @@ public class CodegenTestFiles {
 
     @NotNull
     public static CodegenTestFiles create(@NotNull String fileName, @NotNull String contentWithDiagnosticMarkup, @NotNull Project project) {
-        String content = CheckerTestUtil.parseDiagnosedRanges(contentWithDiagnosticMarkup, new ArrayList<CheckerTestUtil.DiagnosedRange>());
+        String content = CheckerTestUtil.parseDiagnosedRanges(contentWithDiagnosticMarkup, new ArrayList<>());
         KtFile file = KotlinTestUtils.createFile(fileName, content, project);
         List<PsiErrorElement> ranges = AnalyzingUtils.getSyntaxErrorRanges(file);
         assert ranges.isEmpty() : "Syntax errors found in " + file + ": " + ranges;
diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestUtil.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestUtil.java
index b812b0e0b04..c14aca4a810 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestUtil.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestUtil.java
@@ -114,13 +114,13 @@ public class CodegenTestUtil {
     ) {
         try {
             File javaClassesTempDirectory = KotlinTestUtils.tmpDir("java-classes");
-            List<String> classpath = new ArrayList<String>();
+            List<String> classpath = new ArrayList<>();
             classpath.add(ForTestCompileRuntime.runtimeJarForTests().getPath());
             classpath.add(ForTestCompileRuntime.reflectJarForTests().getPath());
             classpath.add(KotlinTestUtils.getAnnotationsJar().getPath());
             classpath.addAll(additionalClasspath);
 
-            List<String> options = new ArrayList<String>(Arrays.asList(
+            List<String> options = new ArrayList<>(Arrays.asList(
                     "-classpath", StringsKt.join(classpath, File.pathSeparator),
                     "-d", javaClassesTempDirectory.getPath()
             ));
diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java
index 730dec812c2..cdf044a310e 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java
@@ -98,7 +98,7 @@ public abstract class AbstractWriteFlagsTest extends CodegenTestCase {
 
     private static List<TestedObject> parseExpectedTestedObject(String testDescription) {
         String[] testObjectData = testDescription.substring(testDescription.indexOf("// TESTED_OBJECT_KIND")).split("\n\n");
-        List<TestedObject> objects = new ArrayList<TestedObject>();
+        List<TestedObject> objects = new ArrayList<>();
 
         for (String testData : testObjectData) {
             if (testData.isEmpty()) continue;
diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/forTestCompile/ForTestCompileRuntime.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/forTestCompile/ForTestCompileRuntime.java
index 25f5f1fe515..c7e2a89fb3d 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/codegen/forTestCompile/ForTestCompileRuntime.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/forTestCompile/ForTestCompileRuntime.java
@@ -28,8 +28,8 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class ForTestCompileRuntime {
-    private static volatile SoftReference<ClassLoader> reflectJarClassLoader = new SoftReference<ClassLoader>(null);
-    private static volatile SoftReference<ClassLoader> runtimeJarClassLoader = new SoftReference<ClassLoader>(null);
+    private static volatile SoftReference<ClassLoader> reflectJarClassLoader = new SoftReference<>(null);
+    private static volatile SoftReference<ClassLoader> runtimeJarClassLoader = new SoftReference<>(null);
 
     @NotNull
     public static File runtimeJarForTests() {
@@ -81,7 +81,7 @@ public class ForTestCompileRuntime {
         ClassLoader loader = reflectJarClassLoader.get();
         if (loader == null) {
             loader = createClassLoader(runtimeJarForTests(), reflectJarForTests(), scriptRuntimeJarForTests(), kotlinTestJarForTests());
-            reflectJarClassLoader = new SoftReference<ClassLoader>(loader);
+            reflectJarClassLoader = new SoftReference<>(loader);
         }
         return loader;
     }
@@ -91,7 +91,7 @@ public class ForTestCompileRuntime {
         ClassLoader loader = runtimeJarClassLoader.get();
         if (loader == null) {
             loader = createClassLoader(runtimeJarForTests(), scriptRuntimeJarForTests());
-            runtimeJarClassLoader = new SoftReference<ClassLoader>(loader);
+            runtimeJarClassLoader = new SoftReference<>(loader);
         }
         return loader;
     }
@@ -99,7 +99,7 @@ public class ForTestCompileRuntime {
     @NotNull
     private static ClassLoader createClassLoader(@NotNull File... files) {
         try {
-            List<URL> urls = new ArrayList<URL>(2);
+            List<URL> urls = new ArrayList<>(2);
             for (File file : files) {
                 urls.add(file.toURI().toURL());
             }
diff --git a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java
index 91ffeda3e4e..235a9145596 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java
@@ -55,7 +55,7 @@ public class ExpectedLoadErrorsUtil {
     }
 
     private static Map<SourceElement, List<String>> getExpectedLoadErrors(@NotNull PackageViewDescriptor packageFromJava) {
-        Map<SourceElement, List<String>> map = new HashMap<SourceElement, List<String>>();
+        Map<SourceElement, List<String>> map = new HashMap<>();
 
         packageFromJava.acceptVoid(new DeclarationDescriptorVisitorEmptyBodies<Void, Void>() {
             @Override
@@ -107,7 +107,7 @@ public class ExpectedLoadErrorsUtil {
     }
 
     private static Map<SourceElement, List<String>> getActualLoadErrors(@NotNull BindingContext bindingContext) {
-        Map<SourceElement, List<String>> result = new HashMap<SourceElement, List<String>>();
+        Map<SourceElement, List<String>> result = new HashMap<>();
 
         Collection<DeclarationDescriptor> descriptors = bindingContext.getKeys(JvmBindingContextSlices.LOAD_FROM_JAVA_SIGNATURE_ERRORS);
         for (DeclarationDescriptor descriptor : descriptors) {
diff --git a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java
index ca6e5d16767..75b9e35161b 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java
@@ -72,10 +72,10 @@ public class LoadDescriptorUtil {
             @NotNull ConfigurationKind configurationKind,
             boolean isBinaryRoot
     ) {
-        List<File> javaBinaryRoots = new ArrayList<File>();
+        List<File> javaBinaryRoots = new ArrayList<>();
         javaBinaryRoots.add(KotlinTestUtils.getAnnotationsJar());
 
-        List<File> javaSourceRoots = new ArrayList<File>();
+        List<File> javaSourceRoots = new ArrayList<>();
         javaSourceRoots.add(new File("compiler/testData/loadJava/include"));
         if (isBinaryRoot) {
             javaBinaryRoots.add(javaRoot);
diff --git a/compiler/tests-common/org/jetbrains/kotlin/resolve/ExpectedResolveDataUtil.java b/compiler/tests-common/org/jetbrains/kotlin/resolve/ExpectedResolveDataUtil.java
index b1d9c15d321..6cd04e1cc79 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/resolve/ExpectedResolveDataUtil.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/resolve/ExpectedResolveDataUtil.java
@@ -59,7 +59,7 @@ public class ExpectedResolveDataUtil {
         Project project = environment.getProject();
         KotlinBuiltIns builtIns = DefaultBuiltIns.getInstance();
 
-        Map<String, DeclarationDescriptor> nameToDescriptor = new HashMap<String, DeclarationDescriptor>();
+        Map<String, DeclarationDescriptor> nameToDescriptor = new HashMap<>();
         nameToDescriptor.put("kotlin::Int.plus(Int)", standardFunction(builtIns.getInt(), "plus", project, builtIns.getIntType()));
         FunctionDescriptor descriptorForGet = standardFunction(builtIns.getArray(), "get", project, builtIns.getIntType());
         nameToDescriptor.put("kotlin::Array.get(Int)", descriptorForGet.getOriginal());
@@ -74,7 +74,7 @@ public class ExpectedResolveDataUtil {
     @NotNull
     public static Map<String, PsiElement> prepareDefaultNameToDeclaration(@NotNull KotlinCoreEnvironment environment) {
         Project project = environment.getProject();
-        Map<String, PsiElement> nameToDeclaration = new HashMap<String, PsiElement>();
+        Map<String, PsiElement> nameToDeclaration = new HashMap<>();
 
         PsiClass java_util_Collections = findClass("java.util.Collections", environment);
         nameToDeclaration.put("java::java.util.Collections.emptyList()", findMethod(java_util_Collections, "emptyList"));
@@ -154,7 +154,7 @@ public class ExpectedResolveDataUtil {
 
         TemporaryBindingTrace traceWithFakeArgumentInfo =
                 TemporaryBindingTrace.create(context.trace, "trace to store fake argument for", name);
-        List<KtExpression> fakeArguments = new ArrayList<KtExpression>(parameterTypes.length);
+        List<KtExpression> fakeArguments = new ArrayList<>(parameterTypes.length);
         for (KotlinType type : parameterTypes) {
             fakeArguments.add(ExpressionTypingUtils.createFakeExpressionOfType(
                     project, traceWithFakeArgumentInfo, "fakeArgument" + fakeArguments.size(), type
diff --git a/compiler/tests-common/org/jetbrains/kotlin/test/InTextDirectivesUtils.java b/compiler/tests-common/org/jetbrains/kotlin/test/InTextDirectivesUtils.java
index 82738765f8f..26e9047b74e 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/test/InTextDirectivesUtils.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/test/InTextDirectivesUtils.java
@@ -69,7 +69,7 @@ public final class InTextDirectivesUtils {
 
     @NotNull
     public static List<String> findListWithPrefixes(@NotNull String fileText, @NotNull String... prefixes) {
-        List<String> result = new ArrayList<String>();
+        List<String> result = new ArrayList<>();
 
         for (String line : findLinesWithPrefixesRemoved(fileText, prefixes)) {
             String unquoted = StringUtil.unquoteString(line);
@@ -115,7 +115,7 @@ public final class InTextDirectivesUtils {
 
     @NotNull
     public static List<String> findLinesWithPrefixesRemoved(String fileText, boolean trim, String... prefixes) {
-        List<String> result = new ArrayList<String>();
+        List<String> result = new ArrayList<>();
         List<String> cleanedPrefixes = cleanDirectivesFromComments(Arrays.asList(prefixes));
 
         for (String line : fileNonEmptyCommentedLines(fileText)) {
@@ -183,7 +183,7 @@ public final class InTextDirectivesUtils {
 
     @NotNull
     private static List<String> fileNonEmptyCommentedLines(String fileText) {
-        List<String> result = new ArrayList<String>();
+        List<String> result = new ArrayList<>();
 
         try {
             try (BufferedReader reader = new BufferedReader(new StringReader(fileText))) {
diff --git a/compiler/tests-common/org/jetbrains/kotlin/test/JUnit3RunnerWithInners.java b/compiler/tests-common/org/jetbrains/kotlin/test/JUnit3RunnerWithInners.java
index 9bed3c4cb61..56a0c709700 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/test/JUnit3RunnerWithInners.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/test/JUnit3RunnerWithInners.java
@@ -36,7 +36,7 @@ import java.util.*;
  * with IDEA package test runner.
  */
 public class JUnit3RunnerWithInners extends Runner implements Filterable, Sortable {
-    private static final Set<Class> requestedRunners = new HashSet<Class>();
+    private static final Set<Class> requestedRunners = new HashSet<>();
 
     private JUnit38ClassRunner delegateRunner;
     private final Class<?> klass;
@@ -126,8 +126,8 @@ public class JUnit3RunnerWithInners extends Runner implements Filterable, Sortab
     }
 
     private static Test createTreeTestSuite(Class root) {
-        Set<Class> classes = new LinkedHashSet<Class>(collectDeclaredClasses(root, true));
-        Map<Class, TestSuite> classSuites = new HashMap<Class, TestSuite>();
+        Set<Class> classes = new LinkedHashSet<>(collectDeclaredClasses(root, true));
+        Map<Class, TestSuite> classSuites = new HashMap<>();
 
         for (Class aClass : classes) {
             classSuites.put(aClass, hasTestMethods(aClass) ? new TestSuite(aClass) : new TestSuite(aClass.getCanonicalName()));
@@ -143,7 +143,7 @@ public class JUnit3RunnerWithInners extends Runner implements Filterable, Sortab
     }
 
     private static Set<Class> unprocessedClasses(Collection<Class> classes) {
-        Set<Class> result = new LinkedHashSet<Class>();
+        Set<Class> result = new LinkedHashSet<>();
         for (Class aClass : classes) {
             if (!requestedRunners.contains(aClass)) {
                 result.add(aClass);
@@ -154,7 +154,7 @@ public class JUnit3RunnerWithInners extends Runner implements Filterable, Sortab
     }
 
     private static List<Class> collectDeclaredClasses(Class klass, boolean withItself) {
-        List<Class> result = new ArrayList<Class>();
+        List<Class> result = new ArrayList<>();
         if (withItself) {
             result.add(klass);
         }
diff --git a/compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java b/compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java
index 3f54f30082b..c1f50164fef 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java
@@ -100,7 +100,7 @@ public class KotlinTestUtils {
     public static final String TEST_GENERATOR_NAME = "org.jetbrains.kotlin.generators.tests.TestsPackage";
     public static final String PLEASE_REGENERATE_TESTS = "Please regenerate tests (GenerateTests.kt)";
 
-    private static final List<File> filesToDelete = new ArrayList<File>();
+    private static final List<File> filesToDelete = new ArrayList<>();
 
     /**
      * Syntax:
@@ -486,7 +486,7 @@ public class KotlinTestUtils {
     public static void resolveAllKotlinFiles(KotlinCoreEnvironment environment) throws IOException {
         List<ContentRoot> paths = environment.getConfiguration().get(JVMConfigurationKeys.CONTENT_ROOTS);
         if (paths == null) return;
-        List<KtFile> ktFiles = new ArrayList<KtFile>();
+        List<KtFile> ktFiles = new ArrayList<>();
         for (ContentRoot root : paths) {
             if (!(root instanceof KotlinSourceRoot)) continue;
 
@@ -718,7 +718,7 @@ public class KotlinTestUtils {
     }
 
     public static String getLastCommentedLines(@NotNull Document document) {
-        List<CharSequence> resultLines = new ArrayList<CharSequence>();
+        List<CharSequence> resultLines = new ArrayList<>();
         for (int i = document.getLineCount() - 1; i >= 0; i--) {
             int lineStart = document.getLineStartOffset(i);
             int lineEnd = document.getLineEndOffset(i);
@@ -796,7 +796,7 @@ public class KotlinTestUtils {
 
     private static boolean compileJavaFiles(@NotNull Collection<File> files, List<String> options, @Nullable File javaErrorFile) throws IOException {
         JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
-        DiagnosticCollector<JavaFileObject> diagnosticCollector = new DiagnosticCollector<JavaFileObject>();
+        DiagnosticCollector<JavaFileObject> diagnosticCollector = new DiagnosticCollector<>();
         try (StandardJavaFileManager fileManager =
                      javaCompiler.getStandardFileManager(diagnosticCollector, Locale.ENGLISH, Charset.forName("utf-8"))) {
             Iterable<? extends JavaFileObject> javaFileObjectsFromFiles = fileManager.getJavaFileObjectsFromFiles(files);
diff --git a/compiler/tests-common/org/jetbrains/kotlin/test/MockLibraryUtil.java b/compiler/tests-common/org/jetbrains/kotlin/test/MockLibraryUtil.java
index 4ecfd3eaffc..8c1ba89a21b 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/test/MockLibraryUtil.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/test/MockLibraryUtil.java
@@ -44,7 +44,7 @@ import static org.junit.Assert.assertEquals;
 
 public class MockLibraryUtil {
 
-    private static SoftReference<ClassLoader> compilerClassLoader = new SoftReference<ClassLoader>(null);
+    private static SoftReference<ClassLoader> compilerClassLoader = new SoftReference<>(null);
 
     @NotNull
     public static File compileLibraryToJar(
@@ -105,7 +105,7 @@ public class MockLibraryUtil {
 
             List<File> javaFiles = FileUtil.findFilesByMask(Pattern.compile(".*\\.java"), srcFile);
             if (!javaFiles.isEmpty()) {
-                List<String> classpath = new ArrayList<String>();
+                List<String> classpath = new ArrayList<>();
                 classpath.add(ForTestCompileRuntime.runtimeJarForTests().getPath());
                 classpath.add(KotlinTestUtils.getAnnotationsJar().getPath());
                 Collections.addAll(classpath, extraClasspath);
@@ -200,13 +200,13 @@ public class MockLibraryUtil {
             boolean allowKotlinPackage,
             @NotNull String... extraClasspath
     ) {
-        List<String> classpath = new ArrayList<String>();
+        List<String> classpath = new ArrayList<>();
         if (new File(sourcesPath).isDirectory()) {
             classpath.add(sourcesPath);
         }
         Collections.addAll(classpath, extraClasspath);
 
-        List<String> args = new ArrayList<String>();
+        List<String> args = new ArrayList<>();
         args.add(sourcesPath);
         args.add("-d");
         args.add(outDir.getAbsolutePath());
@@ -220,7 +220,7 @@ public class MockLibraryUtil {
     }
 
     private static void compileKotlin2JS(@NotNull String sourcesPath, @NotNull File outputFile) {
-        List<String> args = new ArrayList<String>();
+        List<String> args = new ArrayList<>();
 
         args.add("-meta-info");
         args.add("-output");
@@ -250,7 +250,7 @@ public class MockLibraryUtil {
             ClassLoader classLoader = compilerClassLoader.get();
             if (classLoader == null) {
                 classLoader = createCompilerClassLoader();
-                compilerClassLoader = new SoftReference<ClassLoader>(classLoader);
+                compilerClassLoader = new SoftReference<>(classLoader);
             }
             return classLoader.loadClass(compilerClassName);
         }
diff --git a/compiler/tests-common/org/jetbrains/kotlin/test/testFramework/KtUsefulTestCase.java b/compiler/tests-common/org/jetbrains/kotlin/test/testFramework/KtUsefulTestCase.java
index f9dca1be4a3..b30e84ef779 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/test/testFramework/KtUsefulTestCase.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/test/testFramework/KtUsefulTestCase.java
@@ -55,8 +55,8 @@ public abstract class KtUsefulTestCase extends TestCase {
 
     private static final String ORIGINAL_TEMP_DIR = FileUtil.getTempDirectory();
 
-    private static final Map<String, Long> TOTAL_SETUP_COST_MILLIS = new HashMap<String, Long>();
-    private static final Map<String, Long> TOTAL_TEARDOWN_COST_MILLIS = new HashMap<String, Long>();
+    private static final Map<String, Long> TOTAL_SETUP_COST_MILLIS = new HashMap<>();
+    private static final Map<String, Long> TOTAL_TEARDOWN_COST_MILLIS = new HashMap<>();
 
     private Application application;
 
@@ -73,7 +73,7 @@ public abstract class KtUsefulTestCase extends TestCase {
     };
 
     private static final String ourPathToKeep = null;
-    private final List<String> myPathsToKeep = new ArrayList<String>();
+    private final List<String> myPathsToKeep = new ArrayList<>();
 
     private String myTempDir;
 
@@ -180,7 +180,7 @@ public abstract class KtUsefulTestCase extends TestCase {
         List<String> list;
         synchronized (DELETE_ON_EXIT_HOOK_CLASS) {
             if (DELETE_ON_EXIT_HOOK_DOT_FILES.isEmpty()) return;
-            list = new ArrayList<String>(DELETE_ON_EXIT_HOOK_DOT_FILES);
+            list = new ArrayList<>(DELETE_ON_EXIT_HOOK_DOT_FILES);
         }
         for (int i = list.size() - 1; i >= 0; i--) {
             String path = list.get(i);
@@ -310,7 +310,7 @@ public abstract class KtUsefulTestCase extends TestCase {
             String erroMsg,
             Iterable<? extends T> actual,
             Collection<? extends T> expected) {
-        ArrayList<T> list = new ArrayList<T>();
+        ArrayList<T> list = new ArrayList<>();
         for (T t : actual) {
             list.add(t);
         }
@@ -337,9 +337,9 @@ public abstract class KtUsefulTestCase extends TestCase {
     public static <T> void assertSameElements(String message, Collection<? extends T> collection, Collection<T> expected) {
         assertNotNull(collection);
         assertNotNull(expected);
-        if (collection.size() != expected.size() || !new HashSet<T>(expected).equals(new HashSet<T>(collection))) {
+        if (collection.size() != expected.size() || !new HashSet<>(expected).equals(new HashSet<T>(collection))) {
             Assert.assertEquals(message, toString(expected, "\n"), toString(collection, "\n"));
-            Assert.assertEquals(message, new HashSet<T>(expected), new HashSet<T>(collection));
+            Assert.assertEquals(message, new HashSet<>(expected), new HashSet<T>(collection));
         }
     }
 
diff --git a/compiler/tests-common/org/jetbrains/kotlin/test/testFramework/mock/MockPsiManager.java b/compiler/tests-common/org/jetbrains/kotlin/test/testFramework/mock/MockPsiManager.java
index b8c17b05fa2..8cbba58bda6 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/test/testFramework/mock/MockPsiManager.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/test/testFramework/mock/MockPsiManager.java
@@ -36,7 +36,7 @@ import java.util.Map;
 
 public class MockPsiManager extends PsiManagerEx {
   private final Project myProject;
-  private final Map<VirtualFile,PsiDirectory> myDirectories = new THashMap<VirtualFile, PsiDirectory>();
+  private final Map<VirtualFile,PsiDirectory> myDirectories = new THashMap<>();
   private MockFileManager myMockFileManager;
   private PsiModificationTrackerImpl myPsiModificationTracker;
 
diff --git a/compiler/tests-common/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java b/compiler/tests-common/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java
index 916d9eca587..3c72da4cf00 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java
@@ -174,7 +174,7 @@ public class RecursiveDescriptorComparator {
     @NotNull
     private MemberScope getPackageScopeInModule(@NotNull PackageViewDescriptor descriptor, @NotNull ModuleDescriptor module) {
         // See LazyPackageViewDescriptorImpl#memberScope
-        List<MemberScope> scopes = new ArrayList<MemberScope>();
+        List<MemberScope> scopes = new ArrayList<>();
         for (PackageFragmentDescriptor fragment : descriptor.getFragments()) {
             if (isFromModule(fragment, module)) {
                 scopes.add(fragment.getMemberScope());
diff --git a/compiler/tests-common/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessor.java b/compiler/tests-common/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessor.java
index b1be75998df..dcf0c9a94f7 100644
--- a/compiler/tests-common/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessor.java
+++ b/compiler/tests-common/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessor.java
@@ -31,7 +31,7 @@ public class RecursiveDescriptorProcessor {
             D data,
             @NotNull DeclarationDescriptorVisitor<Boolean, D> visitor
     ) {
-        return descriptor.accept(new RecursiveVisitor<D>(visitor), data);
+        return descriptor.accept(new RecursiveVisitor<>(visitor), data);
     }
 
     private static class RecursiveVisitor<D> implements DeclarationDescriptorVisitor<Boolean, D> {
diff --git a/compiler/tests/org/jetbrains/kotlin/cfg/AbstractControlFlowTest.java b/compiler/tests/org/jetbrains/kotlin/cfg/AbstractControlFlowTest.java
index 33094714b3b..4bdd441c879 100644
--- a/compiler/tests/org/jetbrains/kotlin/cfg/AbstractControlFlowTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/cfg/AbstractControlFlowTest.java
@@ -97,7 +97,7 @@ public abstract class AbstractControlFlowTest extends AbstractPseudocodeTest {
         if (natural == null) {
             return actual.isEmpty();
         }
-        return Collections.singleton(natural).equals(new HashSet<Instruction>(actual));
+        return Collections.singleton(natural).equals(new HashSet<>(actual));
     }
 
     @Override
diff --git a/compiler/tests/org/jetbrains/kotlin/cfg/CFGraphToDotFilePrinter.java b/compiler/tests/org/jetbrains/kotlin/cfg/CFGraphToDotFilePrinter.java
index 36ad7ebb1f9..4ab281d745a 100644
--- a/compiler/tests/org/jetbrains/kotlin/cfg/CFGraphToDotFilePrinter.java
+++ b/compiler/tests/org/jetbrains/kotlin/cfg/CFGraphToDotFilePrinter.java
@@ -47,7 +47,7 @@ public class CFGraphToDotFilePrinter {
 
         out.println("digraph " + FileUtil.getNameWithoutExtension(file) + " {");
         int[] count = new int[1];
-        Map<Instruction, String> nodeToName = new HashMap<Instruction, String>();
+        Map<Instruction, String> nodeToName = new HashMap<>();
         for (Pseudocode pseudocode : pseudocodes) {
             dumpNodes(pseudocode.getInstructionsIncludingDeadCode(), out, count, nodeToName, Sets
                     .newHashSet(pseudocode.getInstructions()));
diff --git a/compiler/tests/org/jetbrains/kotlin/cli/AbstractCliTest.java b/compiler/tests/org/jetbrains/kotlin/cli/AbstractCliTest.java
index fe2bf3423fc..509709f8692 100644
--- a/compiler/tests/org/jetbrains/kotlin/cli/AbstractCliTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/cli/AbstractCliTest.java
@@ -54,7 +54,7 @@ public abstract class AbstractCliTest extends TestCaseWithTmpdir {
         try {
             System.setErr(new PrintStream(bytes));
             ExitCode exitCode = CLICompiler.doMainNoExit(compiler, ArrayUtil.toStringArray(args));
-            return new Pair<String, ExitCode>(bytes.toString("utf-8"), exitCode);
+            return new Pair<>(bytes.toString("utf-8"), exitCode);
         }
         catch (Exception e) {
             throw ExceptionUtilsKt.rethrow(e);
@@ -97,7 +97,7 @@ public abstract class AbstractCliTest extends TestCaseWithTmpdir {
     }
 
     private void doTestAdditionalChecks(@NotNull File testConfigFile) throws IOException {
-        List<String> diagnostics = new ArrayList<String>(0);
+        List<String> diagnostics = new ArrayList<>(0);
         String content = FilesKt.readText(testConfigFile, Charsets.UTF_8);
 
         List<String> existsList = InTextDirectivesUtils.findListWithPrefixes(content, "// EXISTS: ");
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/InnerClassInfoGenTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/InnerClassInfoGenTest.java
index d49ec533e1a..5f54ba7bd61 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/InnerClassInfoGenTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/InnerClassInfoGenTest.java
@@ -137,7 +137,7 @@ public class InnerClassInfoGenTest extends CodegenTestCase {
         assertNotNull(outputFile);
         byte[] bytes = outputFile.asByteArray();
         ClassReader reader = new ClassReader(bytes);
-        List<InnerClassAttribute> result = new ArrayList<InnerClassAttribute>();
+        List<InnerClassAttribute> result = new ArrayList<>();
 
         reader.accept(new ClassVisitor(ASM5) {
             @Override
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/PackageGenTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/PackageGenTest.java
index 5329b63a53c..9d23ffc4c01 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/PackageGenTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/PackageGenTest.java
@@ -378,7 +378,7 @@ public class PackageGenTest extends CodegenTestCase {
     public void testSubstituteJavaMethodTypeParameters() throws Exception {
         loadText("import java.util.*; fun foo(l: ArrayList<Int>) { l.add(10) }");
         Method main = generateFunction();
-        ArrayList<Integer> l = new ArrayList<Integer>();
+        ArrayList<Integer> l = new ArrayList<>();
         main.invoke(null, l);
         assertEquals(10, l.get(0).intValue());
     }
@@ -399,7 +399,7 @@ public class PackageGenTest extends CodegenTestCase {
     public void testJavaInterfaceMethod() throws Exception {
         loadText("import java.util.*; fun foo(l: ArrayList<String>) { l.add(\"foo\") }");
         Method main = generateFunction();
-        ArrayList<String> list = new ArrayList<String>();
+        ArrayList<String> list = new ArrayList<>();
         main.invoke(null, list);
         assertEquals("foo", list.get(0));
     }
@@ -407,7 +407,7 @@ public class PackageGenTest extends CodegenTestCase {
     public void testArrayAccessForArrayList() throws Exception {
         loadText("import java.util.*; fun foo(l: ArrayList<String>) { l[0] = \"Kotlin\" + l[0]; }");
         Method main = generateFunction();
-        ArrayList<String> list = new ArrayList<String>();
+        ArrayList<String> list = new ArrayList<>();
         list.add("Language");
         main.invoke(null, list);
         assertEquals("KotlinLanguage", list.get(0));
diff --git a/compiler/tests/org/jetbrains/kotlin/integration/CompilerSmokeTestBase.java b/compiler/tests/org/jetbrains/kotlin/integration/CompilerSmokeTestBase.java
index 5efe36a7dff..098d54ca9ef 100644
--- a/compiler/tests/org/jetbrains/kotlin/integration/CompilerSmokeTestBase.java
+++ b/compiler/tests/org/jetbrains/kotlin/integration/CompilerSmokeTestBase.java
@@ -32,7 +32,7 @@ public abstract class CompilerSmokeTestBase extends KotlinIntegrationTestBase {
     }
 
     protected int runCompiler(String logName, String... arguments) throws Exception {
-        Collection<String> javaArgs = new ArrayList<String>();
+        Collection<String> javaArgs = new ArrayList<>();
 
         javaArgs.add("-cp");
         javaArgs.add(StringsKt.join(Arrays.asList(
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java
index dcb87f6b709..6766026c7ae 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java
@@ -103,7 +103,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
             @NotNull CLICompiler<?> compiler, @NotNull String sourcePath, @NotNull File destination, List<String> additionalOptions, @NotNull File... extraClassPath
     ) {
         Pair<String, ExitCode> output = compileKotlin(compiler, sourcePath, destination, additionalOptions, extraClassPath);
-        Assert.assertEquals(normalizeOutput(new Pair<String, ExitCode>("", ExitCode.OK)), normalizeOutput(output));
+        Assert.assertEquals(normalizeOutput(new Pair<>("", ExitCode.OK)), normalizeOutput(output));
     }
 
     @NotNull
@@ -135,7 +135,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
 
     @NotNull
     private KotlinCoreEnvironment createEnvironment(@NotNull List<File> extraClassPath) {
-        List<File> extras = new ArrayList<File>();
+        List<File> extras = new ArrayList<>();
         extras.addAll(extraClassPath);
         extras.add(KotlinTestUtils.getAnnotationsJar());
 
@@ -233,7 +233,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
             @NotNull List<String> additionalOptions,
             @NotNull File... classpath
     ) {
-        List<String> args = new ArrayList<String>();
+        List<String> args = new ArrayList<>();
         File sourceFile = new File(getTestDataDirectory(), fileName);
         assert sourceFile.exists() : "Source file does not exist: " + sourceFile.getAbsolutePath();
         args.add(sourceFile.getPath());
@@ -553,7 +553,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
 
         compileKotlin("source.kt", tmpdir, tmpdir);
 
-        Ref<String> debugInfo = new Ref<String>();
+        Ref<String> debugInfo = new Ref<>();
         File resultFile = new File(tmpdir.getAbsolutePath(), "test/B.class");
         new ClassReader(FilesKt.readBytes(resultFile)).accept(new ClassVisitor(Opcodes.ASM5) {
             @Override
diff --git a/compiler/tests/org/jetbrains/kotlin/name/FqNameTest.java b/compiler/tests/org/jetbrains/kotlin/name/FqNameTest.java
index 8007cf8faf6..28c6cd8f5e3 100644
--- a/compiler/tests/org/jetbrains/kotlin/name/FqNameTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/name/FqNameTest.java
@@ -30,7 +30,7 @@ public class FqNameTest {
 
         for (String name : new String[] { "org", "org.jetbrains", "org.jetbrains.kotlin" }) {
             List<Name> segments = new FqName(name).pathSegments();
-            List<String> segmentsStrings = new ArrayList<String>();
+            List<String> segmentsStrings = new ArrayList<>();
             for (Name segment : segments) {
                 segmentsStrings.add(segment.asString());
             }
diff --git a/compiler/tests/org/jetbrains/kotlin/storage/StorageManagerTest.java b/compiler/tests/org/jetbrains/kotlin/storage/StorageManagerTest.java
index ca5979f44f0..884caffca20 100644
--- a/compiler/tests/org/jetbrains/kotlin/storage/StorageManagerTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/storage/StorageManagerTest.java
@@ -318,7 +318,7 @@ public class StorageManagerTest extends TestCase {
         CounterImpl counter = new CounterImpl();
         NotNullLazyValue<Collection<String>> v = m.createLazyValueWithPostCompute(
                 () -> {
-                    List<String> strings = new ArrayList<String>();
+                    List<String> strings = new ArrayList<>();
                     strings.add("first");
                     return strings;
                 },
@@ -339,7 +339,7 @@ public class StorageManagerTest extends TestCase {
         CounterImpl counter = new CounterImpl();
         NullableLazyValue<Collection<String>> v = m.createNullableLazyValueWithPostCompute(
                 () -> {
-                    ArrayList<String> strings = new ArrayList<String>();
+                    ArrayList<String> strings = new ArrayList<>();
                     strings.add("first");
                     return strings;
                 },
diff --git a/compiler/tests/org/jetbrains/kotlin/types/KotlinTypeCheckerTest.java b/compiler/tests/org/jetbrains/kotlin/types/KotlinTypeCheckerTest.java
index 8f7b2c7495b..c426a1bb2d4 100644
--- a/compiler/tests/org/jetbrains/kotlin/types/KotlinTypeCheckerTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/types/KotlinTypeCheckerTest.java
@@ -505,7 +505,7 @@ public class KotlinTypeCheckerTest extends KotlinTestWithEnvironment {
     }
 
     private void assertIntersection(String expected, String... types) {
-        Set<KotlinType> typesToIntersect = new LinkedHashSet<KotlinType>();
+        Set<KotlinType> typesToIntersect = new LinkedHashSet<>();
         for (String type : types) {
             typesToIntersect.add(makeType(type));
         }
@@ -515,7 +515,7 @@ public class KotlinTypeCheckerTest extends KotlinTestWithEnvironment {
     }
 
     private void assertCommonSupertype(String expected, String... types) {
-        Collection<KotlinType> subtypes = new ArrayList<KotlinType>();
+        Collection<KotlinType> subtypes = new ArrayList<>();
         for (String type : types) {
             subtypes.add(makeType(type));
         }
diff --git a/compiler/util/src/org/jetbrains/kotlin/utils/Interner.java b/compiler/util/src/org/jetbrains/kotlin/utils/Interner.java
index 86c0e9a217a..8bb04893df6 100644
--- a/compiler/util/src/org/jetbrains/kotlin/utils/Interner.java
+++ b/compiler/util/src/org/jetbrains/kotlin/utils/Interner.java
@@ -27,7 +27,7 @@ import java.util.Map;
 public final class Interner<T> {
     private final Interner<T> parent;
     private final int firstIndex;
-    private final Map<T, Integer> interned = new HashMap<T, Integer>();
+    private final Map<T, Integer> interned = new HashMap<>();
 
     public Interner(Interner<T> parent) {
         this.parent = parent;
diff --git a/compiler/util/src/org/jetbrains/kotlin/utils/Profiler.java b/compiler/util/src/org/jetbrains/kotlin/utils/Profiler.java
index 2da13cf95a9..384fc100b21 100644
--- a/compiler/util/src/org/jetbrains/kotlin/utils/Profiler.java
+++ b/compiler/util/src/org/jetbrains/kotlin/utils/Profiler.java
@@ -29,7 +29,7 @@ public class Profiler {
     private static final ThreadLocal<Stack<Profiler>> PROFILERS = new ThreadLocal<Stack<Profiler>>() {
         @Override
         protected Stack<Profiler> initialValue() {
-            return new Stack<Profiler>();
+            return new Stack<>();
         }
     };
 
diff --git a/generators/src/org/jetbrains/kotlin/generators/frontend/GenerateKeywordStrings.java b/generators/src/org/jetbrains/kotlin/generators/frontend/GenerateKeywordStrings.java
index 9dbe4f68c21..69f2a36f86d 100644
--- a/generators/src/org/jetbrains/kotlin/generators/frontend/GenerateKeywordStrings.java
+++ b/generators/src/org/jetbrains/kotlin/generators/frontend/GenerateKeywordStrings.java
@@ -53,7 +53,7 @@ public class GenerateKeywordStrings {
         p.println("public static final Set<String> KEYWORDS = new HashSet<String>(Arrays.asList(");
         p.pushIndent();
 
-        List<String> strings = new ArrayList<String>();
+        List<String> strings = new ArrayList<>();
         for (IElementType type : KtTokens.KEYWORDS.getTypes()) {
             assert type instanceof KtKeywordToken : "Not a keyword in KtTokens.KEYWORDS: " + type;
             KtKeywordToken keyword = (KtKeywordToken) type;
diff --git a/generators/src/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.java b/generators/src/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.java
index 231701d1b26..4495dc35d03 100644
--- a/generators/src/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.java
+++ b/generators/src/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.java
@@ -72,7 +72,7 @@ public class SimpleTestClassModel implements TestClassModel {
         this.testClassName = testClassName;
         this.targetBackend = targetBackend;
         this.checkFilenameStartsLowerCase = checkFilenameStartsLowerCase;
-        this.excludeDirs = excludeDirs.isEmpty() ? Collections.<String>emptySet() : new LinkedHashSet<String>(excludeDirs);
+        this.excludeDirs = excludeDirs.isEmpty() ? Collections.emptySet() : new LinkedHashSet<>(excludeDirs);
     }
 
     @NotNull
@@ -106,7 +106,7 @@ public class SimpleTestClassModel implements TestClassModel {
     private Set<String> excludesStripOneDirectory(@NotNull String directoryName) {
         if (excludeDirs.isEmpty()) return excludeDirs;
 
-        Set<String> result = new LinkedHashSet<String>();
+        Set<String> result = new LinkedHashSet<>();
         for (String excludeDir : excludeDirs) {
             int firstSlash = excludeDir.indexOf('/');
             if (firstSlash >= 0 && excludeDir.substring(0, firstSlash).equals(directoryName)) {
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/config/JsConfig.java b/js/js.frontend/src/org/jetbrains/kotlin/js/config/JsConfig.java
index 52dc5398b5f..9de78b2d03f 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/config/JsConfig.java
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/config/JsConfig.java
@@ -62,7 +62,7 @@ public class JsConfig {
     private final CompilerConfiguration configuration;
     private final LockBasedStorageManager storageManager = new LockBasedStorageManager();
 
-    private final List<KotlinJavascriptMetadata> metadata = new SmartList<KotlinJavascriptMetadata>();
+    private final List<KotlinJavascriptMetadata> metadata = new SmartList<>();
 
     @Nullable
     private List<JsModuleDescriptor<ModuleDescriptorImpl>> moduleDescriptors = null;
@@ -118,7 +118,7 @@ public class JsConfig {
         VirtualFileSystem fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL);
         VirtualFileSystem jarFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JAR_PROTOCOL);
 
-        Set<String> modules = new HashSet<String>();
+        Set<String> modules = new HashSet<>();
 
         boolean skipMetadataVersionCheck =
                 getLanguageVersionSettings(configuration).isFlagEnabled(AnalysisFlags.getSkipMetadataVersionCheck());
@@ -175,8 +175,8 @@ public class JsConfig {
         init();
         if (moduleDescriptors != null) return moduleDescriptors;
 
-        moduleDescriptors = new SmartList<JsModuleDescriptor<ModuleDescriptorImpl>>();
-        List<ModuleDescriptorImpl> kotlinModuleDescriptors = new ArrayList<ModuleDescriptorImpl>();
+        moduleDescriptors = new SmartList<>();
+        List<ModuleDescriptorImpl> kotlinModuleDescriptors = new ArrayList<>();
         for (KotlinJavascriptMetadata metadataEntry : metadata) {
             JsModuleDescriptor<ModuleDescriptorImpl> descriptor = createModuleDescriptor(metadataEntry);
             moduleDescriptors.add(descriptor);
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java b/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java
index 539820adbb6..93c535e0e23 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java
@@ -273,7 +273,7 @@ public final class AnnotationsUtils {
 
         KtFile kotlinFile = getFile(descriptor);
         if (kotlinFile != null) {
-            List<AnnotationDescriptor> annotations = new ArrayList<AnnotationDescriptor>();
+            List<AnnotationDescriptor> annotations = new ArrayList<>();
             for (KtAnnotationEntry psiAnnotation : kotlinFile.getAnnotationEntries()) {
                 AnnotationDescriptor annotation = bindingContext.get(BindingContext.ANNOTATION, psiAnnotation);
                 if (annotation != null) {
diff --git a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/JsInliner.java b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/JsInliner.java
index e6973163b21..35c7eecefcd 100644
--- a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/JsInliner.java
+++ b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/JsInliner.java
@@ -49,15 +49,15 @@ public class JsInliner extends JsVisitorWithContextImpl {
 
     private final Map<JsName, JsFunction> functions;
     private final Map<String, JsFunction> accessors;
-    private final Stack<JsInliningContext> inliningContexts = new Stack<JsInliningContext>();
+    private final Stack<JsInliningContext> inliningContexts = new Stack<>();
     private final Set<JsFunction> processedFunctions = CollectionUtilsKt.IdentitySet();
     private final Set<JsFunction> inProcessFunctions = CollectionUtilsKt.IdentitySet();
     private final FunctionReader functionReader;
     private final DiagnosticSink trace;
 
     // these are needed for error reporting, when inliner detects cycle
-    private final Stack<JsFunction> namedFunctionsStack = new Stack<JsFunction>();
-    private final LinkedList<JsCallInfo> inlineCallInfos = new LinkedList<JsCallInfo>();
+    private final Stack<JsFunction> namedFunctionsStack = new Stack<>();
+    private final LinkedList<JsCallInfo> inlineCallInfos = new LinkedList<>();
     private final Function1<JsNode, Boolean> canBeExtractedByInliner =
             node -> node instanceof JsInvocation && hasToBeInlined((JsInvocation) node);
 
diff --git a/js/js.tests/test/org/jetbrains/kotlin/integration/AntTaskJsTest.java b/js/js.tests/test/org/jetbrains/kotlin/integration/AntTaskJsTest.java
index 144ad6d676e..4ad7548f929 100644
--- a/js/js.tests/test/org/jetbrains/kotlin/integration/AntTaskJsTest.java
+++ b/js/js.tests/test/org/jetbrains/kotlin/integration/AntTaskJsTest.java
@@ -54,7 +54,7 @@ public class AntTaskJsTest extends AbstractAntTaskTest {
     private void doJsAntTest(boolean withModuleSystem, String... jsFiles) throws Exception {
         doTest();
 
-        List<String> fileNames = new ArrayList<String>(Arrays.asList(jsFiles));
+        List<String> fileNames = new ArrayList<>(Arrays.asList(jsFiles));
         fileNames.add(JS_OUT_FILE);
 
         List<String> filePaths = CollectionsKt.map(fileNames, s -> getOutputFileByName(s).getAbsolutePath());
diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicTest.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicTest.java
index 970fc9ad5aa..62bf49896f7 100644
--- a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicTest.java
+++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicTest.java
@@ -315,7 +315,7 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
 
         configuration.put(CommonConfigurationKeys.DISABLE_INLINE, hasNoInline(files));
 
-        List<String> librariesWithStdlib = new ArrayList<String>(JsConfig.JS_STDLIB);
+        List<String> librariesWithStdlib = new ArrayList<>(JsConfig.JS_STDLIB);
         if (libraries != null) {
             librariesWithStdlib.addAll(libraries);
         }
diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/CompileMavenGeneratedJSLibrary.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/CompileMavenGeneratedJSLibrary.java
index a048a77533e..37e8f8b8f72 100644
--- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/CompileMavenGeneratedJSLibrary.java
+++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/CompileMavenGeneratedJSLibrary.java
@@ -94,7 +94,7 @@ public class CompileMavenGeneratedJSLibrary extends SingleFileTranslationTest {
             String outputFile = getOutputFilePath(getTestName(false) + ".compiler.kt", version);
             System.out.println("Compiling with version: " + version + " to: " + outputFile);
 
-            List<String> args = new ArrayList<String>(Arrays.asList(
+            List<String> args = new ArrayList<>(Arrays.asList(
                     "-output", outputFile,
                     "-libraries", generatedJsDefinitionsDir,
                     "-verbose"
diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsUnitTestBase.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsUnitTestBase.java
index c3efc33fb22..c4dc0692e50 100644
--- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsUnitTestBase.java
+++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsUnitTestBase.java
@@ -100,7 +100,7 @@ public abstract class JsUnitTestBase extends MultipleFilesTranslationTest {
 
     @Override
     protected Map<String, Object> getRhinoTestVariables() throws Exception {
-        Map<String, Object> testVariables = new HashMap<String, Object>();
+        Map<String, Object> testVariables = new HashMap<>();
         testVariables.put(RhinoUtils.OPTIMIZATION_LEVEL_TEST_VARIABLE, RhinoUtils.OPTIMIZATION_OFF);
         testVariables.put("jsTestReporter", JS_UNIT_TEST_REPORTER);
         return testVariables;
diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/StdLibTest.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/StdLibTest.java
index bd70d76830f..61627734c99 100644
--- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/StdLibTest.java
+++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/StdLibTest.java
@@ -65,7 +65,7 @@ public final class StdLibTest extends SingleFileTranslationTest {
         Element foo = document.getElementById("foo");
         assertNotNull(foo);
 
-        Map<String, Object> answer = new HashMap<String, Object>();
+        Map<String, Object> answer = new HashMap<>();
         answer.put("document", document);
         answer.put("Node", new DummyNode());
         return answer;
diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/CallCounter.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/CallCounter.java
index a316cff5715..6abd9dca5f2 100644
--- a/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/CallCounter.java
+++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/CallCounter.java
@@ -23,7 +23,7 @@ import java.util.*;
 
 public class CallCounter extends RecursiveJsVisitor {
 
-    private final List<JsNameRef> callsNameRefs = new ArrayList<JsNameRef>();
+    private final List<JsNameRef> callsNameRefs = new ArrayList<>();
 
     @NotNull
     private final Set<String> exceptFunctionNames;
@@ -40,7 +40,7 @@ public class CallCounter extends RecursiveJsVisitor {
 
     @NotNull
     public static CallCounter countCalls(@NotNull JsNode node, @NotNull Set<String> exceptFunctionNames) {
-        CallCounter visitor = new CallCounter(new HashSet<String>(exceptFunctionNames), Collections.<String>emptySet());
+        CallCounter visitor = new CallCounter(new HashSet<>(exceptFunctionNames), Collections.<String>emptySet());
         node.accept(visitor);
 
         return visitor;
@@ -48,7 +48,7 @@ public class CallCounter extends RecursiveJsVisitor {
 
     @NotNull
     public static CallCounter countCallsWithExcludedScopes(@NotNull JsNode node, @NotNull Set<String> exceptScopes) {
-        CallCounter visitor = new CallCounter(Collections.<String>emptySet(), new HashSet<String>(exceptScopes));
+        CallCounter visitor = new CallCounter(Collections.<String>emptySet(), new HashSet<>(exceptScopes));
         node.accept(visitor);
 
         return visitor;
@@ -65,7 +65,7 @@ public class CallCounter extends RecursiveJsVisitor {
 
     public int getQualifiedCallsCount(String... qualifiers) {
         int count = 0;
-        List<String> expectedQualifierChain = new ArrayList<String>();
+        List<String> expectedQualifierChain = new ArrayList<>();
         Collections.addAll(expectedQualifierChain, qualifiers);
 
         for (JsNameRef callNameRef : callsNameRefs) {
diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/DirectiveTestUtils.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/DirectiveTestUtils.java
index c67248f1c00..cfd2018e577 100644
--- a/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/DirectiveTestUtils.java
+++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/DirectiveTestUtils.java
@@ -36,7 +36,7 @@ public class DirectiveTestUtils {
     private static final DirectiveHandler FUNCTION_CONTAINS_NO_CALLS = new DirectiveHandler("CHECK_CONTAINS_NO_CALLS") {
         @Override
         void processEntry(@NotNull JsNode ast, @NotNull ArgumentsHelper arguments) throws Exception {
-            Set<String> exceptNames = new HashSet<String>();
+            Set<String> exceptNames = new HashSet<>();
             String exceptNamesArg = arguments.findNamedArgument("except");
             if (exceptNamesArg != null) {
                 for (String exceptName : exceptNamesArg.split(";")) {
@@ -185,11 +185,11 @@ public class DirectiveTestUtils {
         }
     };
 
-    private static final DirectiveHandler COUNT_VARS = new CountNodesDirective<JsVars.JsVar>("CHECK_VARS_COUNT", JsVars.JsVar.class);
+    private static final DirectiveHandler COUNT_VARS = new CountNodesDirective<>("CHECK_VARS_COUNT", JsVars.JsVar.class);
 
-    private static final DirectiveHandler COUNT_BREAKS = new CountNodesDirective<JsBreak>("CHECK_BREAKS_COUNT", JsBreak.class);
+    private static final DirectiveHandler COUNT_BREAKS = new CountNodesDirective<>("CHECK_BREAKS_COUNT", JsBreak.class);
 
-    private static final DirectiveHandler COUNT_NULLS = new CountNodesDirective<JsNullLiteral>("CHECK_NULLS_COUNT", JsNullLiteral.class);
+    private static final DirectiveHandler COUNT_NULLS = new CountNodesDirective<>("CHECK_NULLS_COUNT", JsNullLiteral.class);
 
     private static final DirectiveHandler NOT_REFERENCED = new DirectiveHandler("CHECK_NOT_REFERENCED") {
         @Override
@@ -268,7 +268,7 @@ public class DirectiveTestUtils {
         void processEntry(@NotNull JsNode ast, @NotNull ArgumentsHelper arguments) throws Exception {
             String functionName = arguments.getNamedArgument("function");
 
-            Set<String> except = new HashSet<String>();
+            Set<String> except = new HashSet<>();
             String exceptString = arguments.findNamedArgument("except");
             if (exceptString != null) {
                 for (String exceptId : StringUtil.split(exceptString, ";")) {
@@ -421,8 +421,8 @@ public class DirectiveTestUtils {
      * Neither key, nor value should contain spaces.
      */
     private static class ArgumentsHelper {
-        private final List<String> positionalArguments = new ArrayList<String>();
-        private final Map<String, String> namedArguments = new HashMap<String, String>();
+        private final List<String> positionalArguments = new ArrayList<>();
+        private final Map<String, String> namedArguments = new HashMap<>();
         private final String entry;
 
         ArgumentsHelper(@NotNull String directiveEntry) {
diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/JsTestUtils.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/JsTestUtils.java
index dcf69cd130d..8fc16c29bc2 100644
--- a/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/JsTestUtils.java
+++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/JsTestUtils.java
@@ -58,7 +58,7 @@ public final class JsTestUtils {
     public static List<String> getAllFilesInDir(@NotNull String dirName) {
         File dir = new File(dirName);
         assert dir.isDirectory() : dir + " is not a directory.";
-        List<String> fullFilePaths = new ArrayList<String>();
+        List<String> fullFilePaths = new ArrayList<>();
         for (String fileName : dir.list()) {
             fullFilePaths.add(dirName + "/" + fileName);
         }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/facade/FacadeUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/facade/FacadeUtils.java
index 0bd3b3bd3c9..77fd0b6fe8f 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/facade/FacadeUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/facade/FacadeUtils.java
@@ -28,7 +28,7 @@ public final class FacadeUtils {
 
     @NotNull
     public static List<String> parseString(@NotNull String argumentString) {
-        List<String> result = new ArrayList<String>();
+        List<String> result = new ArrayList<>();
         StringTokenizer stringTokenizer = new StringTokenizer(argumentString);
         while (stringTokenizer.hasMoreTokens()) {
             result.add(stringTokenizer.nextToken());
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java
index 12db6706966..f109059e6f8 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java
@@ -16,19 +16,19 @@
 
 package org.jetbrains.kotlin.js.facade;
 
-import org.jetbrains.kotlin.js.backend.ast.JsProgram;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS;
 import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult;
+import org.jetbrains.kotlin.js.backend.ast.JsProgram;
 import org.jetbrains.kotlin.js.config.JsConfig;
 import org.jetbrains.kotlin.js.coroutine.CoroutineTransformer;
 import org.jetbrains.kotlin.js.facade.exceptions.TranslationException;
 import org.jetbrains.kotlin.js.inline.JsInliner;
-import org.jetbrains.kotlin.js.translate.context.StaticContext;
 import org.jetbrains.kotlin.js.inline.clean.RemoveUnusedImportsKt;
 import org.jetbrains.kotlin.js.inline.clean.ResolveTemporaryNamesKt;
+import org.jetbrains.kotlin.js.translate.context.StaticContext;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.Translation;
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
@@ -96,7 +96,7 @@ public final class K2JSTranslator {
         expandIsCalls(program, context);
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
 
-        List<String> importedModules = new ArrayList<String>();
+        List<String> importedModules = new ArrayList<>();
         for (StaticContext.ImportedModule module : context.getImportedModules()) {
             importedModules.add(module.getExternalName());
         }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/sourceMap/JsSourceGenerationVisitor.java b/js/js.translator/src/org/jetbrains/kotlin/js/sourceMap/JsSourceGenerationVisitor.java
index 5b26414a5ec..fe668853405 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/sourceMap/JsSourceGenerationVisitor.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/sourceMap/JsSourceGenerationVisitor.java
@@ -29,7 +29,7 @@ public class JsSourceGenerationVisitor extends JsToStringGenerationVisitor imple
     @Nullable
     private final SourceMapBuilder sourceMapBuilder;
 
-    private final List<Object> pendingSources = new SmartList<Object>();
+    private final List<Object> pendingSources = new SmartList<>();
 
     public JsSourceGenerationVisitor(TextOutput out, @Nullable SourceMapBuilder sourceMapBuilder) {
         super(out);
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/sourceMap/SourceMap3Builder.java b/js/js.translator/src/org/jetbrains/kotlin/js/sourceMap/SourceMap3Builder.java
index 9b3b93d3ab6..e260e1bf562 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/sourceMap/SourceMap3Builder.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/sourceMap/SourceMap3Builder.java
@@ -43,7 +43,7 @@ public class SourceMap3Builder implements SourceMapBuilder {
         }
     };
 
-    private final List<String> orderedSources = new ArrayList<String>();
+    private final List<String> orderedSources = new ArrayList<>();
 
     private int previousGeneratedColumn = -1;
     private int previousSourceIndex;
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/StaticContext.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/StaticContext.java
index da8f98d90e0..fbd295c701b 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/StaticContext.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/StaticContext.java
@@ -104,7 +104,7 @@ public final class StaticContext {
     private final Map<MemberDescriptor, List<DeclarationDescriptor>> classOrConstructorClosure = Maps.newHashMap();
 
     @NotNull
-    private final Map<ClassDescriptor, List<DeferredCallSite>> deferredCallSites = new HashMap<ClassDescriptor, List<DeferredCallSite>>();
+    private final Map<ClassDescriptor, List<DeferredCallSite>> deferredCallSites = new HashMap<>();
 
     @NotNull
     private final JsConfig config;
@@ -116,16 +116,16 @@ public final class StaticContext {
     private final NameSuggestion nameSuggestion = new NameSuggestion();
 
     @NotNull
-    private final Map<DeclarationDescriptor, JsName> nameCache = new HashMap<DeclarationDescriptor, JsName>();
+    private final Map<DeclarationDescriptor, JsName> nameCache = new HashMap<>();
 
     @NotNull
-    private final Map<PropertyDescriptor, JsName> backingFieldNameCache = new HashMap<PropertyDescriptor, JsName>();
+    private final Map<PropertyDescriptor, JsName> backingFieldNameCache = new HashMap<>();
 
     @NotNull
-    private final Map<DeclarationDescriptor, JsExpression> fqnCache = new HashMap<DeclarationDescriptor, JsExpression>();
+    private final Map<DeclarationDescriptor, JsExpression> fqnCache = new HashMap<>();
 
     @NotNull
-    private final Map<ImportedModuleKey, ImportedModule> importedModules = new LinkedHashMap<ImportedModuleKey, ImportedModule>();
+    private final Map<ImportedModuleKey, ImportedModule> importedModules = new LinkedHashMap<>();
 
     private Collection<ImportedModule> readOnlyImportedModules;
 
@@ -136,22 +136,22 @@ public final class StaticContext {
     private JsFunction rootFunction;
 
     @NotNull
-    private final List<JsStatement> declarationStatements = new ArrayList<JsStatement>();
+    private final List<JsStatement> declarationStatements = new ArrayList<>();
 
     @NotNull
-    private final List<JsStatement> topLevelStatements = new ArrayList<JsStatement>();
+    private final List<JsStatement> topLevelStatements = new ArrayList<>();
 
     @NotNull
-    private final List<JsStatement> importStatements = new ArrayList<JsStatement>();
+    private final List<JsStatement> importStatements = new ArrayList<>();
 
     @NotNull
     private final DeclarationExporter exporter = new DeclarationExporter(this);
 
     @NotNull
-    private final Set<ClassDescriptor> classes = new LinkedHashSet<ClassDescriptor>();
+    private final Set<ClassDescriptor> classes = new LinkedHashSet<>();
 
     @NotNull
-    private final Map<FqName, JsScope> packageScopes = new HashMap<FqName, JsScope>();
+    private final Map<FqName, JsScope> packageScopes = new HashMap<>();
 
     //TODO: too many parameters in constructor
     private StaticContext(
@@ -392,7 +392,7 @@ public final class StaticContext {
             scope = rootScope;
         }
 
-        List<JsName> names = new ArrayList<JsName>();
+        List<JsName> names = new ArrayList<>();
         if (suggested.getStable()) {
             for (String namePart : suggested.getNames()) {
                 JsName name = scope.declareName(namePart);
@@ -756,7 +756,7 @@ public final class StaticContext {
     }
 
     private void addClassPrototypes() {
-        Set<ClassDescriptor> visited = new HashSet<ClassDescriptor>();
+        Set<ClassDescriptor> visited = new HashSet<>();
         for (ClassDescriptor cls : classes) {
             addClassPrototypes(cls, visited);
         }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/TranslationContext.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/TranslationContext.java
index 3446b0603fa..c5477aeaf04 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/TranslationContext.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/TranslationContext.java
@@ -77,7 +77,7 @@ public class TranslationContext {
         return new TranslationContext(null, staticContext, rootDynamicContext, rootAliasingContext, null, null);
     }
 
-    private final Map<JsExpression, TemporaryConstVariable> expressionToTempConstVariableCache = new HashMap<JsExpression, TemporaryConstVariable>();
+    private final Map<JsExpression, TemporaryConstVariable> expressionToTempConstVariableCache = new HashMap<>();
 
     private TranslationContext(
             @Nullable TranslationContext parent,
@@ -602,7 +602,7 @@ public class TranslationContext {
     public void startDeclaration() {
         ClassDescriptor classDescriptor = this.classDescriptor;
         if (classDescriptor != null && !(classDescriptor.getContainingDeclaration() instanceof ClassOrPackageFragmentDescriptor)) {
-            staticContext.getDeferredCallSites().put(classDescriptor, new ArrayList<DeferredCallSite>());
+            staticContext.getDeferredCallSites().put(classDescriptor, new ArrayList<>());
         }
     }
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/JsDataClassGenerator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/JsDataClassGenerator.java
index 4821bd524c9..11d354f36bf 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/JsDataClassGenerator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/JsDataClassGenerator.java
@@ -60,7 +60,7 @@ class JsDataClassGenerator extends DataClassMethodGenerator {
 
         assert function.getValueParameters().size() == constructorParameters.size();
 
-        List<JsExpression> constructorArguments = new ArrayList<JsExpression>(constructorParameters.size());
+        List<JsExpression> constructorArguments = new ArrayList<>(constructorParameters.size());
 
         for (int i = 0; i < constructorParameters.size(); i++) {
             KtParameter constructorParam = constructorParameters.get(i);
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/DestructuringDeclarationTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/DestructuringDeclarationTranslator.java
index 5adb8cdc8fc..f9a759dc16a 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/DestructuringDeclarationTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/DestructuringDeclarationTranslator.java
@@ -81,7 +81,7 @@ public class DestructuringDeclarationTranslator extends AbstractTranslator {
             context().getCurrentBlock().getStatements().add(JsAstUtils.newVar(multiObjectName, initializer));
         }
 
-        List<JsVars.JsVar> jsVars = new ArrayList<JsVars.JsVar>();
+        List<JsVars.JsVar> jsVars = new ArrayList<>();
         JsNameRef multiObjNameRef = multiObjectName.makeRef();
         for (KtDestructuringDeclarationEntry entry : multiDeclaration.getEntries()) {
             VariableDescriptor descriptor = BindingContextUtils.getNotNull(context().bindingContext(), BindingContext.VARIABLE, entry);
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java
index 1d17970d2bb..2d7143edee5 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java
@@ -532,7 +532,7 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
         JsExpression constructor = ReferenceTranslator.translateAsTypeReference(descriptor, context);
         List<DeclarationDescriptor> closure = context.getClassOrConstructorClosure(descriptor);
-        List<JsExpression> closureArgs = new ArrayList<JsExpression>();
+        List<JsExpression> closureArgs = new ArrayList<>();
         if (closure != null) {
             for (DeclarationDescriptor capturedValue : closure) {
                 closureArgs.add(context.getArgumentForClosureConstructor(capturedValue));
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/StringTemplateTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/StringTemplateTranslator.java
index ffec0b68f83..db8d4cc461f 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/StringTemplateTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/StringTemplateTranslator.java
@@ -93,7 +93,7 @@ public final class StringTemplateTranslator extends AbstractTranslator {
             }
 
             if (type == null || type.isMarkedNullable()) {
-                append(TopLevelFIF.TO_STRING.apply((JsExpression) null, new SmartList<JsExpression>(translatedExpression), context()));
+                append(TopLevelFIF.TO_STRING.apply((JsExpression) null, new SmartList<>(translatedExpression), context()));
             }
             else if (KotlinBuiltIns.isChar(type)) {
                 append(JsAstUtils.charToString(translatedExpression));
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java
index eef1c23b012..917d7311301 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java
@@ -221,7 +221,7 @@ public final class WhenTranslator extends AbstractTranslator {
         assert expressionToMatch != null : "Range pattern is only available for 'when (C) { in ... }'  expressions: " +
                                            PsiUtilsKt.getTextWithLocation(condition);
 
-        Map<KtExpression, JsExpression> subjectAliases = new HashMap<KtExpression, JsExpression>();
+        Map<KtExpression, JsExpression> subjectAliases = new HashMap<>();
         subjectAliases.put(whenExpression.getSubjectExpression(), expressionToMatch);
         TranslationContext callContext = context.innerContextWithAliasesForExpressions(subjectAliases);
         boolean negated = condition.getOperationReference().getReferencedNameElementType() == KtTokens.NOT_IN;
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/Translation.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/Translation.java
index 401e7ce2f18..d5d6d2693b6 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/Translation.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/Translation.java
@@ -285,7 +285,7 @@ public final class Translation {
 
         // Invoke function passing modules as arguments
         // This should help minifier tool to recognize references to these modules as local variables and make them shorter.
-        List<StaticContext.ImportedModule> importedModuleList = new ArrayList<StaticContext.ImportedModule>();
+        List<StaticContext.ImportedModule> importedModuleList = new ArrayList<>();
 
         for (StaticContext.ImportedModule importedModule : staticContext.getImportedModules()) {
             rootFunction.getParameters().add(new JsParameter(importedModule.getInternalName()));
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/ClassInitializerTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/ClassInitializerTranslator.java
index 213541d21df..639aa0515d0 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/ClassInitializerTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/ClassInitializerTranslator.java
@@ -198,7 +198,7 @@ public final class ClassInitializerTranslator extends AbstractTranslator {
                 initFunction.getBody().getStatements().add(fixedInvocation.makeStmt());
             }
             else {
-                List<JsExpression> arguments = new ArrayList<JsExpression>();
+                List<JsExpression> arguments = new ArrayList<>();
 
                 ConstructorDescriptor superDescriptor = (ConstructorDescriptor) superCall.getResultingDescriptor();
                 if (superDescriptor instanceof TypeAliasConstructorDescriptor) {
@@ -319,7 +319,7 @@ public final class ClassInitializerTranslator extends AbstractTranslator {
 
     @NotNull
     private List<JsExpression> getAdditionalArgumentsForEnumConstructor() {
-        List<JsExpression> additionalArguments = new ArrayList<JsExpression>();
+        List<JsExpression> additionalArguments = new ArrayList<>();
         additionalArguments.add(program().getStringLiteral(classDescriptor.getName().asString()));
         additionalArguments.add(program().getNumberLiteral(ordinal));
         return additionalArguments;
@@ -350,7 +350,7 @@ public final class ClassInitializerTranslator extends AbstractTranslator {
     @NotNull
     private List<JsParameter> translatePrimaryConstructorParameters() {
         List<KtParameter> parameterList = getPrimaryConstructorParameters(classDeclaration);
-        List<JsParameter> result = new ArrayList<JsParameter>();
+        List<JsParameter> result = new ArrayList<>();
         for (KtParameter jetParameter : parameterList) {
             result.add(translateParameter(jetParameter));
         }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/FunctionIntrinsics.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/FunctionIntrinsics.java
index 66502e29437..433b8e6b0af 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/FunctionIntrinsics.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/FunctionIntrinsics.java
@@ -30,7 +30,7 @@ import java.util.Map;
 public final class FunctionIntrinsics {
 
     @NotNull
-    private final Map<FunctionDescriptor, FunctionIntrinsic> intrinsicCache = new THashMap<FunctionDescriptor, FunctionIntrinsic>();
+    private final Map<FunctionDescriptor, FunctionIntrinsic> intrinsicCache = new THashMap<>();
 
     @NotNull
     private final List<FunctionIntrinsicFactory> factories = Lists.newArrayList();
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/KotlinFunctionIntrinsic.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/KotlinFunctionIntrinsic.java
index f242f06233a..f5c01a9b809 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/KotlinFunctionIntrinsic.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/KotlinFunctionIntrinsic.java
@@ -48,7 +48,7 @@ public class KotlinFunctionIntrinsic extends FunctionIntrinsicWithReceiverComput
     ) {
         JsExpression function = JsAstUtils.pureFqn(functionName, Namer.kotlinObject());
         if (additionalArguments.length > 0) {
-            List<JsExpression> newArguments = new ArrayList<JsExpression>(arguments);
+            List<JsExpression> newArguments = new ArrayList<>(arguments);
             for (JsExpression e : additionalArguments) {
                 newArguments.add(e.deepCopy());
             }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedAssignmentTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedAssignmentTranslator.java
index ea65cd46afb..c69dce74418 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedAssignmentTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedAssignmentTranslator.java
@@ -82,7 +82,7 @@ public final class OverloadedAssignmentTranslator extends AssignmentTranslator {
             innerContext.addStatementsToCurrentBlockFrom(argumentBlock);
         }
 
-        Map<KtExpression, JsExpression> aliases = new HashMap<KtExpression, JsExpression>();
+        Map<KtExpression, JsExpression> aliases = new HashMap<>();
         aliases.put(argumentPsi, argument);
         innerContext = innerContext.innerContextWithAliasesForExpressions(aliases);
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AccessTranslationUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AccessTranslationUtils.java
index 323ba28e909..cefa32bd86b 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AccessTranslationUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AccessTranslationUtils.java
@@ -59,7 +59,7 @@ public final class AccessTranslationUtils {
     ) {
         TranslationContext accessArrayContext;
         if (forceOrderOfEvaluation) {
-            Map<KtExpression, JsExpression> indexesMap = new LinkedHashMap<KtExpression, JsExpression>();
+            Map<KtExpression, JsExpression> indexesMap = new LinkedHashMap<>();
             for(KtExpression indexExpression : expression.getIndexExpressions()) {
                 JsExpression jsIndexExpression = context.cacheExpressionIfNeeded(
                         Translation.translateAsExpression(indexExpression, context));
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ArrayAccessTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ArrayAccessTranslator.java
index 3c337433939..99556acddb9 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ArrayAccessTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ArrayAccessTranslator.java
@@ -112,7 +112,7 @@ public class ArrayAccessTranslator extends AbstractTranslator implements AccessT
     @NotNull
     @Override
     public AccessTranslator getCached() {
-        Map<KtExpression, JsExpression> aliases = new HashMap<KtExpression, JsExpression>();
+        Map<KtExpression, JsExpression> aliases = new HashMap<>();
 
         JsExpression arrayExpression = context().cacheExpressionIfNeeded(getArrayExpression());
         aliases.put(expression.getArrayExpression(), arrayExpression);
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java
index acb49f8d91a..23ace4b8742 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java
@@ -126,7 +126,7 @@ public final class CallExpressionTranslator extends AbstractCallExpressionTransl
         }
 
         LexicalScope lexicalScope = context().bindingContext().get(BindingContextSlicesJsKt.LEXICAL_SCOPE_FOR_JS, resolvedCall);
-        Map<JsName, JsExpression> replacements = new HashMap<JsName, JsExpression>();
+        Map<JsName, JsExpression> replacements = new HashMap<>();
         if (lexicalScope != null) {
             Set<JsName> references = CollectUtilsKt.collectUsedNames(node);
             references.removeAll(CollectUtilsKt.collectDefinedNames(node));
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/FunctionBodyTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/FunctionBodyTranslator.java
index 85af1f48dbe..40cab009c7e 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/FunctionBodyTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/FunctionBodyTranslator.java
@@ -50,7 +50,7 @@ public final class FunctionBodyTranslator extends AbstractTranslator {
             @NotNull KtDeclarationWithBody declarationWithBody,
             @NotNull TranslationContext functionBodyContext
     ) {
-        Map<DeclarationDescriptor, JsExpression> aliases = new HashMap<DeclarationDescriptor, JsExpression>();
+        Map<DeclarationDescriptor, JsExpression> aliases = new HashMap<>();
         LocalFunctionCollector functionCollector = new LocalFunctionCollector(functionBodyContext.bindingContext());
         declarationWithBody.acceptChildren(functionCollector, null);
 
@@ -74,7 +74,7 @@ public final class FunctionBodyTranslator extends AbstractTranslator {
             @NotNull TranslationContext functionBodyContext) {
         List<ValueParameterDescriptor> valueParameters = descriptor.getValueParameters();
 
-        List<JsStatement> result = new ArrayList<JsStatement>(valueParameters.size());
+        List<JsStatement> result = new ArrayList<>(valueParameters.size());
         for (ValueParameterDescriptor valueParameter : valueParameters) {
             if (!valueParameter.declaresDefaultValue()) continue;
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsAstUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsAstUtils.java
index 905b1a4a668..a408fc8b606 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsAstUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsAstUtils.java
@@ -215,7 +215,7 @@ public final class JsAstUtils {
         if (value < Integer.MIN_VALUE || value > Integer.MAX_VALUE) {
             int low = (int) value;
             int high = (int) (value >> 32);
-            List<JsExpression> args = new SmartList<JsExpression>();
+            List<JsExpression> args = new SmartList<>();
             args.add(context.program().getNumberLiteral(low));
             args.add(context.program().getNumberLiteral(high));
             return new JsNew(Namer.kotlinLong(), args);
@@ -368,7 +368,7 @@ public final class JsAstUtils {
         JsBinaryOperation binary = (JsBinaryOperation) expr;
         if (binary.getOperator() != JsBinaryOperator.ASG) return null;
 
-        return new Pair<JsExpression, JsExpression>(binary.getArg1(), binary.getArg2());
+        return new Pair<>(binary.getArg1(), binary.getArg2());
     }
 
     @Nullable
@@ -379,7 +379,7 @@ public final class JsAstUtils {
         JsNameRef nameRef = (JsNameRef) assignment.getFirst();
         if (nameRef.getName() == null || nameRef.getQualifier() != null) return null;
 
-        return new Pair<JsName, JsExpression>(nameRef.getName(), assignment.getSecond());
+        return new Pair<>(nameRef.getName(), assignment.getSecond());
     }
 
     @NotNull
@@ -457,7 +457,7 @@ public final class JsAstUtils {
             return Collections.emptyList();
         }
 
-        List<JsExpression> result = new SmartList<JsExpression>();
+        List<JsExpression> result = new SmartList<>();
         for (String str : strings) {
             result.add(program.getStringLiteral(str));
         }
@@ -523,7 +523,7 @@ public final class JsAstUtils {
             return ((JsBlock) statement).getStatements();
         }
 
-        return new SmartList<JsStatement>(statement);
+        return new SmartList<>(statement);
     }
 
     @NotNull
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/TranslationUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/TranslationUtils.java
index 7e236e822f7..32eca48b59c 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/TranslationUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/TranslationUtils.java
@@ -265,7 +265,7 @@ public final class TranslationUtils {
             @NotNull JsExpression receiver,
             @NotNull List<? extends JsExpression> arguments
     ) {
-        List<JsExpression> argumentList = new ArrayList<JsExpression>(1 + arguments.size());
+        List<JsExpression> argumentList = new ArrayList<>(1 + arguments.size());
         argumentList.add(receiver);
         argumentList.addAll(arguments);
         return argumentList;