diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AlternativeSignatureParsing.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AlternativeSignatureData.java
similarity index 88%
rename from compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AlternativeSignatureParsing.java
rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AlternativeSignatureData.java
index f1fd1691286..3ed3f13a398 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AlternativeSignatureParsing.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AlternativeSignatureData.java
@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
+import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiErrorElement;
@@ -42,7 +43,72 @@ import java.util.List;
  * @author Evgeny Gerashchenko
  * @since 6/5/12
  */
-class AlternativeSignatureParsing {
+class AlternativeSignatureData {
+    private boolean none;
+    private String error;
+    private JavaDescriptorResolver.ValueParameterDescriptors altValueParameters;
+    private JetType altReturnType;
+    private List<TypeParameterDescriptor> altTypeParameters;
+
+    AlternativeSignatureData(
+            @NotNull PsiMethodWrapper method,
+            @NotNull JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors,
+            @NotNull JetType returnType,
+            @NotNull List<TypeParameterDescriptor> methodTypeParameters){
+        String signature = method.getSignatureAnnotation().signature();
+        if (signature.isEmpty()) {
+            none = true;
+            return;
+        }
+
+        Project project = method.getPsiMethod().getProject();
+        JetNamedFunction altFunDeclaration = JetPsiFactory.createFunction(project, signature);
+        try {
+            checkForSyntaxErrors(method, altFunDeclaration);
+
+            altValueParameters = computeValueParameters(valueParameterDescriptors, altFunDeclaration);
+            altReturnType = computeReturnType(returnType,
+                                                      altFunDeclaration.getReturnTypeRef());
+            altTypeParameters = computeTypeParameters(methodTypeParameters, altFunDeclaration);
+        }
+        catch (AlternativeSignatureMismatchException e) {
+            error = e.getMessage();
+        }
+    }
+
+    public boolean isNone() {
+        return none;
+    }
+
+    @Nullable
+    public String getError() {
+        return error;
+    }
+
+    private void checkForErrors() {
+        if (none || error != null) {
+            throw new IllegalStateException("Trying to read result while there is none");
+        }
+    }
+
+    @NotNull
+    public JavaDescriptorResolver.ValueParameterDescriptors getValueParameters() {
+        checkForErrors();
+        return altValueParameters;
+    }
+
+    @NotNull
+    public JetType getReturnType() {
+        checkForErrors();
+        return altReturnType;
+    }
+
+    @NotNull
+    public List<TypeParameterDescriptor> getTypeParameters() {
+        checkForErrors();
+        return altTypeParameters;
+    }
+
     static JetType computeType(JetTypeElement alternativeTypeElement, final JetType autoType)
             throws AlternativeSignatureMismatchException {
         final Ref<AlternativeSignatureMismatchException> exception = new Ref<AlternativeSignatureMismatchException>();
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
index 5e285db6474..947ddf121df 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
@@ -1391,26 +1391,12 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         JetType returnType = makeReturnType(returnPsiType, method, methodTypeVariableResolver);
 
         // TODO consider better place for this check
-        String signature = method.getSignatureAnnotation().signature();
-        if (!signature.isEmpty()) {
-            try {
-                JetNamedFunction altFunDeclaration = JetPsiFactory.createFunction(project, signature);
-                AlternativeSignatureParsing.checkForSyntaxErrors(method, altFunDeclaration);
-
-                ValueParameterDescriptors altValueParameters = AlternativeSignatureParsing
-                        .computeValueParameters(valueParameterDescriptors, altFunDeclaration);
-                JetType altReturnType = AlternativeSignatureParsing.computeReturnType(returnType,
-                                                                                      altFunDeclaration.getReturnTypeRef());
-                List<TypeParameterDescriptor> altTypeParameters = AlternativeSignatureParsing
-                        .computeTypeParameters(methodTypeParameters, altFunDeclaration);
-                // if no exceptions were thrown, save alternative data
-                valueParameterDescriptors = altValueParameters;
-                returnType = altReturnType;
-                methodTypeParameters = altTypeParameters;
-            }
-            catch (AlternativeSignatureMismatchException e) {
-                scopeData.addAlternativeSignatureError(e.getMessage());
-            }
+        AlternativeSignatureData alternativeSignatureData =
+                new AlternativeSignatureData(method, valueParameterDescriptors, returnType, methodTypeParameters);
+        if (!alternativeSignatureData.isNone() && alternativeSignatureData.getError() == null) {
+            valueParameterDescriptors = alternativeSignatureData.getValueParameters();
+            returnType = alternativeSignatureData.getReturnType();
+            methodTypeParameters = alternativeSignatureData.getTypeParameters();
         }
 
         functionDescriptorImpl.initialize(