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

refactor TypeVariableResolver

Browse Source 
* simplified and unified
* better diagnostics (if type variabe is not found, exception message contains reference)
This commit is contained in:
Stepan Koltsov
2012-02-29 19:21:10 +04:00
parent 6b51c20858
commit 20ca194eef
5 changed files with 112 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+54 -47
View File
@@ -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<JetType> supertypes = new ArrayList<JetType>();
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<TypeParameterDescriptor>(), 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.<AnnotationDescriptor>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<TypeParameterDescriptorInitialization> resolveClassTypeParametersFromJetSignature(String jetSignature, final PsiClass clazz,
final ClassDescriptor classDescriptor, final TypeVariableResolver outerClassTypeVariableResolver) {
JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = new JetSignatureTypeParametersVisitor(outerClassTypeVariableResolver, classDescriptor, clazz) {
private List<TypeParameterDescriptorInitialization> 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<TypeParameterDescriptorInitialization> typeParametersInitialization, TypeVariableResolver typeVariableByPsiResolver) {
private void initializeTypeParameters(List<TypeParameterDescriptorInitialization> typeParametersInitialization, @NotNull DeclarationDescriptor typeParametersOwner, @NotNull String context) {
List<TypeParameterDescriptor> prevTypeParameters = new ArrayList<TypeParameterDescriptor>();
for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) {
prevTypeParameters.add(psiTypeParameter.descriptor);
initializeTypeParameter(psiTypeParameter, new TypeVariableResolverFromTypeDescriptors(prevTypeParameters, typeVariableByPsiResolver));
initializeTypeParameter(psiTypeParameter, TypeVariableResolvers.typeVariableResolverFromTypeParameters(prevTypeParameters, typeParametersOwner, context));
}
}
private Collection<JetType> getSupertypes(PsiClassWrapper psiClass, ClassDescriptor classDescriptor, List<TypeParameterDescriptor> typeParameters) {
final List<JetType> result = new ArrayList<JetType>();
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<VariableDescriptor> resolveFieldGroupByName(@NotNull ClassOrNamespaceDescriptor owner, PsiClass psiClass, String fieldName, boolean staticMembers) {
public Set<VariableDescriptor> 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<VariableDescriptor> r = new HashSet<VariableDescriptor>();
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<VariableDescriptor> resolveFieldGroup(@NotNull ClassOrNamespaceDescriptor owner, PsiClass psiClass, boolean staticMembers) {
public Set<VariableDescriptor> 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<TypeParameterDescriptor> 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<TypeParameterDescriptor> typeParametersInitialization = new ArrayList<TypeParameterDescriptor>(0);
List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(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<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>();
for (TypeParameterDescriptor typeParameter : typeParametersInitialization) {
typeParameters.add(typeParameter);
}
List<TypeParameterDescriptor> typeParametersForReceiver = new ArrayList<TypeParameterDescriptor>();
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<TypeParameterDescriptor> 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<TypeParameterDescriptorInitialization> 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<TypeParameterDescriptor> 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<TypeParameterDescriptorInitialization> resolveMethodTypeParametersFromJetSignature(String jetSignature, final PsiMethod method,
final DeclarationDescriptor functionDescriptor, final TypeVariableResolver classTypeVariableResolver)
private List<TypeParameterDescriptorInitialization> 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;
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromOuters.java
-56
View File
@@ -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());
}
}
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromTypeDescriptors.java
+36 -7
View File
@@ -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<TypeParameterDescriptor> typeParameters;
@Nullable
private final TypeVariableResolver parent;
@NotNull
private final DeclarationDescriptor typeParametersOwner;
@NotNull
private final String context;
public TypeVariableResolverFromTypeDescriptors(@NotNull List<TypeParameterDescriptor> typeParameters, @Nullable TypeVariableResolver parent) {
public TypeVariableResolverFromTypeDescriptors(
@NotNull List<TypeParameterDescriptor> 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<TypeParameterDescriptor> 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);
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolvers.java
+21 -3
View File
@@ -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<TypeParameterDescriptor> 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<TypeParameterDescriptor>(0), null);
return new ArrayList<TypeParameterDescriptor>(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<TypeParameterDescriptor> typeParameters, @NotNull DeclarationDescriptor owner, @NotNull String context) {
return new TypeVariableResolverFromTypeDescriptors(typeParameters, owner, context);
}
}