Converted AlternativeSignatureParsing static class into AlternativeSignatureData stateful class which contains result of all alternative signature parsing. This is needed to simplify JavaDescriptorResolver.

2012-06-21 17:44:25 +04:00
parent c427a3b7aa
commit 4141015472
2 changed files with 73 additions and 21 deletions
@@ -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>();
@@ -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(