Snapshot idea/138.1029 from git://git.jetbrains.org/idea/community.git

Update from idea/138.538 to idea/138.1029

Change-Id: I828f829a968439a99ec67640990c18ff7c9b58ce

32 files changed, 217 insertions, 94 deletions

diff --git a/jps/jps-builders/jps-builders.iml b/jps/jps-builders/jps-builders.iml
index 22e65e9607ee..565691fb134e 100644
--- a/jps/jps-builders/jps-builders.iml
+++ b/jps/jps-builders/jps-builders.iml
@@ -12,7 +12,7 @@
     <orderEntry type="module" module-name="forms_rt" />
     <orderEntry type="module" module-name="forms-compiler" />
     <orderEntry type="module" module-name="instrumentation-util" />
-    <orderEntry type="library" exported="" name="asm4" level="project" />
+    <orderEntry type="library" exported="" name="asm5" level="project" />
     <orderEntry type="library" name="JDOM" level="project" />
     <orderEntry type="library" name="NanoXML" level="project" />
     <orderEntry type="library" name="jgoodies-forms" level="project" />
diff --git a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Callbacks.java b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Callbacks.java
index ce3c2a4fc269..16a3da40fca1 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Callbacks.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Callbacks.java
@@ -15,7 +15,7 @@
  */
 package org.jetbrains.jps.builders.java.dependencyView;
 
-import org.jetbrains.asm4.ClassReader;
+import org.jetbrains.org.objectweb.asm.ClassReader;
 
 import java.io.File;
 import java.util.Collection;
diff --git a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/ClassRepr.java b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/ClassRepr.java
index 21818f540cc7..2cbfe0592f3a 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/ClassRepr.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/ClassRepr.java
@@ -20,8 +20,8 @@ import com.intellij.util.io.DataInputOutputUtil;
 import gnu.trove.THashSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.asm4.Opcodes;
 import org.jetbrains.jps.builders.storage.BuildDataCorruptedException;
+import org.jetbrains.org.objectweb.asm.Opcodes;
 
 import java.io.*;
 import java.lang.annotation.RetentionPolicy;
diff --git a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/ClassfileAnalyzer.java b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/ClassfileAnalyzer.java
index 03dddda7183f..01013e05186a 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/ClassfileAnalyzer.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/ClassfileAnalyzer.java
@@ -19,9 +19,9 @@ import com.intellij.openapi.util.Pair;
 import gnu.trove.THashMap;
 import gnu.trove.THashSet;
 import gnu.trove.TIntHashSet;
-import org.jetbrains.asm4.*;
-import org.jetbrains.asm4.signature.SignatureReader;
-import org.jetbrains.asm4.signature.SignatureVisitor;
+import org.jetbrains.org.objectweb.asm.*;
+import org.jetbrains.org.objectweb.asm.signature.SignatureReader;
+import org.jetbrains.org.objectweb.asm.signature.SignatureVisitor;
 
 import java.lang.annotation.RetentionPolicy;
 import java.util.EnumSet;
