From 20ca194eefe843d6e392e88af6ae324e94db29d9 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Wed, 29 Feb 2012 19:21:10 +0400 Subject: [PATCH] refactor TypeVariableResolver * simplified and unified * better diagnostics (if type variabe is not found, exception message contains reference) --- .../resolve/java/JavaDescriptorResolver.java | 101 ++++++++++-------- .../java/TypeVariableResolverFromOuters.java | 56 ---------- ...peVariableResolverFromTypeDescriptors.java | 43 ++++++-- .../resolve/java/TypeVariableResolvers.java | 24 ++++- .../lang/descriptors/ModuleDescriptor.java | 2 +- 5 files changed, 112 insertions(+), 114 deletions(-) delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromOuters.java 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 f5063500f7f..d06c3a74cde 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 @@ -282,14 +282,16 @@ public class JavaDescriptorResolver { ResolverBinaryClassData classData = new ResolverBinaryClassData(); classDescriptorCache.put(psiClass.getQualifiedName(), classData); ClassKind kind = psiClass.isInterface() ? (psiClass.isAnnotationType() ? ClassKind.ANNOTATION_CLASS : ClassKind.TRAIT) : ClassKind.CLASS; - DeclarationDescriptor containingDeclaration = resolveParentDescriptor(psiClass); + ClassOrNamespaceDescriptor containingDeclaration = resolveParentDescriptor(psiClass); classData.classDescriptor = new MutableClassDescriptorLite(containingDeclaration, kind); classData.classDescriptor.setName(name); classData.classDescriptor.setAnnotations(resolveAnnotations(psiClass)); List supertypes = new ArrayList(); - TypeVariableResolverFromOuters outerTypeVariableByNameResolver = new TypeVariableResolverFromOuters(containingDeclaration); + TypeVariableResolver outerTypeVariableByNameResolver = TypeVariableResolvers.classTypeVariableResolver( + (ClassOrNamespaceDescriptor) classData.classDescriptor.getContainingDeclaration(), + "class " + psiClass.getQualifiedName()); classData.typeParameters = createUninitializedClassTypeParameters(psiClass, classData, outerTypeVariableByNameResolver); @@ -314,9 +316,11 @@ public class JavaDescriptorResolver { classData.classDescriptor.createTypeConstructor(); classData.classDescriptor.setScopeForMemberLookup(new JavaClassMembersScope(classData.classDescriptor, psiClass, semanticServices, false)); - initializeTypeParameters(classData.typeParameters, new TypeVariableResolverFromTypeDescriptors(new ArrayList(), outerTypeVariableByNameResolver)); + initializeTypeParameters(classData.typeParameters, classData.classDescriptor, "class " + psiClass.getQualifiedName()); - TypeVariableResolverFromTypeDescriptors resolverForTypeParameters = new TypeVariableResolverFromTypeDescriptors(classData.getTypeParameters(), null); + TypeVariableResolver resolverForTypeParameters = TypeVariableResolvers.classTypeVariableResolver( + classData.classDescriptor, + "class " + psiClass.getQualifiedName()); // TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes supertypes.addAll(getSupertypes(new PsiClassWrapper(psiClass), classData.classDescriptor, classData.getTypeParameters())); @@ -392,10 +396,10 @@ public class JavaDescriptorResolver { classData.classDescriptor, Collections.emptyList(), // TODO false); + String context = "constructor of class " + psiClass.getQualifiedName(); ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(constructorDescriptor, constructor.getParameters(), - new TypeVariableResolverFromTypeDescriptors(classData.getTypeParameters(), null) // TODO: outer too - ); + TypeVariableResolvers.classTypeVariableResolver(classData.classDescriptor, context)); if (valueParameterDescriptors.receiverType != null) { throw new IllegalStateException(); } @@ -474,7 +478,7 @@ public class JavaDescriptorResolver { if (jetClassAnnotation.signature().length() > 0) { return resolveClassTypeParametersFromJetSignature( - jetClassAnnotation.signature(), psiClass, classData.classDescriptor, typeVariableResolver); + jetClassAnnotation.signature(), psiClass, classData.classDescriptor); } return makeUninitializedTypeParameters(classData.classDescriptor, psiClass.getTypeParameters()); @@ -578,11 +582,14 @@ public class JavaDescriptorResolver { private final TypeVariableResolver typeVariableResolver; - private JetSignatureTypeParametersVisitor(@NotNull TypeVariableResolver containerTypeVariableResolver, @NotNull DeclarationDescriptor containingDeclaration, @NotNull PsiTypeParameterListOwner psiOwner) { + private JetSignatureTypeParametersVisitor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull PsiTypeParameterListOwner psiOwner, @NotNull String context) { this.containingDeclaration = containingDeclaration; this.psiOwner = psiOwner; - this.typeVariableResolver = new TypeVariableResolverFromTypeDescriptors(previousTypeParameters, containerTypeVariableResolver); + this.typeVariableResolver = TypeVariableResolvers.typeVariableResolverFromTypeParameters( + previousTypeParameters, + containingDeclaration, + context); } private int formalTypeParameterIndex = 0; @@ -613,11 +620,12 @@ public class JavaDescriptorResolver { } /** - * @see #resolveMethodTypeParametersFromJetSignature(String, com.intellij.psi.PsiMethod, org.jetbrains.jet.lang.descriptors.DeclarationDescriptor, TypeVariableResolver) + * @see #resolveMethodTypeParametersFromJetSignature(String, com.intellij.psi.PsiMethod, org.jetbrains.jet.lang.descriptors.DeclarationDescriptor) */ - private List resolveClassTypeParametersFromJetSignature(String jetSignature, final PsiClass clazz, - final ClassDescriptor classDescriptor, final TypeVariableResolver outerClassTypeVariableResolver) { - JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = new JetSignatureTypeParametersVisitor(outerClassTypeVariableResolver, classDescriptor, clazz) { + private List resolveClassTypeParametersFromJetSignature(String jetSignature, + final PsiClass clazz, final ClassDescriptor classDescriptor) { + String context = "class " + clazz.getQualifiedName(); + JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = new JetSignatureTypeParametersVisitor(classDescriptor, clazz, context) { @Override public JetSignatureVisitor visitSuperclass() { // TODO @@ -634,7 +642,7 @@ public class JavaDescriptorResolver { return jetSignatureTypeParametersVisitor.r; } - private DeclarationDescriptor resolveParentDescriptor(PsiClass psiClass) { + private ClassOrNamespaceDescriptor resolveParentDescriptor(PsiClass psiClass) { PsiClass containingClass = psiClass.getContainingClass(); if (containingClass != null) { return resolveClass(containingClass); @@ -704,19 +712,21 @@ public class JavaDescriptorResolver { typeParameterDescriptor.setInitialized(); } - private void initializeTypeParameters(List typeParametersInitialization, TypeVariableResolver typeVariableByPsiResolver) { + private void initializeTypeParameters(List typeParametersInitialization, @NotNull DeclarationDescriptor typeParametersOwner, @NotNull String context) { List prevTypeParameters = new ArrayList(); for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) { prevTypeParameters.add(psiTypeParameter.descriptor); - initializeTypeParameter(psiTypeParameter, new TypeVariableResolverFromTypeDescriptors(prevTypeParameters, typeVariableByPsiResolver)); + initializeTypeParameter(psiTypeParameter, TypeVariableResolvers.typeVariableResolverFromTypeParameters(prevTypeParameters, typeParametersOwner, context)); } } private Collection getSupertypes(PsiClassWrapper psiClass, ClassDescriptor classDescriptor, List typeParameters) { final List result = new ArrayList(); + String context = "class " + psiClass.getQualifiedName(); + if (psiClass.getJetClass().signature().length() > 0) { - final TypeVariableResolver typeVariableResolver = new TypeVariableResolverFromTypeDescriptors(typeParameters, null); + final TypeVariableResolver typeVariableResolver = TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context); new JetSignatureReader(psiClass.getJetClass().signature()).accept(new JetSignatureExceptionsAdapter() { @Override @@ -743,8 +753,9 @@ public class JavaDescriptorResolver { } }); } else { - transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), new TypeVariableResolverFromTypeDescriptors(typeParameters, null), classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS); - transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), new TypeVariableResolverFromTypeDescriptors(typeParameters, null), classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS); + TypeVariableResolver typeVariableResolverForSupertypes = TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context); + transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), typeVariableResolverForSupertypes, classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS); + transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), typeVariableResolverForSupertypes, classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS); } for (JetType supertype : result) { @@ -978,7 +989,7 @@ public class JavaDescriptorResolver { } } - public Set resolveFieldGroupByName(@NotNull ClassOrNamespaceDescriptor owner, PsiClass psiClass, String fieldName, boolean staticMembers) { + public Set resolveFieldGroupByName(@NotNull ClassOrNamespaceDescriptor owner, @NotNull PsiClass psiClass, String fieldName, boolean staticMembers) { ResolverScopeData scopeData = getResolverScopeData(owner, new PsiClassWrapper(psiClass)); NamedMembers namedMembers = scopeData.namedMembersMap.get(fieldName); @@ -987,7 +998,7 @@ public class JavaDescriptorResolver { } Set r = new HashSet(); - resolveNamedGroupProperties(owner, scopeData, staticMembers, namedMembers, fieldName); + resolveNamedGroupProperties(owner, scopeData, staticMembers, namedMembers, fieldName, "class or namespace " + psiClass.getQualifiedName()); r.addAll(namedMembers.propertyDescriptors); @@ -999,7 +1010,7 @@ public class JavaDescriptorResolver { } @NotNull - public Set resolveFieldGroup(@NotNull ClassOrNamespaceDescriptor owner, PsiClass psiClass, boolean staticMembers) { + public Set resolveFieldGroup(@NotNull ClassOrNamespaceDescriptor owner, @NotNull PsiClass psiClass, boolean staticMembers) { ResolverScopeData scopeData = getResolverScopeData(owner, new PsiClassWrapper(psiClass)); @@ -1013,7 +1024,7 @@ public class JavaDescriptorResolver { String propertyName = entry.getKey(); - resolveNamedGroupProperties(owner, scopeData, staticMembers, namedMembers, propertyName); + resolveNamedGroupProperties(owner, scopeData, staticMembers, namedMembers, propertyName, "class or namespace " + psiClass.getQualifiedName()); descriptors.addAll(namedMembers.propertyDescriptors); } @@ -1060,7 +1071,9 @@ public class JavaDescriptorResolver { private void resolveNamedGroupProperties( @NotNull ClassOrNamespaceDescriptor owner, @NotNull ResolverScopeData scopeData, - boolean staticMembers, NamedMembers namedMembers, String propertyName) { + boolean staticMembers, @NotNull NamedMembers namedMembers, @NotNull String propertyName, + @NotNull String context + ) { if (namedMembers.propertyDescriptors != null) { return; } @@ -1070,9 +1083,7 @@ public class JavaDescriptorResolver { return; } - final List classTypeParameterDescriptorInitialization = scopeData.getTypeParameters(); - - TypeVariableResolver typeVariableResolver = new TypeVariableResolverFromTypeDescriptors(scopeData.getTypeParameters(), null); + TypeVariableResolver typeVariableResolver = TypeVariableResolvers.classTypeVariableResolver(owner, context); class GroupingValue { PropertyAccessorData getter; @@ -1186,32 +1197,24 @@ public class JavaDescriptorResolver { propertyDescriptor.initialize(getterDescriptor, setterDescriptor); - List typeParametersInitialization = new ArrayList(0); + List typeParameters = new ArrayList(0); if (members.setter != null) { PsiMethodWrapper method = (PsiMethodWrapper) members.setter.getMember(); if (anyMember == members.setter) { - typeParametersInitialization = resolveMethodTypeParameters(method, setterDescriptor, typeVariableResolver); + typeParameters = resolveMethodTypeParameters(method, propertyDescriptor, typeVariableResolver); } } if (members.getter != null) { PsiMethodWrapper method = (PsiMethodWrapper) members.getter.getMember(); if (anyMember == members.getter) { - typeParametersInitialization = resolveMethodTypeParameters(method, getterDescriptor, typeVariableResolver); + typeParameters = resolveMethodTypeParameters(method, propertyDescriptor, typeVariableResolver); } } - List typeParameters = new ArrayList(); - for (TypeParameterDescriptor typeParameter : typeParametersInitialization) { - typeParameters.add(typeParameter); - } - - List typeParametersForReceiver = new ArrayList(); - typeParametersForReceiver.addAll(classTypeParameterDescriptorInitialization); - typeParametersForReceiver.addAll(typeParametersInitialization); - TypeVariableResolver typeVariableResolverForPropertyInternals = new TypeVariableResolverFromTypeDescriptors(typeParametersForReceiver, null); + TypeVariableResolver typeVariableResolverForPropertyInternals = TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, propertyDescriptor, "property " + propertyName + " in " + context); JetType propertyType; if (anyMember.getType().getTypeString().length() > 0) { @@ -1438,11 +1441,13 @@ public class JavaDescriptorResolver { CallableMemberDescriptor.Kind.DECLARATION ); - final TypeVariableResolver typeVariableResolverForParameters = TypeVariableResolvers.classTypeVariableResolver(classDescriptor); + String context = "method " + method.getName() + " in class " + psiClass.getQualifiedName(); + + final TypeVariableResolver typeVariableResolverForParameters = TypeVariableResolvers.classTypeVariableResolver(classDescriptor, context); final List methodTypeParameters = resolveMethodTypeParameters(method, functionDescriptorImpl, typeVariableResolverForParameters); - TypeVariableResolver methodTypeVariableResolver = new TypeVariableResolverFromTypeDescriptors(methodTypeParameters, typeVariableResolverForParameters); + TypeVariableResolver methodTypeVariableResolver = TypeVariableResolvers.typeVariableResolverFromTypeParameters(methodTypeParameters, functionDescriptorImpl, context); ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(functionDescriptorImpl, method.getParameters(), methodTypeVariableResolver); @@ -1544,12 +1549,13 @@ public class JavaDescriptorResolver { List typeParametersIntialization; if (method.getJetMethod().typeParameters().length() > 0) { typeParametersIntialization = resolveMethodTypeParametersFromJetSignature( - method.getJetMethod().typeParameters(), method.getPsiMethod(), functionDescriptor, classTypeVariableResolver); + method.getJetMethod().typeParameters(), method.getPsiMethod(), functionDescriptor); } else { typeParametersIntialization = makeUninitializedTypeParameters(functionDescriptor, method.getPsiMethod().getTypeParameters()); } - initializeTypeParameters(typeParametersIntialization, classTypeVariableResolver); + String context = "method " + method.getName() + " in class " + method.getPsiMethod().getContainingClass().getQualifiedName(); + initializeTypeParameters(typeParametersIntialization, functionDescriptor, context); List typeParameters = Lists.newArrayListWithCapacity(typeParametersIntialization.size()); @@ -1561,12 +1567,13 @@ public class JavaDescriptorResolver { } /** - * @see #resolveClassTypeParametersFromJetSignature(String, com.intellij.psi.PsiClass, org.jetbrains.jet.lang.descriptors.ClassDescriptor, TypeVariableResolver) + * @see #resolveClassTypeParametersFromJetSignature(String, com.intellij.psi.PsiClass, org.jetbrains.jet.lang.descriptors.ClassDescriptor) */ - private List resolveMethodTypeParametersFromJetSignature(String jetSignature, final PsiMethod method, - final DeclarationDescriptor functionDescriptor, final TypeVariableResolver classTypeVariableResolver) + private List resolveMethodTypeParametersFromJetSignature(String jetSignature, + final PsiMethod method, final DeclarationDescriptor functionDescriptor) { - JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = new JetSignatureTypeParametersVisitor(classTypeVariableResolver, functionDescriptor, method); + String context = "method " + method.getName() + " in class " + method.getContainingClass().getQualifiedName(); + JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = new JetSignatureTypeParametersVisitor(functionDescriptor, method, context); new JetSignatureReader(jetSignature).acceptFormalTypeParametersOnly(jetSignatureTypeParametersVisitor); return jetSignatureTypeParametersVisitor.r; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromOuters.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromOuters.java deleted file mode 100644 index c3d8a87a4a6..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromOuters.java +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright 2000-2012 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.lang.resolve.java; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; - -/** - * @author Stepan Koltsov - */ -public class TypeVariableResolverFromOuters implements TypeVariableResolver { - - @NotNull - private final DeclarationDescriptor outer; - - public TypeVariableResolverFromOuters(@NotNull DeclarationDescriptor outer) { - this.outer = outer; - } - - @NotNull - @Override - public TypeParameterDescriptor getTypeVariable(@NotNull String name) { - DeclarationDescriptor outer = this.outer; - for (;;) { - if (outer instanceof NamespaceDescriptor) { - throw new IllegalStateException("unresolve type parameter: " + name); - } else if (outer instanceof ClassDescriptor) { - for (TypeParameterDescriptor typeParameter : ((ClassDescriptor) outer).getTypeConstructor().getParameters()) { - if (typeParameter.getName().equals(name)) { - return typeParameter; - } - } - outer = outer.getContainingDeclaration(); - } else { - throw new IllegalStateException("unknown outer: " + outer.getClass().getName()); - } - } - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromTypeDescriptors.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromTypeDescriptors.java index 8c2713267d1..848a2e643bf 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromTypeDescriptors.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromTypeDescriptors.java @@ -18,6 +18,8 @@ package org.jetbrains.jet.lang.resolve.java; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import java.util.List; @@ -29,25 +31,52 @@ public class TypeVariableResolverFromTypeDescriptors implements TypeVariableReso @NotNull private final List typeParameters; - @Nullable - private final TypeVariableResolver parent; + @NotNull + private final DeclarationDescriptor typeParametersOwner; + @NotNull + private final String context; - public TypeVariableResolverFromTypeDescriptors(@NotNull List typeParameters, @Nullable TypeVariableResolver parent) { + public TypeVariableResolverFromTypeDescriptors( + @NotNull List typeParameters, + @NotNull DeclarationDescriptor owner, + @NotNull String context) { this.typeParameters = typeParameters; - this.parent = parent; + this.typeParametersOwner = owner; + this.context = context; + + for (TypeParameterDescriptor typeParameter : typeParameters) { + if (typeParameter.getContainingDeclaration() != owner) { + throw new IllegalStateException(); + } + } } @NotNull @Override public TypeParameterDescriptor getTypeVariable(@NotNull String name) { + return getTypeVariable(name, typeParameters, typeParametersOwner, context); + } + + @NotNull + private static TypeParameterDescriptor getTypeVariable( + @NotNull String name, + @NotNull List typeParameters, + @NotNull DeclarationDescriptor owner, + @NotNull String context) { for (TypeParameterDescriptor typeParameter : typeParameters) { if (typeParameter.getName().equals(name)) { return typeParameter; } } - if (parent != null) { - return parent.getTypeVariable(name); + + DeclarationDescriptor containingDeclaration = owner.getContainingDeclaration(); + if (containingDeclaration != null) { + return getTypeVariable( + name, + TypeVariableResolvers.getTypeParameterDescriptors((ClassOrNamespaceDescriptor) containingDeclaration), + containingDeclaration, + context); } - throw new RuntimeException("type parameter not found by name " + name); // TODO report properly + throw new RuntimeException("type parameter not found by name '" + name + "' in " + context); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolvers.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolvers.java index 9c4c1232120..6efcac5a4fa 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolvers.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolvers.java @@ -16,23 +16,41 @@ package org.jetbrains.jet.lang.resolve.java; +import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import java.util.ArrayList; +import java.util.List; /** * @author Stepan Koltsov */ public class TypeVariableResolvers { - public static TypeVariableResolver classTypeVariableResolver(ClassOrNamespaceDescriptor clazz) { + @NotNull + public static List getTypeParameterDescriptors(@NotNull ClassOrNamespaceDescriptor clazz) { if (clazz instanceof ClassDescriptor) { - return new TypeVariableResolverFromTypeDescriptors(((ClassDescriptor) clazz).getTypeConstructor().getParameters(), new TypeVariableResolverFromOuters(clazz.getContainingDeclaration())); + return ((ClassDescriptor) clazz).getTypeConstructor().getParameters(); } else { - return new TypeVariableResolverFromTypeDescriptors(new ArrayList(0), null); + return new ArrayList(0); } } + + @NotNull + public static TypeVariableResolver classTypeVariableResolver(@NotNull ClassOrNamespaceDescriptor clazz, @NotNull String context) { + return typeVariableResolverFromTypeParameters(getTypeParameterDescriptors(clazz), clazz, context); + } + + @NotNull + public static TypeVariableResolver typeVariableResolverFromTypeParameters( + @NotNull List typeParameters, @NotNull DeclarationDescriptor owner, @NotNull String context) { + + return new TypeVariableResolverFromTypeDescriptors(typeParameters, owner, context); + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java index bcced8441e1..772367c602e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java @@ -25,7 +25,7 @@ import java.util.Collections; /** * @author abreslav */ -public class ModuleDescriptor extends DeclarationDescriptorImpl { +public class ModuleDescriptor extends DeclarationDescriptorImpl implements ClassOrNamespaceDescriptor { public ModuleDescriptor(String name) { super(null, Collections.emptyList(), name); }