Services for completion

.idea/compiler.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="CompilerConfiguration">
-    <option name="DEFAULT_COMPILER" value="Javac" />
+    <option name="DEFAULT_COMPILER" value="Eclipse" />
     <resourceExtensions />
     <wildcardResourcePatterns>
       <entry name="?*.properties" />

idea/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java

@@ -213,7 +213,10 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     @NotNull
     @Override
     public ClassDescriptor substitute(TypeSubstitutor substitutor) {
-        throw new UnsupportedOperationException(); // TODO
+        if (substitutor.isEmpty()) {
+            return this;
+        }
+        return new LazySubstitutingClassDescriptor(this, substitutor);
     }
 
     @Override

idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java

 package org.jetbrains.jet.lang.psi;
 
+import com.google.common.collect.Lists;
 import com.intellij.codeInsight.lookup.LookupElement;
+import com.intellij.codeInsight.lookup.LookupElementPresentation;
 import com.intellij.lang.ASTNode;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
@@ -15,6 +17,9 @@ import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lexer.JetTokens;
+import org.jetbrains.jet.resolve.DescriptorRenderer;
+
+import java.util.List;
 
 /**
  * @author max
@@ -84,15 +89,25 @@ public class JetSimpleNameExpression extends JetReferenceExpression {
                     BindingContext bindingContext = AnalyzingUtils.analyzeFileWithCache(file);
                     final JetType expressionType = bindingContext.getExpressionType(receiverExpression);
                     if (expressionType != null) {
-                        return new Object[] {
-                                new LookupElement() {
-                                    @NotNull
-                                    @Override
-                                    public String getLookupString() {
-                                        return expressionType.toString();
+                        List<LookupElement> result = Lists.newArrayList();
+                        for (final DeclarationDescriptor descriptor : expressionType.getMemberScope().getAllDescriptors()) {
+                            result.add(
+                                    new LookupElement() {
+                                        @NotNull
+                                        @Override
+                                        public String getLookupString() {
+                                            return descriptor.getName();
+                                        }
+
+                                        @Override
+                                        public void renderElement(LookupElementPresentation presentation) {
+                                            presentation.setItemText(descriptor.getName());
+                                            presentation.setTypeText(DescriptorRenderer.TEXT.render(descriptor));
+                                        }
                                     }
-                                }
-                        };
+                            );
+                        }
+                        return result.toArray();
                     }
                 }
 

idea/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java

@@ -61,4 +61,9 @@ public abstract class AbstractScopeAdapter implements JetScope {
     public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() {
         return getWorkerScope().getDeclarationDescriptorForUnqualifiedThis();
     }
+
+    @Override
+    public Collection<DeclarationDescriptor> getAllDescriptors() {
+        return getWorkerScope().getAllDescriptors();
+    }
 }

idea/src/org/jetbrains/jet/lang/resolve/BindingContext.java

@@ -46,5 +46,8 @@ public interface BindingContext {
     @Nullable
     JetType getAutoCastType(@NotNull JetExpression expression);
 
+    @Nullable
+    JetScope getResolutionScope(@NotNull JetExpression expression);
+
     Collection<JetDiagnostic> getDiagnostics();
 }

idea/src/org/jetbrains/jet/lang/resolve/BindingTrace.java

@@ -29,6 +29,8 @@ public interface BindingTrace {
 
     void recordStatement(@NotNull JetElement statement);
 
+    void recordResolutionScope(@NotNull JetExpression expression, @NotNull JetScope scope);
+
     void removeStatementRecord(@NotNull JetElement statement);
 
     void removeReferenceResolution(@NotNull JetReferenceExpression referenceExpression);

idea/src/org/jetbrains/jet/lang/resolve/BindingTraceAdapter.java

@@ -91,4 +91,9 @@ public class BindingTraceAdapter implements BindingTrace {
     public BindingContext getBindingContext() {
         return originalTrace.getBindingContext();
     }
+
+    @Override
+    public void recordResolutionScope(@NotNull JetExpression expression, @NotNull JetScope scope) {
+        originalTrace.recordResolutionScope(expression, scope);
+    }
 }

idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java

@@ -36,6 +36,7 @@ public class BindingTraceContext implements BindingContext, BindingTrace {
 
     private final List<JetDiagnostic> diagnostics = Lists.newArrayList();
     private final ErrorHandlerWithRegions errorHandler = new ErrorHandlerWithRegions(new CollectingErrorHandler(diagnostics));
+    private Map<JetExpression, JetScope> resolutionScopes = Maps.newHashMap();
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -124,6 +125,11 @@ public class BindingTraceContext implements BindingContext, BindingTrace {
         statements.add(statement);
     }
 
+    @Override
+    public void recordResolutionScope(@NotNull JetExpression expression, @NotNull JetScope scope) {
+        safePut(resolutionScopes, expression, scope);
+    }
+
     @Override
     public void removeStatementRecord(@NotNull JetElement statement) {
         statements.remove(statement);
@@ -267,6 +273,11 @@ public class BindingTraceContext implements BindingContext, BindingTrace {
         return autoCasts.get(expression);
     }
 
+    @Override
+    public JetScope getResolutionScope(@NotNull JetExpression expression) {
+        return resolutionScopes.get(expression);
+    }
+
     @Override
     public Collection<JetDiagnostic> getDiagnostics() {
         return diagnostics;

idea/src/org/jetbrains/jet/lang/resolve/ChainedScope.java

 package org.jetbrains.jet.lang.resolve;
 
+import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.types.JetType;
@@ -13,6 +14,7 @@ import java.util.Collections;
 public class ChainedScope implements JetScope {
     private final DeclarationDescriptor containingDeclaration;
     private final JetScope[] scopeChain;
+    private Collection<DeclarationDescriptor> allDescriptors;
 
     public ChainedScope(DeclarationDescriptor containingDeclaration, JetScope... scopes) {
         this.containingDeclaration = containingDeclaration;
@@ -107,4 +109,15 @@ public class ChainedScope implements JetScope {
         }
         return null;
     }
+
+    @Override
+    public Collection<DeclarationDescriptor> getAllDescriptors() {
+        if (allDescriptors == null) {
+            allDescriptors = Sets.newHashSet();
+            for (JetScope scope : scopeChain) {
+                allDescriptors.addAll(scope.getAllDescriptors());
+            }
+        }
+        return allDescriptors;
+    }
 }

idea/src/org/jetbrains/jet/lang/resolve/JetScope.java

@@ -54,4 +54,6 @@ public interface JetScope {
 
     @Nullable
     DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis();
+
+    Collection<DeclarationDescriptor> getAllDescriptors();
 }
\ No newline at end of file

idea/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java

@@ -53,4 +53,9 @@ public abstract class JetScopeImpl implements JetScope {
     public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() {
         return null;
     }
+
+    @Override
+    public Collection<DeclarationDescriptor> getAllDescriptors() {
+        return Collections.emptyList();
+    }
 }

idea/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java

 package org.jetbrains.jet.lang.resolve;
 
+import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -15,6 +16,7 @@ public class SubstitutingScope implements JetScope {
     private final JetScope workerScope;
 //    private final Map<TypeConstructor, TypeProjection> substitutionContext;
     private final TypeSubstitutor substitutor;
+    private Collection<DeclarationDescriptor> allDescriptors;
 
     public SubstitutingScope(JetScope workerScope, @NotNull TypeSubstitutor substitutor) {
         this.workerScope = workerScope;
@@ -86,4 +88,15 @@ public class SubstitutingScope implements JetScope {
     public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() {
         return workerScope.getDeclarationDescriptorForUnqualifiedThis();
     }
+
+    @Override
+    public Collection<DeclarationDescriptor> getAllDescriptors() {
+        if (allDescriptors == null) {
+            allDescriptors = Sets.newHashSet();
+            for (DeclarationDescriptor descriptor : workerScope.getAllDescriptors()) {
+                allDescriptors.add(descriptor.substitute(substitutor));
+            }
+        }
+        return allDescriptors;
+    }
 }

idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java

@@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.resolve;
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.ErrorHandler;
@@ -15,6 +16,8 @@ import java.util.*;
  */
 public class WritableScopeImpl extends WritableScopeWithImports {
 
+    private final Collection<DeclarationDescriptor> allDescriptors = Sets.newHashSet();
+
     @NotNull
     private final DeclarationDescriptor ownerDeclarationDescriptor;
 
@@ -51,6 +54,23 @@ public class WritableScopeImpl extends WritableScopeWithImports {
         return super.getDeclarationDescriptorForUnqualifiedThis();
     }
 
+    @Override
+    public void importScope(@NotNull JetScope imported) {
+        allDescriptors.addAll(imported.getAllDescriptors());
+        super.importScope(imported);
+    }
+
+    @Override
+    public void importClassifierAlias(@NotNull String importedClassifierName, @NotNull ClassifierDescriptor classifierDescriptor) {
+        allDescriptors.add(classifierDescriptor);
+        super.importClassifierAlias(importedClassifierName, classifierDescriptor);
+    }
+
+    @Override
+    public Collection<DeclarationDescriptor> getAllDescriptors() {
+        return allDescriptors;
+    }
+
     @NotNull
     private Map<String, List<DeclarationDescriptor>> getLabelsToDescriptors() {
         if (labelsToDescriptors == null) {
@@ -104,6 +124,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
         }
         // TODO : Should this always happen?
         variableClassOrNamespaceDescriptors.put(variableDescriptor.getName(), variableDescriptor);
+        allDescriptors.add(variableDescriptor);
     }
 
     @Override
@@ -140,6 +161,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
             functionGroups.put(name, functionGroup);
         }
         functionGroup.addFunction(functionDescriptor);
