azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Changed some static methods of AlternativeSignatureData to non-static, got rid of some unnecessary method parameters.

Browse Source
This commit is contained in:
Evgeny Gerashchenko
2012-06-21 18:10:50 +04:00
parent 5ae461b5ac
commit 572f66a2a1
1 changed files with 26 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AlternativeSignatureData.java
+26 -26
View File
@@ -17,7 +17,6 @@
package org.jetbrains.jet.lang.resolve.java; package org.jetbrains.jet.lang.resolve.java;
import com.intellij.openapi.project.Project; import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Ref;
import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.PsiErrorElement; import com.intellij.psi.PsiErrorElement;
import com.intellij.psi.PsiSubstitutor; import com.intellij.psi.PsiSubstitutor;
@@ -44,8 +43,12 @@ import java.util.List;
* @since 6/5/12 * @since 6/5/12
*/ */
class AlternativeSignatureData { class AlternativeSignatureData {
private JetNamedFunction altFunDeclaration;
private PsiMethodWrapper method;
private boolean none; private boolean none;
private String error; private String error;
private JavaDescriptorResolver.ValueParameterDescriptors altValueParameters; private JavaDescriptorResolver.ValueParameterDescriptors altValueParameters;
private JetType altReturnType; private JetType altReturnType;
private List<TypeParameterDescriptor> altTypeParameters; private List<TypeParameterDescriptor> altTypeParameters;
@@ -54,22 +57,23 @@ class AlternativeSignatureData {
@NotNull PsiMethodWrapper method, @NotNull PsiMethodWrapper method,
@NotNull JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors, @NotNull JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors,
@NotNull JetType returnType, @NotNull JetType returnType,
@NotNull List<TypeParameterDescriptor> methodTypeParameters){ @NotNull List<TypeParameterDescriptor> methodTypeParameters) {
String signature = method.getSignatureAnnotation().signature(); String signature = method.getSignatureAnnotation().signature();
if (signature.isEmpty()) { if (signature.isEmpty()) {
none = true; none = true;
return; return;
} }
this.method = method;
Project project = method.getPsiMethod().getProject(); Project project = method.getPsiMethod().getProject();
JetNamedFunction altFunDeclaration = JetPsiFactory.createFunction(project, signature); altFunDeclaration = JetPsiFactory.createFunction(project, signature);
try {
checkForSyntaxErrors(method, altFunDeclaration);
altValueParameters = computeValueParameters(valueParameterDescriptors, altFunDeclaration); try {
altReturnType = computeReturnType(returnType, checkForSyntaxErrors();
altFunDeclaration.getReturnTypeRef());
altTypeParameters = computeTypeParameters(methodTypeParameters, altFunDeclaration); computeValueParameters(valueParameterDescriptors);
computeReturnType(returnType);
computeTypeParameters(methodTypeParameters);
} }
catch (AlternativeSignatureMismatchException e) { catch (AlternativeSignatureMismatchException e) {
error = e.getMessage(); error = e.getMessage();
@@ -204,8 +208,8 @@ class AlternativeSignatureData {
}, null); }, null);
} }
static JetType computeReturnType(@NotNull JetType autoType, @Nullable JetTypeReference altReturnTypeRef) { private void computeReturnType(@NotNull JetType autoType) {
JetType altReturnType; JetTypeReference altReturnTypeRef = altFunDeclaration.getReturnTypeRef();
if (altReturnTypeRef == null) { if (altReturnTypeRef == null) {
if (JetStandardClasses.isUnit(autoType)) { if (JetStandardClasses.isUnit(autoType)) {
altReturnType = autoType; altReturnType = autoType;
@@ -220,12 +224,9 @@ class AlternativeSignatureData {
altReturnType = computeType(altReturnTypeRef.getTypeElement(), altReturnType = computeType(altReturnTypeRef.getTypeElement(),
autoType); autoType);
} }
return altReturnType;
} }
static JavaDescriptorResolver.ValueParameterDescriptors computeValueParameters( private void computeValueParameters(JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors) {
JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors,
JetNamedFunction altFunDeclaration) {
List<ValueParameterDescriptor> parameterDescriptors = valueParameterDescriptors.descriptors; List<ValueParameterDescriptor> parameterDescriptors = valueParameterDescriptors.descriptors;
if (parameterDescriptors.size() != altFunDeclaration.getValueParameters().size()) { if (parameterDescriptors.size() != altFunDeclaration.getValueParameters().size()) {
@@ -266,20 +267,20 @@ class AlternativeSignatureData {
altReceiverType = computeType(altFunDeclaration.getReceiverTypeRef().getTypeElement(), altReceiverType = computeType(altFunDeclaration.getReceiverTypeRef().getTypeElement(),
valueParameterDescriptors.receiverType); valueParameterDescriptors.receiverType);
} }
return new JavaDescriptorResolver.ValueParameterDescriptors(altReceiverType, altParamDescriptors); altValueParameters = new JavaDescriptorResolver.ValueParameterDescriptors(altReceiverType, altParamDescriptors);
} }
static List<TypeParameterDescriptor> computeTypeParameters(List<TypeParameterDescriptor> typeParameterDescriptors, private void computeTypeParameters(List<TypeParameterDescriptor> typeParameters) {
JetNamedFunction altFunDeclaration) {
if (typeParameterDescriptors.size() != altFunDeclaration.getTypeParameters().size()) { if (typeParameters.size() != altFunDeclaration.getTypeParameters().size()) {
throw new AlternativeSignatureMismatchException( throw new AlternativeSignatureMismatchException(
String.format("Method signature has %d type parameters, but alternative signature has %d", String.format("Method signature has %d type parameters, but alternative signature has %d",
typeParameterDescriptors.size(), altFunDeclaration.getTypeParameters().size())); typeParameters.size(), altFunDeclaration.getTypeParameters().size()));
} }
List<TypeParameterDescriptor> altParamDescriptors = new ArrayList<TypeParameterDescriptor>(); altTypeParameters = new ArrayList<TypeParameterDescriptor>();
for (int i = 0, size = typeParameterDescriptors.size(); i < size; i++) { for (int i = 0, size = typeParameters.size(); i < size; i++) {
TypeParameterDescriptor pd = typeParameterDescriptors.get(i); TypeParameterDescriptor pd = typeParameters.get(i);
DeclarationDescriptor containingDeclaration = pd.getContainingDeclaration(); DeclarationDescriptor containingDeclaration = pd.getContainingDeclaration();
assert containingDeclaration != null; assert containingDeclaration != null;
TypeParameterDescriptorImpl altParamDescriptor = TypeParameterDescriptorImpl TypeParameterDescriptorImpl altParamDescriptor = TypeParameterDescriptorImpl
@@ -308,9 +309,8 @@ class AlternativeSignatureData {
} }
altParamDescriptor.setInitialized(); altParamDescriptor.setInitialized();
altParamDescriptors.add(altParamDescriptor); altTypeParameters.add(altParamDescriptor);
} }
return altParamDescriptors;
} }
@Nullable @Nullable
@@ -329,7 +329,7 @@ class AlternativeSignatureData {
return null; return null;
} }
static void checkForSyntaxErrors(PsiMethodWrapper method, JetNamedFunction altFunDeclaration) { private void checkForSyntaxErrors() {
List<PsiErrorElement> syntaxErrors = AnalyzingUtils.getSyntaxErrorRanges(altFunDeclaration); List<PsiErrorElement> syntaxErrors = AnalyzingUtils.getSyntaxErrorRanges(altFunDeclaration);
if (!syntaxErrors.isEmpty()) { if (!syntaxErrors.isEmpty()) {
String textSignature = String.format("%s(%s)", method.getName(), String textSignature = String.format("%s(%s)", method.getName(),