From 87b22e810fb9206c6ae5187151eb48fa0541d140 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Mon, 26 Sep 2011 20:41:37 +0400 Subject: [PATCH] JAVA_ROOT eliminated. Proper parents for everything except generic parameters of functions --- .../resolve/java/JavaClassMembersScope.java | 19 ++-- .../resolve/java/JavaDescriptorResolver.java | 105 ++++++++++++++---- .../resolve/java/JavaTypeTransformer.java | 2 +- .../DeclarationDescriptorImpl.java | 2 +- .../checkerWithErrorTypes/quick/Override.jet | 63 ++++++++--- 5 files changed, 147 insertions(+), 44 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java index 713f828c4f3..8aed6d1ea3f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java @@ -71,13 +71,7 @@ public class JavaClassMembersScope implements JetScope { public Collection getAllDescriptors() { if (allDescriptors == null) { allDescriptors = Sets.newHashSet(); - TypeSubstitutor substitutorForGenericSupertypes; - if (containingDeclaration instanceof ClassDescriptor) { - substitutorForGenericSupertypes = semanticServices.getDescriptorResolver().createSubstitutorForGenericSupertypes((ClassDescriptor) containingDeclaration); - } - else { - substitutorForGenericSupertypes = TypeSubstitutor.EMPTY; - } + TypeSubstitutor substitutorForGenericSupertypes = getTypeSubstitutorForSupertypes(); for (HierarchicalMethodSignature signature : psiClass.getVisibleSignatures()) { PsiMethod method = signature.getMethod(); @@ -98,6 +92,17 @@ public class JavaClassMembersScope implements JetScope { return allDescriptors; } + private TypeSubstitutor getTypeSubstitutorForSupertypes() { + TypeSubstitutor substitutorForGenericSupertypes; + if (containingDeclaration instanceof ClassDescriptor) { + substitutorForGenericSupertypes = semanticServices.getDescriptorResolver().createSubstitutorForGenericSupertypes((ClassDescriptor) containingDeclaration); + } + else { + substitutorForGenericSupertypes = TypeSubstitutor.EMPTY; + } + return substitutorForGenericSupertypes; + } + private ClassifierDescriptor doGetClassifierDescriptor(String name) { // TODO : suboptimal, walk the list only once for (PsiClass innerClass : psiClass.getAllInnerClasses()) { 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 90aa3ac07c4..2d4c8b30948 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 @@ -21,11 +21,11 @@ import java.util.*; */ public class JavaDescriptorResolver { - /*package*/ static final DeclarationDescriptor JAVA_ROOT = new DeclarationDescriptorImpl(null, Collections.emptyList(), "") { - @NotNull + /*package*/ static final DeclarationDescriptor JAVA_METHOD_TYPE_PARAMETER_PARENT = new DeclarationDescriptorImpl(null, Collections.emptyList(), "") { + @Override public DeclarationDescriptor substitute(TypeSubstitutor substitutor) { - throw new UnsupportedOperationException(); // TODO + throw new UnsupportedOperationException(); } @Override @@ -38,7 +38,7 @@ public class JavaDescriptorResolver { @NotNull @Override public DeclarationDescriptor substitute(TypeSubstitutor substitutor) { - throw new UnsupportedOperationException(); // TODO + throw new UnsupportedOperationException(); } @Override @@ -51,7 +51,7 @@ public class JavaDescriptorResolver { protected final Map typeParameterDescriptorCache = Maps.newHashMap(); protected final Map methodDescriptorCache = Maps.newHashMap(); protected final Map fieldDescriptorCache = Maps.newHashMap(); - protected final Map namespaceDescriptorCache = new HashMap(); + protected final Map namespaceDescriptorCache = Maps.newHashMap(); protected final JavaPsiFacade javaFacade; protected final GlobalSearchScope javaSearchScope; protected final JavaSemanticServices semanticServices; @@ -92,7 +92,7 @@ public class JavaDescriptorResolver { String name = psiClass.getName(); JavaClassDescriptor classDescriptor = new JavaClassDescriptor( - JAVA_ROOT, psiClass.isInterface() ? ClassKind.TRAIT : ClassKind.CLASS + resolveParentDescriptor(psiClass), psiClass.isInterface() ? ClassKind.TRAIT : ClassKind.CLASS ); classDescriptor.setName(name); @@ -163,6 +163,17 @@ public class JavaDescriptorResolver { return classDescriptor; } + private DeclarationDescriptor resolveParentDescriptor(PsiClass psiClass) { + PsiClass containingClass = psiClass.getContainingClass(); + if (containingClass != null) { + return resolveClass(psiClass); + } + + PsiJavaFile containingFile = (PsiJavaFile) psiClass.getContainingFile(); + String packageName = containingFile.getPackageName(); + return resolveNamespace(packageName); + } + private List resolveTypeParameters(@NotNull DeclarationDescriptor containingDeclaration, @NotNull PsiTypeParameter[] typeParameters) { List result = Lists.newArrayList(); for (PsiTypeParameter typeParameter : typeParameters) { @@ -223,7 +234,15 @@ public class JavaDescriptorResolver { } public NamespaceDescriptor resolveNamespace(String qualifiedName) { - NamespaceDescriptor namespaceDescriptor = namespaceDescriptorCache.get(qualifiedName); + PsiPackage psiPackage = javaFacade.findPackage(qualifiedName); + if (psiPackage == null) { + return null; + } + return resolveNamespace(psiPackage); + } + + private NamespaceDescriptor resolveNamespace(@NotNull PsiPackage psiPackage) { + NamespaceDescriptor namespaceDescriptor = namespaceDescriptorCache.get(psiPackage); if (namespaceDescriptor == null) { // TODO : packages @@ -232,31 +251,37 @@ public class JavaDescriptorResolver { // namespaceDescriptor = createJavaNamespaceDescriptor(psiClass); // } // else { - PsiPackage psiPackage = javaFacade.findPackage(qualifiedName); - if (psiPackage == null) { - return null; - } namespaceDescriptor = createJavaNamespaceDescriptor(psiPackage); // } - namespaceDescriptorCache.put(qualifiedName, namespaceDescriptor); + namespaceDescriptorCache.put(psiPackage, namespaceDescriptor); } return namespaceDescriptor; } - private NamespaceDescriptor createJavaNamespaceDescriptor(PsiPackage psiPackage) { + private NamespaceDescriptor createJavaNamespaceDescriptor(@NotNull PsiPackage psiPackage) { + String name = psiPackage.getName(); JavaNamespaceDescriptor namespaceDescriptor = new JavaNamespaceDescriptor( - JAVA_ROOT, + resolveParentDescriptor(psiPackage), Collections.emptyList(), // TODO - psiPackage.getName() + name == null ? "" : name ); + namespaceDescriptor.setMemberScope(new JavaPackageScope(psiPackage.getQualifiedName(), namespaceDescriptor, semanticServices)); semanticServices.getTrace().record(BindingContext.NAMESPACE, psiPackage, namespaceDescriptor); return namespaceDescriptor; } + private DeclarationDescriptor resolveParentDescriptor(@NotNull PsiPackage psiPackage) { + PsiPackage parentPackage = psiPackage.getParentPackage(); + if (parentPackage == null) { + return null; + } + return resolveNamespace(parentPackage); + } + private NamespaceDescriptor createJavaNamespaceDescriptor(@NotNull final PsiClass psiClass) { JavaNamespaceDescriptor namespaceDescriptor = new JavaNamespaceDescriptor( - JAVA_ROOT, + resolveParentDescriptor(psiClass), Collections.emptyList(), // TODO psiClass.getName() ); @@ -312,15 +337,11 @@ public class JavaDescriptorResolver { final Collection signatures = psiClass.getVisibleSignatures(); TypeSubstitutor typeSubstitutor = createSubstitutorForGenericSupertypes(classDescriptor); for (HierarchicalMethodSignature signature: signatures) { - PsiMethod method = signature.getMethod(); - if (method.hasModifierProperty(PsiModifier.STATIC) != staticMembers) { - continue; - } - if (!methodName.equals(method.getName())) { + if (!methodName.equals(signature.getName())) { continue; } - FunctionDescriptor substitutedFunctionDescriptor = resolveMethodToFunctionDescriptor(owner, psiClass, typeSubstitutor, method); + FunctionDescriptor substitutedFunctionDescriptor = resolveHierarchicalSignatureToFunction(owner, psiClass, staticMembers, typeSubstitutor, signature); if (substitutedFunctionDescriptor != null) { writableFunctionGroup.add(substitutedFunctionDescriptor); } @@ -328,6 +349,21 @@ public class JavaDescriptorResolver { return writableFunctionGroup; } + @Nullable + private FunctionDescriptor resolveHierarchicalSignatureToFunction(DeclarationDescriptor owner, PsiClass psiClass, boolean staticMembers, TypeSubstitutor typeSubstitutor, HierarchicalMethodSignature signature) { + PsiMethod method = signature.getMethod(); + if (method.hasModifierProperty(PsiModifier.STATIC) != staticMembers) { + return null; + } + FunctionDescriptor functionDescriptor = resolveMethodToFunctionDescriptor(owner, psiClass, typeSubstitutor, method); +// if (functionDescriptor != null && !staticMembers) { +// for (HierarchicalMethodSignature superSignature : signature.getSuperSignatures()) { +// ((FunctionDescriptorImpl) functionDescriptor).addOverriddenFunction(resolveHierarchicalSignatureToFunction(owner, superSignature.getMethod().getContainingClass(), false, typeSubstitutor, superSignature)); +// } +// } + return functionDescriptor; + } + public TypeSubstitutor createSubstitutorForGenericSupertypes(ClassDescriptor classDescriptor) { TypeSubstitutor typeSubstitutor; if (classDescriptor != null) { @@ -382,4 +418,29 @@ public class JavaDescriptorResolver { (modifierListOwner.hasModifierProperty(PsiModifier.PROTECTED) ? Visibility.PROTECTED : Visibility.INTERNAL)); } + public TypeParameterDescriptor resolveTypeParameter(PsiTypeParameter typeParameter) { + PsiTypeParameterListOwner owner = typeParameter.getOwner(); + if (owner instanceof PsiClass) { + PsiClass psiClass = (PsiClass) owner; + return resolveTypeParameter(resolveClass(psiClass), typeParameter); + } + if (owner instanceof PsiMethod) { + PsiMethod psiMethod = (PsiMethod) owner; + PsiClass containingClass = psiMethod.getContainingClass(); + DeclarationDescriptor ownerOwner; + TypeSubstitutor substitutorForGenericSupertypes; + if (psiMethod.hasModifierProperty(PsiModifier.STATIC)) { + substitutorForGenericSupertypes = TypeSubstitutor.EMPTY; + return resolveTypeParameter(JAVA_METHOD_TYPE_PARAMETER_PARENT, typeParameter); + } + else { + ClassDescriptor classDescriptor = resolveClass(containingClass); + ownerOwner = classDescriptor; + substitutorForGenericSupertypes = semanticServices.getDescriptorResolver().createSubstitutorForGenericSupertypes(classDescriptor); + } + FunctionDescriptor functionDescriptor = resolveMethodToFunctionDescriptor(ownerOwner, containingClass, substitutorForGenericSupertypes, psiMethod); + return resolveTypeParameter(functionDescriptor, typeParameter); + } + throw new IllegalStateException("Unknown parent type: " + owner); + } } 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 a895094dbca..f7d9292e660 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 @@ -70,7 +70,7 @@ public class JavaTypeTransformer { if (psiClass instanceof PsiTypeParameter) { PsiTypeParameter typeParameter = (PsiTypeParameter) psiClass; - TypeParameterDescriptor typeParameterDescriptor = resolver.resolveTypeParameter(JavaDescriptorResolver.JAVA_ROOT, typeParameter); + TypeParameterDescriptor typeParameterDescriptor = resolver.resolveTypeParameter(typeParameter); return typeParameterDescriptor.getDefaultType(); } else { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorImpl.java index 4574e5c9408..defab1eca28 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorImpl.java @@ -16,7 +16,7 @@ public abstract class DeclarationDescriptorImpl extends AnnotatedImpl implements private final String name; private final DeclarationDescriptor containingDeclaration; - public DeclarationDescriptorImpl(@Nullable DeclarationDescriptor containingDeclaration, List annotations, String name) { + public DeclarationDescriptorImpl(@Nullable DeclarationDescriptor containingDeclaration, @NotNull List annotations, @NotNull String name) { super(annotations); this.name = name; this.containingDeclaration = containingDeclaration; diff --git a/idea/testData/checkerWithErrorTypes/quick/Override.jet b/idea/testData/checkerWithErrorTypes/quick/Override.jet index 23056bae452..ce46dadac07 100644 --- a/idea/testData/checkerWithErrorTypes/quick/Override.jet +++ b/idea/testData/checkerWithErrorTypes/quick/Override.jet @@ -3,37 +3,51 @@ namespace override namespace normal { trait MyTrait { fun foo() + val pr : Unit } abstract class MyAbstractClass { abstract fun bar() + abstract val prr : Unit + } - open class MyClass : MyTrait, MyAbstractClass { + open class MyClass() : MyTrait, MyAbstractClass { override fun foo() {} override fun bar() {} + + override val pr : Unit = () + override val prr : Unit = () } - class MyChildClass : MyClass {} + class MyChildClass() : MyClass() {} class MyIllegalClass : MyTrait, MyAbstractClass {} - class MyIllegalClass2 : MyTrait, MyAbstractClass { + class MyIllegalClass2() : MyTrait, MyAbstractClass { override fun foo() {} + override val pr : Unit = () + override val prr : Unit = () } - class MyIllegalClass3 : MyTrait, MyAbstractClass { + class MyIllegalClass3() : MyTrait, MyAbstractClass { override fun bar() {} + override val pr : Unit = () + override val prr : Unit = () } - class MyIllegalClass4 : MyTrait, MyAbstractClass { + class MyIllegalClass4() : MyTrait, MyAbstractClass { fun foo() {} + val pr : Unit override fun other() {} + override val otherPr : Int = 1 } - class MyChildClass1 : MyClass { + class MyChildClass1() : MyClass() { fun foo() {} + val pr : Unit = () override fun bar() {} + override val prr : Unit = () } } @@ -44,33 +58,56 @@ namespace generics { abstract class MyAbstractClass { abstract fun bar(t: T) : T + abstract val pr : T } - open class MyGenericClass : MyTrait, MyAbstractClass { + trait MyProps { + val p : T + } + + open class MyGenericClass(t : T) : MyTrait, MyAbstractClass, MyProps { override fun foo(t: T) = t override fun bar(t: T) = t + override val p : T = t + override val pr : T = t } - class MyChildClass : MyGenericClass {} - class MyChildClass1 : MyGenericClass {} - class MyChildClass2 : MyGenericClass { + class MyChildClass() : MyGenericClass(1) {} + class MyChildClass1(t : T) : MyGenericClass(t) {} + class MyChildClass2(t : T) : MyGenericClass(t) { fun foo(t: T) = t + val pr : T = t override fun bar(t: T) = t + override val p : T = t } - open class MyClass : MyTrait, MyAbstractClass { + open class MyClass() : MyTrait, MyAbstractClass { + override fun foo(i: Int) = i + override fun bar(s: String) = s + override val pr : String = "1" + } + + abstract class MyAbstractClass1 : MyTrait, MyAbstractClass { override fun foo(i: Int) = i override fun bar(s: String) = s } class MyIllegalGenericClass1 : MyTrait, MyAbstractClass {} - class MyIllegalGenericClass2 : MyTrait, MyAbstractClass { + class MyIllegalGenericClass2(r : R) : MyTrait, MyAbstractClass { override fun foo(r: R) = r + override val pr : R = r } class MyIllegalClass1 : MyTrait, MyAbstractClass {} + abstract class MyLegalAbstractClass1 : MyTrait, MyAbstractClass {} - class MyIllegalClass2 : MyTrait, MyAbstractClass { + class MyIllegalClass2(t : T) : MyTrait, MyAbstractClass { fun foo(t: T) = t fun bar(t: T) = t + val pr : T = t + } + abstract class MyLegalAbstractClass2(t : T) : MyTrait, MyAbstractClass { + fun foo(t: T) = t + fun bar(t: T) = t + val pr : T = t } } \ No newline at end of file