From 9248cf9659256468eb7ffb2dc97550b49c7ab4ae Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Wed, 15 Feb 2012 00:02:03 +0400 Subject: [PATCH] Important JavaDescriptorResolver refactoring This patch implement own member filling with supertype scope. Before this patch JDR relied on Idea hierarchy resolver. This patch does two things: * copies FunctionDescriptors from supertype scopes * rewrites containingDeclaration similary to how it is done in previous patch Patch is incomplete, in particular properties are not yet initialized properly, code needs cleanup, however the most important part of refactoring is done, and tests pass. --- .../jetbrains/jet/codegen/CallableMethod.java | 2 +- .../resolve/java/JavaDescriptorResolver.java | 216 ++++++++++++------ .../java/JavaDescriptorResolverHelper.java | 49 ++-- .../resolve/java/JavaTypeTransformer.java | 2 +- .../jet/lang/resolve/java/NamedMembers.java | 6 +- .../resolve/java/PropertyAccessorData.java | 3 + .../lang/resolve/java/PsiClassWrapper.java | 24 +- .../lang/resolve/java/PsiMemberWrapper.java | 5 + .../calls/OverloadingConflictResolver.java | 6 +- .../jet/compiler/NamespaceComparator.java | 36 ++- testlib/test/regressions/kt1202.kt | 1 + 11 files changed, 246 insertions(+), 104 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java b/compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java index 414d8c456a6..34e6d8f4879 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java @@ -94,7 +94,7 @@ public class CallableMethod implements Callable { } void invoke(InstructionAdapter v) { - v.visitMethodInsn(getInvokeOpcode(), getOwner(), getSignature().getAsmMethod().getName(), getSignature().getAsmMethod().getDescriptor()); + v.visitMethodInsn(getInvokeOpcode(), owner, getSignature().getAsmMethod().getName(), getSignature().getAsmMethod().getDescriptor()); } public void requestGenerateCallee(Type objectType) { 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 683c922eab2..8e4b4de7fe6 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 @@ -33,6 +33,8 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.OverrideResolver; +import org.jetbrains.jet.lang.resolve.OverridingUtil; import org.jetbrains.jet.lang.resolve.java.alt.AltClassFinder; import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation; import org.jetbrains.jet.lang.types.*; @@ -81,7 +83,7 @@ public class JavaDescriptorResolver { JAVA, KOTLIN, } - + public static class TypeParameterDescriptorInitialization { @NotNull private final TypeParameterDescriptorOrigin origin; @@ -170,7 +172,7 @@ public class JavaDescriptorResolver { protected final Map namespaceDescriptorCacheByFqn = Maps.newHashMap(); protected final Map namespaceDescriptorCache = Maps.newHashMap(); - protected final Map methodDescriptorCache = Maps.newHashMap(); + protected final Map methodDescriptorCache = Maps.newHashMap(); protected final JavaPsiFacade javaFacade; protected final GlobalSearchScope javaSearchScope; protected final JavaSemanticServices semanticServices; @@ -394,11 +396,29 @@ public class JavaDescriptorResolver { } } + // TODO + //classData.classDescriptor.setClassObjectDescriptor(createClassObjectDescriptor(classData.classDescriptor)); + semanticServices.getTrace().record(BindingContext.CLASS, psiClass, classData.classDescriptor); return classData; } + /** + * TODO + * @see #createJavaNamespaceDescriptor(com.intellij.psi.PsiClass) + */ + @Nullable + private MutableClassDescriptorLite createClassObjectDescriptor(@NotNull ClassDescriptor containing, @NotNull PsiClass psiClass) { + MutableClassDescriptorLite classObjectDescriptor = new MutableClassDescriptorLite(containing, ClassKind.OBJECT); + classObjectDescriptor.setName(""); // TODO + classObjectDescriptor.setModality(Modality.FINAL); + classObjectDescriptor.setTypeParameterDescriptors(new ArrayList(0)); + classObjectDescriptor.createTypeConstructor(); + classObjectDescriptor.setScopeForMemberLookup(new JavaClassMembersScope(classObjectDescriptor, psiClass, semanticServices, true)); + return classObjectDescriptor; + } + private List createUninitializedClassTypeParameters(PsiClass psiClass, ResolverBinaryClassData classData, TypeVariableByNameResolver typeVariableByNameResolver) { JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass); classData.kotlin = jetClassAnnotation.isDefined(); @@ -767,6 +787,10 @@ public class JavaDescriptorResolver { return resolveNamespace(parentPackage); } + /** + * TODO + * @see #createClassObjectDescriptor(org.jetbrains.jet.lang.descriptors.ClassDescriptor, com.intellij.psi.PsiClass) + */ private ResolverNamespaceData createJavaNamespaceDescriptor(@NotNull final PsiClass psiClass) { ResolverNamespaceData namespaceData = new ResolverNamespaceData(); namespaceData.namespaceDescriptor = new JavaNamespaceDescriptor( @@ -791,30 +815,6 @@ public class JavaDescriptorResolver { } } - private ValueParameterDescriptors resolveParameterDescriptors(DeclarationDescriptor containingDeclaration, - List parameters, TypeVariableResolver typeVariableResolver) { - List result = new ArrayList(); - JetType receiverType = null; - int indexDelta = 0; - for (int i = 0, parametersLength = parameters.size(); i < parametersLength; i++) { - PsiParameterWrapper parameter = parameters.get(i); - JvmMethodParameterMeaning meaning = resolveParameterDescriptor(containingDeclaration, i + indexDelta, parameter, typeVariableResolver); - if (meaning.kind == JvmMethodParameterKind.TYPE_INFO) { - // TODO - --indexDelta; - } else if (meaning.kind == JvmMethodParameterKind.REGULAR) { - result.add(meaning.valueParameterDescriptor); - } else if (meaning.kind == JvmMethodParameterKind.RECEIVER) { - if (receiverType != null) { - throw new IllegalStateException("more then one receiver"); - } - --indexDelta; - receiverType = meaning.receiverType; - } - } - return new ValueParameterDescriptors(receiverType, result); - } - private enum JvmMethodParameterKind { REGULAR, RECEIVER, @@ -907,10 +907,17 @@ public class JavaDescriptorResolver { if (namedMembers == null) { return Collections.emptySet(); } + Set r = new HashSet(); resolveNamedGroupProperties(owner, scopeData, staticMembers, namedMembers, fieldName); - return namedMembers.propertyDescriptors; + r.addAll(namedMembers.propertyDescriptors); + + for (JetType supertype : getSupertypes(scopeData)) { + r.addAll(supertype.getMemberScope().getProperties(fieldName)); + } + + return r; } @NotNull @@ -931,6 +938,16 @@ public class JavaDescriptorResolver { resolveNamedGroupProperties(owner, scopeData, staticMembers, namedMembers, propertyName); descriptors.addAll(namedMembers.propertyDescriptors); } + + for (JetType supertype : getSupertypes(scopeData)) { + for (DeclarationDescriptor descriptor : supertype.getMemberScope().getAllDescriptors()) { + // TODO: ugly + if (descriptor instanceof VariableDescriptor) { + descriptors.add((VariableDescriptor) descriptor); + } + } + } + return descriptors; } @@ -1140,24 +1157,50 @@ public class JavaDescriptorResolver { namedMembers.propertyDescriptors = r; } - private void resolveNamedGroupFunctions(ClassOrNamespaceDescriptor owner, PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, NamedMembers namedMembers) { + private void resolveNamedGroupFunctions(ClassOrNamespaceDescriptor owner, PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, NamedMembers namedMembers, String methodName, ResolverScopeData scopeData) { if (namedMembers.functionDescriptors != null) { return; } + + final Set functions = new HashSet(); - if (namedMembers.methods == null) { - namedMembers.functionDescriptors = Collections.emptySet(); - return; - } - - Set functionDescriptors = new HashSet(namedMembers.methods.size()); + Set functionsFromCurrent = Sets.newHashSet(); for (PsiMethodWrapper method : namedMembers.methods) { - FunctionDescriptor function = resolveMethodToFunctionDescriptor(owner, psiClass, typeSubstitutorForGenericSuperclasses, method); + FunctionDescriptorImpl function = resolveMethodToFunctionDescriptor(owner, psiClass, + typeSubstitutorForGenericSuperclasses, + method); if (function != null) { - functionDescriptors.add(function); + functionsFromCurrent.add((NamedFunctionDescriptor) function); } } - namedMembers.functionDescriptors = functionDescriptors; + + if (owner instanceof ClassDescriptor) { + ClassDescriptor classDescriptor = (ClassDescriptor) owner; + + Set functionsFromSupertypes = getFunctionsFromSupertypes(scopeData, methodName); + + OverrideResolver.generateOverridesInFunctionGroup(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor, new OverrideResolver.DescriptorSink() { + @Override + public void addToScope(NamedFunctionDescriptor fakeOverride) { + functions.add(fakeOverride); + } + }); + + } + + functions.addAll(functionsFromCurrent); + + namedMembers.functionDescriptors = functions; + } + + private Set getFunctionsFromSupertypes(ResolverScopeData scopeData, String methodName) { + Set r = new HashSet(); + for (JetType supertype : getSupertypes(scopeData)) { + for (FunctionDescriptor function : supertype.getMemberScope().getFunctions(methodName)) { + r.add((NamedFunctionDescriptor) function); + } + } + return r; } private ResolverScopeData getResolverScopeData(@NotNull ClassOrNamespaceDescriptor owner, PsiClassWrapper psiClass) { @@ -1191,19 +1234,15 @@ public class JavaDescriptorResolver { Map namedMembersMap = resolverScopeData.namedMembersMap; NamedMembers namedMembers = namedMembersMap.get(methodName); - if (namedMembers == null || namedMembers.methods == null) { + if (namedMembers != null && namedMembers.methods != null) { + TypeSubstitutor typeSubstitutor = typeSubstitutorForGenericSupertypes(resolverScopeData); + + resolveNamedGroupFunctions(descriptor, psiClass, typeSubstitutor, namedMembers, methodName, resolverScopeData); + + return namedMembers.functionDescriptors; + } else { return Collections.emptySet(); } - - TypeSubstitutor typeSubstitutor; - if (descriptor instanceof ClassDescriptor && !staticMembers) { - typeSubstitutor = createSubstitutorForGenericSupertypes((ClassDescriptor) descriptor); - } else { - typeSubstitutor = TypeSubstitutor.EMPTY; - } - resolveNamedGroupFunctions(descriptor, psiClass, typeSubstitutor, namedMembers); - - return namedMembers.functionDescriptors; } private TypeSubstitutor createSubstitutorForGenericSupertypes(@Nullable ClassDescriptor classDescriptor) { @@ -1274,17 +1313,42 @@ public class JavaDescriptorResolver { return equal(p1.getOwner(), p2.getOwner()); } + private ValueParameterDescriptors resolveParameterDescriptors(DeclarationDescriptor containingDeclaration, + List parameters, TypeVariableResolver typeVariableResolver) { + List result = new ArrayList(); + JetType receiverType = null; + int indexDelta = 0; + for (int i = 0, parametersLength = parameters.size(); i < parametersLength; i++) { + PsiParameterWrapper parameter = parameters.get(i); + JvmMethodParameterMeaning meaning = resolveParameterDescriptor(containingDeclaration, i + indexDelta, parameter, typeVariableResolver); + if (meaning.kind == JvmMethodParameterKind.TYPE_INFO) { + // TODO + --indexDelta; + } else if (meaning.kind == JvmMethodParameterKind.REGULAR) { + result.add(meaning.valueParameterDescriptor); + } else if (meaning.kind == JvmMethodParameterKind.RECEIVER) { + if (receiverType != null) { + throw new IllegalStateException("more then one receiver"); + } + --indexDelta; + receiverType = meaning.receiverType; + } + } + return new ValueParameterDescriptors(receiverType, result); + } + @Nullable - private FunctionDescriptor resolveMethodToFunctionDescriptor(ClassOrNamespaceDescriptor owner, final PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, final PsiMethodWrapper method) { - + private FunctionDescriptorImpl resolveMethodToFunctionDescriptor(ClassOrNamespaceDescriptor owner, final PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, final PsiMethodWrapper method) { + PsiType returnType = method.getReturnType(); if (returnType == null) { return null; } - FunctionDescriptor functionDescriptor = methodDescriptorCache.get(method.getPsiMethod()); + FunctionDescriptorImpl functionDescriptor = methodDescriptorCache.get(method.getPsiMethod()); if (functionDescriptor != null) { if (method.getPsiMethod().getContainingClass() != psiClass) { - functionDescriptor = functionDescriptor.substitute(typeSubstitutorForGenericSuperclasses); + //functionDescriptor = functionDescriptor.substitute(typeSubstitutorForGenericSuperclasses); + throw new IllegalStateException(); } return functionDescriptor; } @@ -1434,36 +1498,52 @@ public class JavaDescriptorResolver { semanticServices.getTrace().record(BindingContext.FUNCTION, method.getPsiMethod(), functionDescriptorImpl); FunctionDescriptor substitutedFunctionDescriptor = functionDescriptorImpl; if (method.getPsiMethod().getContainingClass() != psiClass) { - substitutedFunctionDescriptor = functionDescriptorImpl.substitute(typeSubstitutorForGenericSuperclasses); + //substitutedFunctionDescriptor = functionDescriptorImpl.substitute(typeSubstitutorForGenericSuperclasses); + throw new IllegalStateException(); } - return substitutedFunctionDescriptor; + return (FunctionDescriptorImpl) substitutedFunctionDescriptor; } - + public List resolveMethods(PsiClass psiClass, ClassOrNamespaceDescriptor containingDeclaration) { ResolverScopeData scopeData = getResolverScopeData(containingDeclaration, new PsiClassWrapper(psiClass)); - TypeSubstitutor substitutorForGenericSupertypes; - if (scopeData instanceof ResolverBinaryClassData) { - substitutorForGenericSupertypes = createSubstitutorForGenericSupertypes(((ResolverBinaryClassData) scopeData).classDescriptor); - } else { - substitutorForGenericSupertypes = TypeSubstitutor.EMPTY; - } + TypeSubstitutor substitutorForGenericSupertypes = typeSubstitutorForGenericSupertypes(scopeData); List functions = new ArrayList(); - - for (NamedMembers namedMembers : scopeData.namedMembersMap.values()) { - resolveNamedGroupFunctions(containingDeclaration, psiClass, substitutorForGenericSupertypes, namedMembers); + + for (Map.Entry entry : scopeData.namedMembersMap.entrySet()) { + String methodName = entry.getKey(); + NamedMembers namedMembers = entry.getValue(); + resolveNamedGroupFunctions(containingDeclaration, psiClass, substitutorForGenericSupertypes, namedMembers, methodName, scopeData); functions.addAll(namedMembers.functionDescriptors); } return functions; } + private Collection getSupertypes(ResolverScopeData scope) { + if (scope instanceof ResolverBinaryClassData) { + return ((ResolverBinaryClassData) scope).classDescriptor.getSupertypes(); + } else if (scope instanceof ResolverNamespaceData) { + return Collections.emptyList(); + } else { + throw new IllegalStateException(); + } + } + + private TypeSubstitutor typeSubstitutorForGenericSupertypes(ResolverScopeData scopeData) { + if (scopeData instanceof ResolverClassData) { + return createSubstitutorForGenericSupertypes(((ResolverClassData) scopeData).getClassDescriptor()); + } else { + return TypeSubstitutor.EMPTY; + } + } + private List resolveMethodTypeParameters( @NotNull PsiMethodWrapper method, @NotNull DeclarationDescriptor functionDescriptor, - @NotNull TypeVariableResolver classTypeVariableResolver - ) { + @NotNull TypeVariableResolver classTypeVariableResolver) { + List typeParameters; if (method.getJetMethod().typeParameters().length() > 0) { typeParameters = resolveMethodTypeParametersFromJetSignature( @@ -1477,13 +1557,13 @@ public class JavaDescriptorResolver { } /** - * @see #resolveClassTypeParametersFromJetSignature(String, com.intellij.psi.PsiClass, MutableClassDescriptorLite) + * @see #resolveClassTypeParametersFromJetSignature(String, com.intellij.psi.PsiClass, org.jetbrains.jet.lang.descriptors.ClassDescriptor, TypeVariableResolver) */ private List resolveMethodTypeParametersFromJetSignature(String jetSignature, final PsiMethod method, final DeclarationDescriptor functionDescriptor, final TypeVariableByNameResolver classTypeVariableByNameResolver) { final List r = new ArrayList(); - + class MyTypeVariableByNameResolver implements TypeVariableByNameResolver { @NotNull diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolverHelper.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolverHelper.java index 8fca96e6029..5312df706de 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolverHelper.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolverHelper.java @@ -17,10 +17,14 @@ package org.jetbrains.jet.lang.resolve.java; import com.intellij.openapi.util.text.StringUtil; -import com.intellij.psi.HierarchicalMethodSignature; +import com.intellij.psi.PsiField; +import com.intellij.psi.PsiMember; +import com.intellij.psi.PsiMethod; import org.jetbrains.annotations.NotNull; +import java.util.ArrayList; import java.util.HashMap; +import java.util.List; import java.util.Map; /** @@ -57,14 +61,28 @@ class JavaDescriptorResolverHelper { return r; } + private boolean includeMember(PsiMemberWrapper member) { + if (member.isStatic() != staticMembers) { + return false; + } + + if (!staticMembers && member.getPsiMember().getContainingClass() != psiClass.getPsiClass()) { + return false; + } + + if (member.isPrivate()) { + return false; + } + + return true; + } + private void processFields() { if (!kotlin) { - for (PsiFieldWrapper field : psiClass.getFields()) { - if (field.isStatic() != staticMembers) { - continue; - } - - if (field.isPrivate()) { + for (PsiField field0 : psiClass.getPsiClass().getFields()) { + PsiFieldWrapper field = new PsiFieldWrapper(field0); + + if (!includeMember(field)) { continue; } @@ -77,15 +95,16 @@ class JavaDescriptorResolverHelper { } private void processMethods() { - for (HierarchicalMethodSignature method0 : psiClass.getPsiClass().getVisibleSignatures()) { + + for (PsiMethod method : psiClass.getPsiClass().getAllMethods()) { + getNamedMembers(method.getName()); + } + + + for (PsiMethod method0 : psiClass.getPsiClass().getMethods()) { + PsiMethodWrapper method = new PsiMethodWrapper(method0); - PsiMethodWrapper method = new PsiMethodWrapper(method0.getMethod()); - - if (method.isStatic() != staticMembers) { - continue; - } - - if (method.isPrivate()) { + if (!includeMember(method)) { continue; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java index ca50d5462ef..0f1ac47a803 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java @@ -139,7 +139,7 @@ public class JavaTypeTransformer { for (int i = 0; i < parameters.size(); i++) { PsiType psiArgument = psiArguments[i]; TypeParameterDescriptor typeParameterDescriptor = parameters.get(i); - + TypeVariableResolver typeVariableByPsiResolver2 = new TypeVariableResolver() { @NotNull @Override diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/NamedMembers.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/NamedMembers.java index 23914fc429f..c52862bae8a 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/NamedMembers.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/NamedMembers.java @@ -30,7 +30,7 @@ import java.util.Set; */ class NamedMembers { String name; - List methods; + List methods = new ArrayList(0); @Nullable PsiFieldWrapper field; @@ -41,12 +41,10 @@ class NamedMembers { private PsiClass nestedClasses; Set propertyDescriptors; + /** Including from supertypes */ Set functionDescriptors; void addMethod(PsiMethodWrapper method) { - if (methods == null) { - methods = new ArrayList(); - } methods.add(method); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PropertyAccessorData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PropertyAccessorData.java index 8be7adfe85f..d2cdb52024b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PropertyAccessorData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PropertyAccessorData.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.lang.resolve.java; +import com.intellij.psi.HierarchicalMethodSignature; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -26,6 +27,8 @@ class PropertyAccessorData { @NotNull private final PsiMemberWrapper member; + + // for methods private final boolean getter; @NotNull diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassWrapper.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassWrapper.java index 87c60326709..eb8ad1fb6c7 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassWrapper.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassWrapper.java @@ -37,32 +37,36 @@ public class PsiClassWrapper { this.psiClass = psiClass; } - private List methods; + private List ownMethods; @NotNull - public List getMethods() { - if (methods == null) { + public List getOwnMethods() { + if (ownMethods == null) { PsiMethod[] psiMethods = psiClass.getMethods(); List methods = new ArrayList(psiMethods.length); for (PsiMethod psiMethod : psiMethods) { + if (psiMethod.getContainingClass() != psiClass) + continue; methods.add(new PsiMethodWrapper(psiMethod)); } - this.methods = methods; + this.ownMethods = methods; } - return methods; + return ownMethods; } - private List fields; + private List ownFields; @NotNull - public List getFields() { - if (fields == null) { + public List getOwnFields() { + if (ownFields == null) { PsiField[] psiFields = psiClass.getFields(); List fields = new ArrayList(psiFields.length); for (PsiField psiField : psiFields) { + if (psiField.getContainingClass() != psiClass) + continue; fields.add(new PsiFieldWrapper(psiField)); } - this.fields = fields; + this.ownFields = fields; } - return fields; + return ownFields; } public String getQualifiedName() { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiMemberWrapper.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiMemberWrapper.java index 9bb7dbb5694..16337969c30 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiMemberWrapper.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiMemberWrapper.java @@ -32,6 +32,11 @@ public abstract class PsiMemberWrapper { this.psiMember = psiMember; } + @NotNull + public PsiMember getPsiMember() { + return psiMember; + } + public boolean isStatic() { return psiMember.hasModifierProperty(PsiModifier.STATIC); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java index d22f7684274..7754aa2400d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java @@ -22,6 +22,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassKind; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.OverridingUtil; @@ -109,7 +111,7 @@ public class OverloadingConflictResolver { return false; } } - + if (discriminateGenericDescriptors && isGeneric(f)) { if (!isGeneric(g)) { return false; @@ -122,7 +124,7 @@ public class OverloadingConflictResolver { return true; } - + private boolean isGeneric(CallableDescriptor f) { return !f.getOriginal().getTypeParameters().isEmpty(); } diff --git a/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java b/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java index 4610b62d740..6abd1bd31ce 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java +++ b/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java @@ -18,7 +18,19 @@ package org.jetbrains.jet.compiler; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.codegen.PropertyCodegen; -import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassKind; +import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; +import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.Modality; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; +import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; +import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaNamespaceDescriptor; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -32,7 +44,12 @@ import java.io.BufferedReader; import java.io.IOException; import java.io.StringReader; import java.lang.reflect.Method; -import java.util.*; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; /** * @author Stepan Koltsov @@ -166,8 +183,11 @@ class NamespaceComparator { case TRAIT: sb.append("trait"); break; + case OBJECT: + sb.append("object"); + break; default: - throw new IllegalStateException(); + throw new IllegalStateException("unknown class kind: " + kind); } } @@ -184,6 +204,10 @@ class NamespaceComparator { public void serialize(FunctionDescriptor fun) { serialize(fun.getModality()); sb.append(" "); + + if (!fun.getOverriddenDescriptors().isEmpty()) { + sb.append("override /*" + fun.getOverriddenDescriptors().size() + "*/ "); + } if (fun instanceof ConstructorDescriptor) { sb.append("/*constructor*/ "); @@ -473,6 +497,12 @@ class NamespaceComparator { for (String memberString : memberStrings) { sb.append(indent(memberString)); } + + if (klass.getClassObjectDescriptor() != null) { + StringBuilder sbForClassObject = new StringBuilder(); + new FullContentSerialier(sbForClassObject).serialize(klass.getClassObjectDescriptor()); + sb.append(indent(sbForClassObject.toString())); + } sb.append("}\n"); } diff --git a/testlib/test/regressions/kt1202.kt b/testlib/test/regressions/kt1202.kt index e158681e0ac..48b3f735e55 100644 --- a/testlib/test/regressions/kt1202.kt +++ b/testlib/test/regressions/kt1202.kt @@ -2,6 +2,7 @@ package testeval import java.util.* import junit.framework.TestCase.* +import junit.framework.Assert.* // TODO unnecessary import trait Expression class Num(val value : Int) : Expression