refactor TypeVariableResolver

* simplified and unified
* better diagnostics (if type variabe is not found, exception message contains reference)

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<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,
+    private List<TypeParameterDescriptorInitialization> resolveClassTypeParametersFromJetSignature(String jetSignature,
-            final ClassDescriptor classDescriptor, final TypeVariableResolver outerClassTypeVariableResolver) {
+            final PsiClass clazz, final ClassDescriptor classDescriptor) {
-        JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = new JetSignatureTypeParametersVisitor(outerClassTypeVariableResolver, classDescriptor, clazz) {
+        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);
+            TypeVariableResolver typeVariableResolverForSupertypes = TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context);
-            transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), new TypeVariableResolverFromTypeDescriptors(typeParameters, null), classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS);
+            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 = TypeVariableResolvers.classTypeVariableResolver(owner, context);
-
-        TypeVariableResolver typeVariableResolver = new TypeVariableResolverFromTypeDescriptors(scopeData.getTypeParameters(), null);
 
         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>();
+            TypeVariableResolver typeVariableResolverForPropertyInternals = TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, propertyDescriptor, "property " + propertyName + " in " + context);
-            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);
 
             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,
+    private List<TypeParameterDescriptorInitialization> resolveMethodTypeParametersFromJetSignature(String jetSignature,
-            final DeclarationDescriptor functionDescriptor, final TypeVariableResolver classTypeVariableResolver)
+            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

@@ -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

@@ -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
+    @NotNull
-    private final TypeVariableResolver parent;
+    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

@@ -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);
+    }
+    
 }

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.<AnnotationDescriptor>emptyList(), name);
     }