+        allDescriptors.add(functionDescriptor);
     }
 
     @Override
@@ -202,6 +224,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
             errorHandler.redeclaration(originalDescriptor, classifierDescriptor);
         }
         variableClassOrNamespaceDescriptors.put(name, classifierDescriptor);
+        allDescriptors.add(classifierDescriptor);
     }
 
     @Override
@@ -232,6 +255,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
         if (oldValue != null) {
             errorHandler.redeclaration(oldValue, namespaceDescriptor);
         }
+        allDescriptors.add(namespaceDescriptor);
     }
 
     @Override

idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java

 package org.jetbrains.jet.lang.resolve.java;
 
 import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
 import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 import java.util.Collection;
-import java.util.Collections;
 import java.util.Map;
 
 /**
@@ -22,6 +23,7 @@ public class JavaClassMembersScope implements JetScope {
     private final Map<String, FunctionGroup> functionGroups = Maps.newHashMap();
     private final Map<String, VariableDescriptor> variables = Maps.newHashMap();
     private final Map<String, ClassifierDescriptor> classifiers = Maps.newHashMap();
+    private Collection<DeclarationDescriptor> allDescriptors;
 
     public JavaClassMembersScope(@NotNull DeclarationDescriptor classDescriptor, PsiClass psiClass, JavaSemanticServices semanticServices, boolean staticMembers) {
         this.containingDeclaration = classDescriptor;
@@ -62,6 +64,37 @@ public class JavaClassMembersScope implements JetScope {
         return classifierDescriptor;
     }
 
+    @Override
+    public Collection<DeclarationDescriptor> getAllDescriptors() {
+        if (allDescriptors == null) {
+            allDescriptors = Sets.newHashSet();
+            TypeSubstitutor substitutorForGenericSupertypes;
+            if (containingDeclaration instanceof ClassDescriptor) {
+                substitutorForGenericSupertypes = semanticServices.getDescriptorResolver().createSubstitutorForGenericSupertypes((ClassDescriptor) containingDeclaration);
+            }
+            else {
+                substitutorForGenericSupertypes = TypeSubstitutor.EMPTY;
+            }
+
+            for (HierarchicalMethodSignature signature : psiClass.getVisibleSignatures()) {
+                PsiMethod method = signature.getMethod();
+                if (method.hasModifierProperty(PsiModifier.STATIC) != staticMembers) {
+                    continue;
+                }
+                FunctionDescriptor functionDescriptor = semanticServices.getDescriptorResolver().resolveMethodToFunctionDescriptor(psiClass, substitutorForGenericSupertypes, method);
+                if (functionDescriptor != null) {
+                    allDescriptors.add(functionDescriptor);
+                }
+            }
+
+            for (PsiField field : psiClass.getAllFields()) {
+                VariableDescriptor variableDescriptor = semanticServices.getDescriptorResolver().resolveFieldToVariableDescriptor(containingDeclaration, field);
+                allDescriptors.add(variableDescriptor);
+            }
+        }
+        return allDescriptors;
+    }
+
     private ClassifierDescriptor doGetClassifierDescriptor(String name) {
         // TODO : suboptimal, walk the list only once
         for (PsiClass innerClass : psiClass.getAllInnerClasses()) {
@@ -90,19 +123,7 @@ public class JavaClassMembersScope implements JetScope {
             return null;
         }
 
-        JetType type = semanticServices.getTypeTransformer().transformToType(field.getType());
-        boolean isFinal = field.hasModifierProperty(PsiModifier.FINAL);
-        PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
-                containingDeclaration,
-                Collections.<Annotation>emptyList(),
-                new MemberModifiers(false, false, false),
-                !isFinal,
-                null,
-                field.getName(),
-                isFinal ? null : type,
-                type);
-        semanticServices.getTrace().recordDeclarationResolution(field, propertyDescriptor);
-        return propertyDescriptor;
+        return semanticServices.getDescriptorResolver().resolveFieldToVariableDescriptor((ClassDescriptor) containingDeclaration, field);
     }
 
     @NotNull

idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java

@@ -46,6 +46,7 @@ public class JavaDescriptorResolver {
     protected final Map<String, ClassDescriptor> classDescriptorCache = new HashMap<String, ClassDescriptor>();
     protected final Map<PsiTypeParameter, TypeParameterDescriptor> typeParameterDescriptorCache = Maps.newHashMap();
     protected final Map<PsiMethod, FunctionDescriptor> methodDescriptorCache = Maps.newHashMap();
+    protected final Map<PsiField, VariableDescriptor> fieldDescriptorCache = Maps.newHashMap();
     protected final Map<String, NamespaceDescriptor> namespaceDescriptorCache = new HashMap<String, NamespaceDescriptor>();
     protected final JavaPsiFacade javaFacade;
     protected final GlobalSearchScope javaSearchScope;
@@ -262,17 +263,32 @@ public class JavaDescriptorResolver {
         return result;
     }
 
+    public VariableDescriptor resolveFieldToVariableDescriptor(DeclarationDescriptor containingDeclaration, PsiField field) {
+        VariableDescriptor variableDescriptor = fieldDescriptorCache.get(field);
+        if (variableDescriptor != null) {
+            return variableDescriptor;
+        }
+        JetType type = semanticServices.getTypeTransformer().transformToType(field.getType());
+        boolean isFinal = field.hasModifierProperty(PsiModifier.FINAL);
+        PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
+                containingDeclaration,
+                Collections.<Annotation>emptyList(),
+                new MemberModifiers(false, false, false),
+                !isFinal,
+                null,
+                field.getName(),
+                isFinal ? null : type,
+                type);
+        semanticServices.getTrace().recordDeclarationResolution(field, propertyDescriptor);
+        fieldDescriptorCache.put(field, propertyDescriptor);
+        return propertyDescriptor;
+    }
+
     @NotNull
     public FunctionGroup resolveFunctionGroup(@NotNull PsiClass psiClass, @Nullable ClassDescriptor classDescriptor, @NotNull String methodName, boolean staticMembers) {
         WritableFunctionGroup writableFunctionGroup = new WritableFunctionGroup(methodName);
         final Collection<HierarchicalMethodSignature> signatures = psiClass.getVisibleSignatures();
-        TypeSubstitutor typeSubstitutor;
-        if (classDescriptor != null) {
-            typeSubstitutor = TypeUtils.buildDeepSubstitutor(classDescriptor.getDefaultType());
-        }
-        else {
-            typeSubstitutor = TypeSubstitutor.EMPTY;
-        }
+        TypeSubstitutor typeSubstitutor = createSubstitutorForGenericSupertypes(classDescriptor);
         for (HierarchicalMethodSignature signature: signatures) {
             PsiMethod method = signature.getMethod();
             if (method.hasModifierProperty(PsiModifier.STATIC) != staticMembers) {
@@ -281,37 +297,57 @@ public class JavaDescriptorResolver {
             if (!methodName.equals(method.getName())) {
                  continue;
             }
-            FunctionDescriptor functionDescriptor = methodDescriptorCache.get(method);
-            if (functionDescriptor != null) {
-                if (method.getContainingClass() != psiClass) {
-                    functionDescriptor = functionDescriptor.substitute(typeSubstitutor);
-                }
-                writableFunctionGroup.addFunction(functionDescriptor);
-                continue;
-            }
 
-            PsiParameter[] parameters = method.getParameterList().getParameters();
-            FunctionDescriptorImpl functionDescriptorImpl = new FunctionDescriptorImpl(
-                    JavaDescriptorResolver.JAVA_ROOT,
-                    Collections.<Annotation>emptyList(), // TODO
-                    methodName
-            );
-            functionDescriptorImpl.initialize(
-                    null,
-                    resolveTypeParameters(functionDescriptorImpl, method.getTypeParameters()),
-                    semanticServices.getDescriptorResolver().resolveParameterDescriptors(functionDescriptorImpl, parameters),
-                    semanticServices.getTypeTransformer().transformToType(method.getReturnType())
-            );
-            semanticServices.getTrace().recordDeclarationResolution(method, functionDescriptorImpl);
-            FunctionDescriptor substitutedFunctionDescriptor = functionDescriptorImpl;
-            if (method.getContainingClass() != psiClass) {
-                substitutedFunctionDescriptor = functionDescriptorImpl.substitute(typeSubstitutor);
-            }
+            FunctionDescriptor substitutedFunctionDescriptor = resolveMethodToFunctionDescriptor(psiClass, typeSubstitutor, method);
             if (substitutedFunctionDescriptor != null) {
                 writableFunctionGroup.addFunction(substitutedFunctionDescriptor);
             }
-            methodDescriptorCache.put(method, functionDescriptorImpl);
         }
         return writableFunctionGroup;
     }
+
+    public TypeSubstitutor createSubstitutorForGenericSupertypes(ClassDescriptor classDescriptor) {
+        TypeSubstitutor typeSubstitutor;
+        if (classDescriptor != null) {
+            typeSubstitutor = TypeUtils.buildDeepSubstitutor(classDescriptor.getDefaultType());
+        }
+        else {
+            typeSubstitutor = TypeSubstitutor.EMPTY;
+        }
+        return typeSubstitutor;
+    }
+
+    @Nullable
+    public FunctionDescriptor resolveMethodToFunctionDescriptor(PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, PsiMethod method) {
+        PsiType returnType = method.getReturnType();
+        if (returnType == null) {
+            return null;
+        }
+        FunctionDescriptor functionDescriptor = methodDescriptorCache.get(method);
+        if (functionDescriptor != null) {
+            if (method.getContainingClass() != psiClass) {
+                functionDescriptor = functionDescriptor.substitute(typeSubstitutorForGenericSuperclasses);
+            }
+            return functionDescriptor;
+        }
+        PsiParameter[] parameters = method.getParameterList().getParameters();
+        FunctionDescriptorImpl functionDescriptorImpl = new FunctionDescriptorImpl(
+                JavaDescriptorResolver.JAVA_ROOT,
+                Collections.<Annotation>emptyList(), // TODO
+                method.getName()
+        );
+        methodDescriptorCache.put(method, functionDescriptorImpl);
+        functionDescriptorImpl.initialize(
+                null,
+                resolveTypeParameters(functionDescriptorImpl, method.getTypeParameters()),
+                semanticServices.getDescriptorResolver().resolveParameterDescriptors(functionDescriptorImpl, parameters),
+                semanticServices.getTypeTransformer().transformToType(returnType)
+        );
+        semanticServices.getTrace().recordDeclarationResolution(method, functionDescriptorImpl);
+        FunctionDescriptor substitutedFunctionDescriptor = functionDescriptorImpl;
+        if (method.getContainingClass() != psiClass) {
+            substitutedFunctionDescriptor = functionDescriptorImpl.substitute(typeSubstitutorForGenericSuperclasses);
+        }
+        return substitutedFunctionDescriptor;
+    }
 }

idea/src/org/jetbrains/jet/lang/types/ErrorUtils.java

@@ -64,6 +64,11 @@ public class ErrorUtils {
             return ERROR_CLASS; // TODO : review
         }
 
+        @Override
+        public Collection<DeclarationDescriptor> getAllDescriptors() {
+            return Collections.emptyList();
+        }
+
     };
 
     private static final FunctionGroup ERROR_FUNCTION_GROUP = new FunctionGroup() {

idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java

@@ -667,6 +667,7 @@ public class JetTypeInferrer {
             }
 
             trace.markAsProcessed(expression);
+            trace.recordResolutionScope(expression, scope);
             return result;
         }
 

idea/tests/org/jetbrains/jet/JetTestUtils.java

@@ -9,6 +9,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 
 import java.util.Collection;
@@ -52,6 +53,10 @@ public class JetTestUtils {
         public void recordStatement(@NotNull JetElement statement) {
         }
 
+        @Override
+        public void recordResolutionScope(@NotNull JetExpression expression, @NotNull JetScope scope) {
+        }
+
         @Override
         public void removeStatementRecord(@NotNull JetElement statement) {
         }
@@ -189,6 +194,11 @@ public class JetTestUtils {
                     throw new UnsupportedOperationException(); // TODO
                 }
 
+                @Override
+                public JetScope getResolutionScope(@NotNull JetExpression expression) {
+                    throw new UnsupportedOperationException(); // TODO
+                }
+
                 @Override
                 public Collection<JetDiagnostic> getDiagnostics() {
                     throw new UnsupportedOperationException(); // TODO