@@ -55,7 +55,7 @@ class ClassfileAnalyzer {
   private class ClassCrawler extends ClassVisitor {
     private class AnnotationRetentionPolicyCrawler extends AnnotationVisitor {
       private AnnotationRetentionPolicyCrawler() {
-        super(Opcodes.ASM4);
+        super(Opcodes.ASM5);
       }
 
       public void visit(String name, Object value) {
@@ -79,7 +79,7 @@ class ClassfileAnalyzer {
 
     private class AnnotationTargetCrawler extends AnnotationVisitor {
       private AnnotationTargetCrawler() {
-        super(Opcodes.ASM4);
+        super(Opcodes.ASM5);
       }
 
       public void visit(String name, Object value) {
@@ -108,7 +108,7 @@ class ClassfileAnalyzer {
       private final TIntHashSet myUsedArguments = new TIntHashSet();
 
       private AnnotationCrawler(final TypeRepr.ClassType type, final ElemType target) {
-        super(Opcodes.ASM4);
+        super(Opcodes.ASM5);
         this.myType = type;
         this.myTarget = target;
         final Set<ElemType> targets = myAnnotationTargets.get(type);
@@ -160,9 +160,7 @@ class ClassfileAnalyzer {
           return "()D;";
         }
 
-        final String s = "()L" + name + ";";
-
-        return s;
+        return "()L" + name + ";";
       }
 
       public void visit(String name, Object value) {
@@ -171,10 +169,7 @@ class ClassfileAnalyzer {
 
         if (value instanceof Type) {
           final String className = ((Type)value).getClassName().replace('.', '/');
-
-          if (className != null) {
-            myUsages.add(UsageRepr.createClassUsage(myContext, myContext.get(className)));
-          }
+          myUsages.add(UsageRepr.createClassUsage(myContext, myContext.get(className)));
         }
 
         myUsages.add(UsageRepr.createMethodUsage(myContext, methodName, myType.className, methodDescr));
@@ -220,9 +215,8 @@ class ClassfileAnalyzer {
       }
     }
 
-    private final SignatureVisitor mySignatureCrawler = new SignatureVisitor(Opcodes.ASM4) {
+    private final SignatureVisitor mySignatureCrawler = new SignatureVisitor(Opcodes.ASM5) {
       public void visitFormalTypeParameter(String name) {
-        return;
       }
 
       public SignatureVisitor visitClassBound() {
@@ -254,11 +248,9 @@ class ClassfileAnalyzer {
       }
 
       public void visitBaseType(char descriptor) {
-        return;
       }
 
       public void visitTypeVariable(String name) {
-        return;
       }
 
       public SignatureVisitor visitArrayType() {
@@ -266,11 +258,9 @@ class ClassfileAnalyzer {
       }
 
       public void visitInnerClassType(String name) {
-        return;
       }
 
       public void visitTypeArgument() {
-        return;
       }
 
       public SignatureVisitor visitTypeArgument(char wildcard) {
@@ -316,7 +306,7 @@ class ClassfileAnalyzer {
     final Map<TypeRepr.ClassType, Set<ElemType>> myAnnotationTargets = new THashMap<TypeRepr.ClassType, Set<ElemType>>();
 
     public ClassCrawler(final int fn) {
-      super(Opcodes.ASM4);
+      super(Opcodes.ASM5);
       myFileName = fn;
     }
 
@@ -407,7 +397,7 @@ class ClassfileAnalyzer {
         myFields.add(new FieldRepr(myContext, access, myContext.get(n), myContext.get(desc), myContext.get(signature), value));
       }
 
-      return new FieldVisitor(Opcodes.ASM4) {
+      return new FieldVisitor(Opcodes.ASM5) {
         @Override
         public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
           return new AnnotationCrawler((TypeRepr.ClassType)TypeRepr.getType(myContext, myContext.get(desc)), ElemType.FIELD);
@@ -421,7 +411,7 @@ class ClassfileAnalyzer {
 
       processSignature(signature);
 
-      return new MethodVisitor(Opcodes.ASM4) {
+      return new MethodVisitor(Opcodes.ASM5) {
         @Override
         public void visitEnd() {
           if ((access & Opcodes.ACC_SYNTHETIC) == 0 || (access & Opcodes.ACC_BRIDGE) > 0) {
@@ -438,7 +428,7 @@ class ClassfileAnalyzer {
 
         @Override
         public AnnotationVisitor visitAnnotationDefault() {
-          return new AnnotationVisitor(Opcodes.ASM4) {
+          return new AnnotationVisitor(Opcodes.ASM5) {
             public void visit(String name, Object value) {
               defaultValue.set(value);
             }
@@ -531,7 +521,7 @@ class ClassfileAnalyzer {
         }
 
         @Override
-        public void visitMethodInsn(int opcode, String owner, String name, String desc) {
+        public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
           final int methodName = myContext.get(name);
           final int methodOwner = myContext.get(owner);
 
@@ -539,7 +529,7 @@ class ClassfileAnalyzer {
           myUsages.add(UsageRepr.createMetaMethodUsage(myContext, methodName, methodOwner, desc));
           addClassUsage(TypeRepr.getType(myContext, Type.getReturnType(desc)));
 
-          super.visitMethodInsn(opcode, owner, name, desc);
+          super.visitMethodInsn(opcode, owner, name, desc, itf);
         }
 
         private void addClassUsage(final TypeRepr.AbstractType type) {
diff --git a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Difference.java b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Difference.java
index d96cf7c7b59e..95ed983a9181 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Difference.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Difference.java
@@ -16,7 +16,7 @@
 package org.jetbrains.jps.builders.java.dependencyView;
 
 import com.intellij.openapi.util.Pair;
-import org.jetbrains.asm4.Opcodes;
+import org.jetbrains.org.objectweb.asm.Opcodes;
 
 import java.util.*;
 
diff --git a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Mappings.java b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Mappings.java
index a0c4b60f3f69..a397d4b87a55 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Mappings.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Mappings.java
@@ -23,10 +23,10 @@ import com.intellij.util.io.IntInlineKeyDescriptor;
 import gnu.trove.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.asm4.ClassReader;
-import org.jetbrains.asm4.Opcodes;
 import org.jetbrains.jps.builders.storage.BuildDataCorruptedException;
 import org.jetbrains.jps.incremental.storage.FileKeyDescriptor;
+import org.jetbrains.org.objectweb.asm.ClassReader;
+import org.jetbrains.org.objectweb.asm.Opcodes;
 
 import java.io.File;
 import java.io.FileNotFoundException;
diff --git a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/MethodRepr.java b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/MethodRepr.java
index 72ad7557cd0b..fea3d8a3d8d8 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/MethodRepr.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/MethodRepr.java
@@ -19,8 +19,8 @@ import com.intellij.util.io.DataExternalizer;
 import com.intellij.util.io.DataInputOutputUtil;
 import gnu.trove.THashSet;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.asm4.Type;
 import org.jetbrains.jps.builders.storage.BuildDataCorruptedException;
+import org.jetbrains.org.objectweb.asm.Type;
 
 import java.io.DataInput;
 import java.io.DataOutput;
diff --git a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Proto.java b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Proto.java
index a7e70f67dcbc..2810863de840 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Proto.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/Proto.java
@@ -16,8 +16,8 @@
 package org.jetbrains.jps.builders.java.dependencyView;
 
 import com.intellij.util.io.DataInputOutputUtil;
-import org.jetbrains.asm4.Opcodes;
 import org.jetbrains.jps.builders.storage.BuildDataCorruptedException;
+import org.jetbrains.org.objectweb.asm.Opcodes;
 
 import java.io.DataInput;
 import java.io.DataOutput;
diff --git a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/ProtoMember.java b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/ProtoMember.java
index 18582a8bc373..afb5cc958a93 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/ProtoMember.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/ProtoMember.java
@@ -16,8 +16,8 @@
 package org.jetbrains.jps.builders.java.dependencyView;
 
 import com.intellij.util.io.DataInputOutputUtil;
-import org.jetbrains.asm4.Type;
 import org.jetbrains.jps.builders.storage.BuildDataCorruptedException;
+import org.jetbrains.org.objectweb.asm.Type;
 
 import java.io.DataInput;
 import java.io.DataOutput;
diff --git a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/TypeRepr.java b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/TypeRepr.java
index af85d75f344f..da4d71baff1a 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/TypeRepr.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/TypeRepr.java
@@ -19,8 +19,8 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.io.DataExternalizer;
 import com.intellij.util.io.DataInputOutputUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.asm4.Type;
 import org.jetbrains.jps.builders.storage.BuildDataCorruptedException;
+import org.jetbrains.org.objectweb.asm.Type;
 
 import java.io.DataInput;
 import java.io.DataOutput;
diff --git a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/UsageRepr.java b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/UsageRepr.java
index 5059152e6a63..e7b376980fae 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/UsageRepr.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/UsageRepr.java
@@ -20,8 +20,8 @@ import com.intellij.util.io.DataInputOutputUtil;
 import gnu.trove.TIntHashSet;
 import gnu.trove.TIntProcedure;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.asm4.Type;
 import org.jetbrains.jps.builders.storage.BuildDataCorruptedException;
+import org.jetbrains.org.objectweb.asm.Type;
 
 import java.io.DataInput;
 import java.io.DataOutput;
diff --git a/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/AsmUtil.java b/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/AsmUtil.java
index 4082d9542698..14552a8173d3 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/AsmUtil.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/AsmUtil.java
@@ -17,7 +17,7 @@ package org.jetbrains.jps.classFilesIndex;
 
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.containers.ContainerUtil;
-import org.jetbrains.asm4.Type;
+import org.jetbrains.org.objectweb.asm.Type;
 
 import java.util.Set;
 
diff --git a/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFileIndexer.java b/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFileIndexer.java
index 827183e3fb82..e7b3212543e1 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFileIndexer.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFileIndexer.java
@@ -18,8 +18,8 @@ package org.jetbrains.jps.classFilesIndex.indexer.api;
 import com.intellij.util.io.DataExternalizer;
 import com.intellij.util.io.KeyDescriptor;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.asm4.ClassReader;
 import org.jetbrains.jps.builders.java.dependencyView.Mappings;
+import org.jetbrains.org.objectweb.asm.ClassReader;
 
 import java.util.Map;
 
diff --git a/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFilesIndexWriter.java b/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFilesIndexWriter.java
index 932ddb1b64ef..95e92f0f7478 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFilesIndexWriter.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFilesIndexWriter.java
@@ -15,15 +15,14 @@
  */
 package org.jetbrains.jps.classFilesIndex.indexer.api;
 
-import com.intellij.openapi.diagnostic.Log;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.io.PersistentHashMap;
-import org.jetbrains.asm4.ClassReader;
 import org.jetbrains.jps.builders.java.dependencyView.Mappings;
 import org.jetbrains.jps.classFilesIndex.indexer.api.storage.ClassFilesIndexStorageBase;
 import org.jetbrains.jps.classFilesIndex.indexer.api.storage.ClassFilesIndexStorageWriter;
 import org.jetbrains.jps.incremental.CompileContext;
+import org.jetbrains.org.objectweb.asm.ClassReader;
 
 import java.io.File;
 import java.io.IOException;
diff --git a/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFilesIndicesBuilder.java b/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFilesIndicesBuilder.java
index 92fd4d9351b5..384e4cb6a193 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFilesIndicesBuilder.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFilesIndicesBuilder.java
@@ -17,26 +17,22 @@ package org.jetbrains.jps.classFilesIndex.indexer.api;
 
 import com.intellij.compiler.instrumentation.InstrumentationClassFinder;
 import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.util.Processor;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.asm4.ClassReader;
-import org.jetbrains.asm4.ClassWriter;
 import org.jetbrains.jps.ModuleChunk;
 import org.jetbrains.jps.builders.java.JavaBuilderUtil;
-import org.jetbrains.jps.builders.java.dependencyView.Mappings;
 import org.jetbrains.jps.incremental.BinaryContent;
 import org.jetbrains.jps.incremental.CompileContext;
 import org.jetbrains.jps.incremental.CompiledClass;
 import org.jetbrains.jps.incremental.instrumentation.BaseInstrumentingBuilder;
-import org.jetbrains.jps.model.java.JpsJavaExtensionService;
-import org.jetbrains.jps.model.module.JpsModule;
 import org.jetbrains.jps.service.JpsServiceManager;
+import org.jetbrains.org.objectweb.asm.ClassReader;
+import org.jetbrains.org.objectweb.asm.ClassWriter;
 
-import java.io.File;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
diff --git a/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/impl/MethodsUsageIndexer.java b/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/impl/MethodsUsageIndexer.java
index 7caa11b18fa4..4853cb5b109c 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/impl/MethodsUsageIndexer.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/impl/MethodsUsageIndexer.java
@@ -17,15 +17,14 @@ package org.jetbrains.jps.classFilesIndex.indexer.impl;
 
 import com.intellij.util.io.DataExternalizer;
 import com.intellij.util.io.EnumeratorIntegerDescriptor;
-import com.intellij.util.io.EnumeratorStringDescriptor;
 import com.intellij.util.io.KeyDescriptor;
 import gnu.trove.TObjectIntHashMap;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.asm4.*;
 import org.jetbrains.jps.builders.java.dependencyView.Mappings;
 import org.jetbrains.jps.classFilesIndex.AsmUtil;
 import org.jetbrains.jps.classFilesIndex.TObjectIntHashMapExternalizer;
 import org.jetbrains.jps.classFilesIndex.indexer.api.ClassFileIndexer;
+import org.jetbrains.org.objectweb.asm.*;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -45,9 +44,9 @@ public class MethodsUsageIndexer extends ClassFileIndexer<Integer, TObjectIntHas
   public Map<Integer, TObjectIntHashMap<EnumeratedMethodIncompleteSignature>> map(final ClassReader inputData, final Mappings mappings) {
     final Map<Integer, TObjectIntHashMap<EnumeratedMethodIncompleteSignature>> map =
       new HashMap<Integer, TObjectIntHashMap<EnumeratedMethodIncompleteSignature>>();
-    final MethodVisitor methodVisitor = new MethodVisitor(Opcodes.ASM4) {
+    final MethodVisitor methodVisitor = new MethodVisitor(Opcodes.ASM5) {
       @Override
-      public void visitMethodInsn(final int opcode, final String owner, final String name, final String desc) {
+      public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
         final Type returnType = Type.getReturnType(desc);
         if (AsmUtil.isPrimitiveOrArrayOfPrimitives(returnType.getDescriptor()) || "<init>".equals(name)) {
           return;
@@ -69,7 +68,7 @@ public class MethodsUsageIndexer extends ClassFileIndexer<Integer, TObjectIntHas
         }
       }
     };
-    inputData.accept(new ClassVisitor(Opcodes.ASM4) {
+    inputData.accept(new ClassVisitor(Opcodes.ASM5) {
       @Override
       public MethodVisitor visitMethod(final int access,
                                        final String name,
diff --git a/jps/jps-builders/src/org/jetbrains/jps/cmdline/BuildSession.java b/jps/jps-builders/src/org/jetbrains/jps/cmdline/BuildSession.java
index a22c5f25b8d4..95279d5df6d2 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/cmdline/BuildSession.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/cmdline/BuildSession.java
@@ -141,6 +141,11 @@ final class BuildSession implements Runnable, CanceledStatus {
             CustomBuilderMessage builderMessage = (CustomBuilderMessage)buildMessage;
             response = CmdlineProtoUtil.createCustomBuilderMessage(builderMessage.getBuilderId(), builderMessage.getMessageType(), builderMessage.getMessageText());
           }
+          else if (buildMessage instanceof BuilderStatisticsMessage) {
+            BuilderStatisticsMessage message = (BuilderStatisticsMessage)buildMessage;
+            LOG.info("Build duration: '" + message.getBuilderName() + "' builder took " + message.getElapsedTimeMs() + " ms");
+            response = null;
+          }
           else if (!(buildMessage instanceof BuildingTargetProgressMessage)) {
             float done = -1.0f;
             if (buildMessage instanceof ProgressMessage) {
diff --git a/jps/jps-builders/src/org/jetbrains/jps/cmdline/ClasspathBootstrap.java b/jps/jps-builders/src/org/jetbrains/jps/cmdline/ClasspathBootstrap.java
index c89cb50397fb..3e5d2514c5a2 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/cmdline/ClasspathBootstrap.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/cmdline/ClasspathBootstrap.java
@@ -30,14 +30,14 @@ import io.netty.util.NetUtil;
 import jsr166e.extra.SequenceLock;
 import net.n3.nanoxml.IXMLBuilder;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.asm4.ClassVisitor;
-import org.jetbrains.asm4.ClassWriter;
 import org.jetbrains.jps.builders.java.JavaCompilingTool;
 import org.jetbrains.jps.builders.java.JavaSourceTransformer;
 import org.jetbrains.jps.javac.JavacServer;
 import org.jetbrains.jps.model.JpsModel;
 import org.jetbrains.jps.model.impl.JpsModelImpl;
 import org.jetbrains.jps.model.serialization.JpsProjectLoader;
+import org.jetbrains.org.objectweb.asm.ClassVisitor;
+import org.jetbrains.org.objectweb.asm.ClassWriter;
 
 import javax.tools.*;
 import java.io.File;
diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/BuildOperations.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/BuildOperations.java
index 2dd177501fdf..882ec81062be 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/BuildOperations.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/BuildOperations.java
@@ -21,9 +21,7 @@ import gnu.trove.TObjectIntHashMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jps.builders.*;
-import org.jetbrains.jps.builders.impl.BuildOutputConsumerImpl;
 import org.jetbrains.jps.builders.impl.BuildTargetChunk;
-import org.jetbrains.jps.builders.impl.DirtyFilesHolderBase;
 import org.jetbrains.jps.builders.logging.ProjectBuilderLogger;
 import org.jetbrains.jps.builders.storage.SourceToOutputMapping;
 import org.jetbrains.jps.cmdline.ProjectDescriptor;
@@ -87,24 +85,6 @@ public class BuildOperations {
     pd.fsState.markInitialScanPerformed(target);
   }
 
-  public static <R extends BuildRootDescriptor, T extends BuildTarget<R>>
-  void buildTarget(final T target, final CompileContext context, TargetBuilder<?, ?> builder) throws ProjectBuildException, IOException {
-
-    if (builder.getTargetTypes().contains(target.getTargetType())) {
-      DirtyFilesHolder<R, T> holder = new DirtyFilesHolderBase<R, T>(context) {
-        @Override
-        public void processDirtyFiles(@NotNull FileProcessor<R, T> processor) throws IOException {
-          context.getProjectDescriptor().fsState.processFilesToRecompile(context, target, processor);
-        }
-      };
-      //noinspection unchecked
-      BuildOutputConsumerImpl outputConsumer = new BuildOutputConsumerImpl(target, context);
-      ((TargetBuilder<R, T>)builder).build(target, holder, outputConsumer, context);
-      outputConsumer.fireFileGeneratedEvent();
-      context.checkCanceled();
-    }
-  }
-
   public static void markTargetsUpToDate(CompileContext context, BuildTargetChunk chunk) throws IOException {
     final ProjectDescriptor pd = context.getProjectDescriptor();
     final BuildFSState fsState = pd.fsState;
diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java
index a981fa0e910e..baa67a0216d8 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java
@@ -24,6 +24,7 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.SmartList;
 import com.intellij.util.concurrency.BoundedTaskExecutor;
 import com.intellij.util.containers.ConcurrentHashSet;
+import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.MultiMap;
 import com.intellij.util.io.MappingFailedException;
 import com.intellij.util.io.PersistentEnumerator;
@@ -37,6 +38,7 @@ import org.jetbrains.jps.api.CanceledStatus;
 import org.jetbrains.jps.api.GlobalOptions;
 import org.jetbrains.jps.api.RequestFuture;
 import org.jetbrains.jps.builders.*;
+import org.jetbrains.jps.builders.impl.BuildOutputConsumerImpl;
 import org.jetbrains.jps.builders.impl.BuildTargetChunk;
 import org.jetbrains.jps.builders.impl.DirtyFilesHolderBase;
 import org.jetbrains.jps.builders.java.JavaBuilderUtil;
@@ -70,6 +72,7 @@ import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.*;
 import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
 
 /**
@@ -113,6 +116,7 @@ public class IncProjectBuilder {
   private final float myTotalTargetsWork;
   private final int myTotalModuleLevelBuilderCount;
   private final List<Future> myAsyncTasks = Collections.synchronizedList(new ArrayList<Future>());
+  private final ConcurrentMap<Builder, AtomicLong> myElapsedTimeNanosByBuilder = ContainerUtil.newConcurrentMap();
 
   public IncProjectBuilder(ProjectDescriptor pd, BuilderRegistry builderRegistry, Map<String, String> builderParams, CanceledStatus cs,
                            @Nullable Callbacks.ConstantAffectionResolver constantSearch, final boolean isTestMode) {
@@ -356,6 +360,7 @@ public class IncProjectBuilder {
       context.processMessage(new ProgressMessage("Running 'after' tasks"));
       runTasks(context, myBuilderRegistry.getAfterTasks());
       TimingLog.LOG.debug("'after' tasks finished");
+      sendElapsedTimeMessages(context);
     }
     finally {
       for (TargetBuilder builder : myBuilderRegistry.getTargetBuilders()) {
@@ -369,6 +374,12 @@ public class IncProjectBuilder {
 
   }
 
+  private void sendElapsedTimeMessages(CompileContext context) {
+    for (Map.Entry<Builder, AtomicLong> entry : myElapsedTimeNanosByBuilder.entrySet()) {
+      context.processMessage(new BuilderStatisticsMessage(entry.getKey().getPresentableName(), entry.getValue().get()/1000000));
+    }
+  }
+
   private void startTempDirectoryCleanupTask() {
     final File systemRoot = Utils.getSystemRoot();
     final String tempPath = System.getProperty("java.io.tmpdir", null);
@@ -822,12 +833,32 @@ public class IncProjectBuilder {
     
     final List<TargetBuilder<?, ?>> builders = BuilderRegistry.getInstance().getTargetBuilders();
     for (TargetBuilder<?, ?> builder : builders) {
-      BuildOperations.buildTarget(target, context, builder);
+      buildTarget(target, context, builder);
       updateDoneFraction(context, 1.0f / builders.size());
     }
     return true;
   }
 
+  private <R extends BuildRootDescriptor, T extends BuildTarget<R>>
+  void buildTarget(final T target, final CompileContext context, TargetBuilder<?, ?> builder) throws ProjectBuildException, IOException {
+
+    if (builder.getTargetTypes().contains(target.getTargetType())) {
+      DirtyFilesHolder<R, T> holder = new DirtyFilesHolderBase<R, T>(context) {
+        @Override
+        public void processDirtyFiles(@NotNull FileProcessor<R, T> processor) throws IOException {
+          context.getProjectDescriptor().fsState.processFilesToRecompile(context, target, processor);
+        }
+      };
+      //noinspection unchecked
+      BuildOutputConsumerImpl outputConsumer = new BuildOutputConsumerImpl(target, context);
+      long start = System.nanoTime();
+      ((TargetBuilder<R, T>)builder).build(target, holder, outputConsumer, context);
+      incBuilderElapsedTime(builder, System.nanoTime() - start);
+      outputConsumer.fireFileGeneratedEvent();
+      context.checkCanceled();
+    }
+  }
+
   private static <T extends BuildRootDescriptor>
   void cleanOldOutputs(final CompileContext context, final BuildTarget<T> target) throws ProjectBuildException, IOException {
     if (!context.getScope().isBuildForced(target)) {
@@ -1105,7 +1136,9 @@ public class IncProjectBuilder {
 
           for (ModuleLevelBuilder builder : builders) {
             processDeletedPaths(context, chunk.getTargets());
+            long start = System.nanoTime();
             final ModuleLevelBuilder.ExitCode buildResult = builder.build(context, chunk, dirtyFilesHolder, outputConsumer);
+            incBuilderElapsedTime(builder, System.nanoTime() - start);
 
             doneSomething |= (buildResult != ModuleLevelBuilder.ExitCode.NOTHING_DONE);
 
@@ -1169,6 +1202,13 @@ public class IncProjectBuilder {
     return doneSomething;
   }
 
+  private void incBuilderElapsedTime(Builder builder, long timeNanos) {
+    if (!myElapsedTimeNanosByBuilder.containsKey(builder)) {
+      myElapsedTimeNanosByBuilder.putIfAbsent(builder, new AtomicLong());
+    }
+    myElapsedTimeNanosByBuilder.get(builder).addAndGet(timeNanos);
+  }
+
   private static void saveInstrumentedClasses(ChunkBuildOutputConsumerImpl outputConsumer) throws IOException {
     for (CompiledClass compiledClass : outputConsumer.getCompiledClasses().values()) {
       if (compiledClass.isDirty()) {
diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/BaseInstrumentingBuilder.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/BaseInstrumentingBuilder.java
index c03ebcb800ec..69ba370c2515 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/BaseInstrumentingBuilder.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/BaseInstrumentingBuilder.java
@@ -20,8 +20,6 @@ import com.intellij.compiler.instrumentation.InstrumenterClassWriter;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.Key;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.asm4.ClassReader;
-import org.jetbrains.asm4.ClassWriter;
 import org.jetbrains.jps.ModuleChunk;
 import org.jetbrains.jps.incremental.BinaryContent;
 import org.jetbrains.jps.incremental.BuilderCategory;
@@ -29,6 +27,8 @@ import org.jetbrains.jps.incremental.CompileContext;
 import org.jetbrains.jps.incremental.CompiledClass;
 import org.jetbrains.jps.incremental.messages.BuildMessage;
 import org.jetbrains.jps.incremental.messages.CompilerMessage;
+import org.jetbrains.org.objectweb.asm.ClassReader;
+import org.jetbrains.org.objectweb.asm.ClassWriter;
 
 /**
  * @author Eugene Zhuravlev
diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/ClassProcessingBuilder.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/ClassProcessingBuilder.java
index af1c974b84a2..551c3ce2f308 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/ClassProcessingBuilder.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/ClassProcessingBuilder.java
@@ -19,16 +19,16 @@ import com.intellij.compiler.instrumentation.InstrumentationClassFinder;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.text.StringUtil;
-import org.jetbrains.asm4.ClassReader;
-import org.jetbrains.asm4.ClassVisitor;
-import org.jetbrains.asm4.ClassWriter;
-import org.jetbrains.asm4.Opcodes;
 import org.jetbrains.jps.ModuleChunk;
 import org.jetbrains.jps.ProjectPaths;
 import org.jetbrains.jps.builders.DirtyFilesHolder;
 import org.jetbrains.jps.builders.java.JavaSourceRootDescriptor;
 import org.jetbrains.jps.incremental.*;
 import org.jetbrains.jps.incremental.messages.ProgressMessage;
+import org.jetbrains.org.objectweb.asm.ClassReader;
+import org.jetbrains.org.objectweb.asm.ClassVisitor;
+import org.jetbrains.org.objectweb.asm.ClassWriter;
+import org.jetbrains.org.objectweb.asm.Opcodes;
 
 import java.io.ByteArrayInputStream;
 import java.io.File;
@@ -140,7 +140,7 @@ public abstract class ClassProcessingBuilder extends ModuleLevelBuilder {
 
   public static int getClassFileVersion(ClassReader reader) {
     final Ref<Integer> result = new Ref<Integer>(0);
-    reader.accept(new ClassVisitor(Opcodes.ASM4) {
+    reader.accept(new ClassVisitor(Opcodes.ASM5) {
       public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
         result.set(version);
       }
diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/NotNullInstrumentingBuilder.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/NotNullInstrumentingBuilder.java
index f23b122aa29a..f46b6a54414e 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/NotNullInstrumentingBuilder.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/NotNullInstrumentingBuilder.java
@@ -19,9 +19,6 @@ import com.intellij.compiler.instrumentation.InstrumentationClassFinder;
 import com.intellij.compiler.notNullVerification.NotNullVerifyingInstrumenter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.asm4.ClassReader;
-import org.jetbrains.asm4.ClassWriter;
-import org.jetbrains.asm4.Opcodes;
 import org.jetbrains.jps.ModuleChunk;
 import org.jetbrains.jps.cmdline.ProjectDescriptor;
 import org.jetbrains.jps.incremental.BinaryContent;
@@ -30,6 +27,9 @@ import org.jetbrains.jps.incremental.CompiledClass;
 import org.jetbrains.jps.incremental.messages.BuildMessage;
 import org.jetbrains.jps.incremental.messages.CompilerMessage;
 import org.jetbrains.jps.model.java.JpsJavaExtensionService;
+import org.jetbrains.org.objectweb.asm.ClassReader;
+import org.jetbrains.org.objectweb.asm.ClassWriter;
+import org.jetbrains.org.objectweb.asm.Opcodes;
 
 import java.io.File;
 
diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/java/OutputFilesSink.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/java/OutputFilesSink.java
index e481a0265ad4..19bd9f142082 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/java/OutputFilesSink.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/java/OutputFilesSink.java
@@ -19,7 +19,6 @@ import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.io.FileUtil;
 import gnu.trove.THashSet;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.asm4.ClassReader;
 import org.jetbrains.jps.builders.java.JavaSourceRootDescriptor;
 import org.jetbrains.jps.builders.java.dependencyView.Callbacks;
 import org.jetbrains.jps.incremental.BinaryContent;
@@ -31,8 +30,9 @@ import org.jetbrains.jps.incremental.messages.CompilerMessage;
 import org.jetbrains.jps.incremental.messages.ProgressMessage;
 import org.jetbrains.jps.javac.OutputFileConsumer;
 import org.jetbrains.jps.javac.OutputFileObject;
+import org.jetbrains.org.objectweb.asm.ClassReader;
 
-import javax.tools.JavaFileObject;
+import javax.tools.*;
 import java.io.File;
 import java.io.IOException;
 import java.util.Collections;
diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/messages/BuilderStatisticsMessage.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/messages/BuilderStatisticsMessage.java
new file mode 100644
index 000000000000..f58546f64cec
--- /dev/null
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/messages/BuilderStatisticsMessage.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2000-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jetbrains.jps.incremental.messages;
+
+/**
+ * @author nik
+ */
+public class BuilderStatisticsMessage extends BuildMessage {
+  private final String myBuilderName;
+  private final long myElapsedTimeMs;
+
+  public BuilderStatisticsMessage(String builderName, long elapsedTimeMs) {
+    super(builderName + " elapsed " + elapsedTimeMs + "ms", Kind.INFO);
+    myBuilderName = builderName;
+    myElapsedTimeMs = elapsedTimeMs;
+  }
+
+  public String getBuilderName() {
+    return myBuilderName;
+  }
+
+  public long getElapsedTimeMs() {
+    return myElapsedTimeMs;
+  }
+}
diff --git a/jps/model-api/src/org/jetbrains/jps/model/JpsProject.java b/jps/model-api/src/org/jetbrains/jps/model/JpsProject.java
index 0b2e90533b24..35834335332d 100644
--- a/jps/model-api/src/org/jetbrains/jps/model/JpsProject.java
+++ b/jps/model-api/src/org/jetbrains/jps/model/JpsProject.java
@@ -23,6 +23,7 @@ import org.jetbrains.jps.model.module.JpsModule;
 import org.jetbrains.jps.model.module.JpsModuleType;
 import org.jetbrains.jps.model.module.JpsSdkReferencesTable;
 import org.jetbrains.jps.model.module.JpsTypedModule;
+import org.jetbrains.jps.model.runConfiguration.JpsRunConfiguration;
 import org.jetbrains.jps.model.runConfiguration.JpsRunConfigurationType;
 import org.jetbrains.jps.model.runConfiguration.JpsTypedRunConfiguration;
 
@@ -61,6 +62,9 @@ public interface JpsProject extends JpsCompositeElement, JpsReferenceableElement
   Iterable<JpsTypedRunConfiguration<P>> getRunConfigurations(JpsRunConfigurationType<P> type);
 
   @NotNull
+  List<JpsRunConfiguration> getRunConfigurations();
+
+  @NotNull
   <P extends JpsElement>
   JpsTypedRunConfiguration<P> addRunConfiguration(@NotNull String name, @NotNull JpsRunConfigurationType<P> type, @NotNull P properties);
 
diff --git a/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsProjectImpl.java b/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsProjectImpl.java
index e210fc5836cd..56d2b985bf75 100644
--- a/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsProjectImpl.java
+++ b/jps/model-impl/src/org/jetbrains/jps/model/impl/JpsProjectImpl.java
@@ -134,6 +134,12 @@ public class JpsProjectImpl extends JpsRootElementBase<JpsProjectImpl> implement
 
   @NotNull
   @Override
+  public List<JpsRunConfiguration> getRunConfigurations() {
+    return getRunConfigurationsCollection().getElements();
+  }
+
+  @NotNull
+  @Override
   public <P extends JpsElement> JpsTypedRunConfiguration<P> addRunConfiguration(@NotNull String name,
                                                                                 @NotNull JpsRunConfigurationType<P> type,
                                                                                 @NotNull P properties) {
diff --git a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsProjectLoader.java b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsProjectLoader.java
index 3b5a5e4a707e..81b0c8298813 100644
--- a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsProjectLoader.java
+++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsProjectLoader.java
@@ -134,7 +134,7 @@ public class JpsProjectLoader extends JpsLoaderBase {
     artifactsTimingLog.run();
 
     if (hasRunConfigurationSerializers()) {
-      Runnable runConfTimingLog = TimingLog.startActivity("loading artifacts");
+      Runnable runConfTimingLog = TimingLog.startActivity("loading run configurations");
       for (File configurationFile : listXmlFiles(new File(dir, "runConfigurations"))) {
         JpsRunConfigurationSerializer.loadRunConfigurations(myProject, loadRootElement(configurationFile));
       }
diff --git a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/runConfigurations/JpsRunConfigurationSerializer.java b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/runConfigurations/JpsRunConfigurationSerializer.java
index 6e619dc4c88c..b20ddf0ff9ae 100644
--- a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/runConfigurations/JpsRunConfigurationSerializer.java
+++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/runConfigurations/JpsRunConfigurationSerializer.java
@@ -21,6 +21,7 @@ import org.jdom.Element;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jps.model.JpsElement;
+import org.jetbrains.jps.model.JpsElementFactory;
 import org.jetbrains.jps.model.JpsProject;
 import org.jetbrains.jps.model.serialization.JpsModelSerializerExtension;
 
@@ -45,17 +46,21 @@ public class JpsRunConfigurationSerializer {
 
       String typeId = configurationTag.getAttributeValue("type");
       JpsRunConfigurationPropertiesSerializer<?> serializer = serializers.get(typeId);
+      String name = configurationTag.getAttributeValue("name");
       if (serializer != null) {
-        loadRunConfiguration(configurationTag, serializer, project);
+        loadRunConfiguration(name, configurationTag, serializer, project);
+      }
+      else {
+        project.addRunConfiguration(name, new JpsUnknownRunConfigurationType(typeId), JpsElementFactory.getInstance().createDummyElement());
       }
     }
   }
 
-  private static <P extends JpsElement> void loadRunConfiguration(Element configurationTag,
+  private static <P extends JpsElement> void loadRunConfiguration(final String name, Element configurationTag,
                                                                   JpsRunConfigurationPropertiesSerializer<P> serializer,
                                                                   JpsProject project) {
     P properties = serializer.loadProperties(configurationTag);
-    project.addRunConfiguration(configurationTag.getAttributeValue("name"), serializer.getType(), properties);
+    project.addRunConfiguration(name, serializer.getType(), properties);
 
   }
 }
diff --git a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/runConfigurations/JpsUnknownRunConfigurationType.java b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/runConfigurations/JpsUnknownRunConfigurationType.java
new file mode 100644
index 000000000000..ea666571b3f9
--- /dev/null
+++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/runConfigurations/JpsUnknownRunConfigurationType.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2000-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jetbrains.jps.model.serialization.runConfigurations;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsDummyElement;
+import org.jetbrains.jps.model.ex.JpsElementTypeWithDummyProperties;
+import org.jetbrains.jps.model.runConfiguration.JpsRunConfigurationType;
+
+/**
+ * @author nik
+ */
+public class JpsUnknownRunConfigurationType extends JpsElementTypeWithDummyProperties implements JpsRunConfigurationType<JpsDummyElement> {
+  private final String myTypeId;
+
+  public JpsUnknownRunConfigurationType(@NotNull String typeId) {
+    myTypeId = typeId;
+  }
+
+  @NotNull
+  public String getTypeId() {
+    return myTypeId;
+  }
+}
diff --git a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsRunConfigurationsSerializationTest.java b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsRunConfigurationsSerializationTest.java
index 44cc637ab2f4..dc260e1f6551 100644
--- a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsRunConfigurationsSerializationTest.java
+++ b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsRunConfigurationsSerializationTest.java
@@ -16,9 +16,13 @@
 package org.jetbrains.jps.model.serialization;
 
 import com.intellij.util.containers.ContainerUtil;
+import junit.framework.AssertionFailedError;
 import org.jetbrains.jps.model.java.runConfiguration.JpsApplicationRunConfigurationProperties;
 import org.jetbrains.jps.model.java.runConfiguration.JpsApplicationRunConfigurationType;
+import org.jetbrains.jps.model.runConfiguration.JpsRunConfiguration;
+import org.jetbrains.jps.model.runConfiguration.JpsRunConfigurationType;
 import org.jetbrains.jps.model.runConfiguration.JpsTypedRunConfiguration;
+import org.jetbrains.jps.model.serialization.runConfigurations.JpsUnknownRunConfigurationType;
 
 import java.util.List;
 
@@ -47,5 +51,19 @@ public class JpsRunConfigurationsSerializationTest extends JpsSerializationTestC
     JpsTypedRunConfiguration<JpsApplicationRunConfigurationProperties> main = configurations.get(1);
     assertEquals("Main", main.getName());
     assertEquals("xxx.Main", main.getProperties().getMainClass());
+
+    List<JpsRunConfiguration> all = myProject.getRunConfigurations();
+    JpsRunConfiguration junit = findByName(all, "test");
+    JpsRunConfigurationType type = ((JpsTypedRunConfiguration)junit).getType();
+    assertEquals("JUnit", assertInstanceOf(type, JpsUnknownRunConfigurationType.class).getTypeId());
+  }
+
+  private static JpsRunConfiguration findByName(List<JpsRunConfiguration> configurations, String name) {
+    for (JpsRunConfiguration configuration : configurations) {
+      if (configuration.getName().equals(name)) {
+        return configuration;
+      }
+    }
+    throw new AssertionFailedError("'" + name + "' run configuration not found");
   }
 }
diff --git a/jps/standalone-builder/src/org/jetbrains/jps/gant/JpsGantProjectBuilder.java b/jps/standalone-builder/src/org/jetbrains/jps/gant/JpsGantProjectBuilder.java
index 6f7d41b2a080..e4d446f808dd 100644
--- a/jps/standalone-builder/src/org/jetbrains/jps/gant/JpsGantProjectBuilder.java
+++ b/jps/standalone-builder/src/org/jetbrains/jps/gant/JpsGantProjectBuilder.java
@@ -31,6 +31,7 @@ import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType;
 import org.jetbrains.jps.cmdline.JpsModelLoader;
 import org.jetbrains.jps.incremental.MessageHandler;
 import org.jetbrains.jps.incremental.messages.BuildMessage;
+import org.jetbrains.jps.incremental.messages.BuilderStatisticsMessage;
 import org.jetbrains.jps.incremental.messages.BuildingTargetProgressMessage;
 import org.jetbrains.jps.incremental.messages.CompilerMessage;
 import org.jetbrains.jps.model.JpsModel;
@@ -295,7 +296,12 @@ public class JpsGantProjectBuilder {
           warning(text);
           break;
         case INFO:
-          if (!text.isEmpty()) {
+          if (msg instanceof BuilderStatisticsMessage) {
+            BuilderStatisticsMessage message = (BuilderStatisticsMessage)msg;
+            myBuildInfoPrinter.printStatisticsMessage(JpsGantProjectBuilder.this, "Compilation time '" + message.getBuilderName() + "', ms",
+                                                      String.valueOf(message.getElapsedTimeMs()));
+          }
+          else if (!text.isEmpty()) {
             info(text);
           }
           break;