Add VarianceChecker to TopDownAnalyzer

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForReplWithJava.java

@@ -80,6 +80,7 @@ import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
+import org.jetbrains.jet.lang.resolve.varianceChecker.VarianceChecker;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
@@ -156,6 +157,7 @@ public class InjectorForReplWithJava {
     private final TopDownAnalyzer topDownAnalyzer;
     private final TypeHierarchyResolver typeHierarchyResolver;
     private final ScriptHeaderResolver scriptHeaderResolver;
+    private final VarianceChecker varianceChecker;
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
@@ -240,6 +242,7 @@ public class InjectorForReplWithJava {
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
+        this.varianceChecker = new VarianceChecker(bindingTrace);
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
         this.resolveSession.setDescriptorResolver(descriptorResolver);
@@ -257,6 +260,7 @@ public class InjectorForReplWithJava {
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
         this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
+        this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
 
         javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct);
         javaClassFinder.setProject(project);
@@ -375,6 +379,7 @@ public class InjectorForReplWithJava {
         topDownAnalyzer.setOverrideResolver(overrideResolver);
         topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
         topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
+        topDownAnalyzer.setVarianceChecker(varianceChecker);
 
         typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
         typeHierarchyResolver.setImportsResolver(importsResolver);

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -80,6 +80,7 @@ import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
+import org.jetbrains.jet.lang.resolve.varianceChecker.VarianceChecker;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
@@ -156,6 +157,7 @@ public class InjectorForTopDownAnalyzerForJvm {
     private final TopDownAnalyzer topDownAnalyzer;
     private final TypeHierarchyResolver typeHierarchyResolver;
     private final ScriptHeaderResolver scriptHeaderResolver;
+    private final VarianceChecker varianceChecker;
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
@@ -239,6 +241,7 @@ public class InjectorForTopDownAnalyzerForJvm {
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
+        this.varianceChecker = new VarianceChecker(bindingTrace);
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
         this.resolveSession.setDescriptorResolver(descriptorResolver);
@@ -256,6 +259,7 @@ public class InjectorForTopDownAnalyzerForJvm {
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
         this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
+        this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
 
         javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct);
         javaClassFinder.setProject(project);
@@ -374,6 +378,7 @@ public class InjectorForTopDownAnalyzerForJvm {
         topDownAnalyzer.setOverrideResolver(overrideResolver);
         topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
         topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
+        topDownAnalyzer.setVarianceChecker(varianceChecker);
 
         typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
         typeHierarchyResolver.setImportsResolver(importsResolver);

compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java

@@ -62,6 +62,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
+import org.jetbrains.jet.lang.resolve.varianceChecker.VarianceChecker;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -115,6 +116,7 @@ public class InjectorForLazyBodyResolve {
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final TypeHierarchyResolver typeHierarchyResolver;
     private final ScriptHeaderResolver scriptHeaderResolver;
+    private final VarianceChecker varianceChecker;
 
     public InjectorForLazyBodyResolve(
         @NotNull Project project,
@@ -169,6 +171,7 @@ public class InjectorForLazyBodyResolve {
         this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(moduleDescriptor);
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
+        this.varianceChecker = new VarianceChecker(bindingTrace);
 
         this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
         this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
@@ -178,6 +181,7 @@ public class InjectorForLazyBodyResolve {
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
         this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
+        this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
 
         bodyResolver.setAnnotationResolver(annotationResolver);
         bodyResolver.setCallResolver(callResolver);
@@ -273,6 +277,7 @@ public class InjectorForLazyBodyResolve {
         topDownAnalyzer.setOverrideResolver(overrideResolver);
         topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
         topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
+        topDownAnalyzer.setVarianceChecker(varianceChecker);
 
         typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
         typeHierarchyResolver.setImportsResolver(importsResolver);

compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java

@@ -65,6 +65,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
+import org.jetbrains.jet.lang.resolve.varianceChecker.VarianceChecker;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -121,6 +122,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final TypeHierarchyResolver typeHierarchyResolver;
     private final ScriptHeaderResolver scriptHeaderResolver;
+    private final VarianceChecker varianceChecker;
 
     public InjectorForLazyTopDownAnalyzerBasic(
         @NotNull Project project,
@@ -178,6 +180,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
         this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(module);
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
+        this.varianceChecker = new VarianceChecker(bindingTrace);
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
         this.resolveSession.setDescriptorResolver(descriptorResolver);
@@ -195,6 +198,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
         this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
+        this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
 
         annotationResolver.setCallResolver(callResolver);
         annotationResolver.setStorageManager(storageManager);
@@ -292,6 +296,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
         topDownAnalyzer.setOverrideResolver(overrideResolver);
         topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
         topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
+        topDownAnalyzer.setVarianceChecker(varianceChecker);
 
         typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
         typeHierarchyResolver.setImportsResolver(importsResolver);

compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java

@@ -60,6 +60,7 @@ import org.jetbrains.jet.lang.resolve.OverloadResolver;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
+import org.jetbrains.jet.lang.resolve.varianceChecker.VarianceChecker;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -111,6 +112,7 @@ public class InjectorForTopDownAnalyzerBasic {
     private final OverrideResolver overrideResolver;
     private final TypeHierarchyResolver typeHierarchyResolver;
     private final ScriptHeaderResolver scriptHeaderResolver;
+    private final VarianceChecker varianceChecker;
 
     public InjectorForTopDownAnalyzerBasic(
         @NotNull Project project,
@@ -164,6 +166,7 @@ public class InjectorForTopDownAnalyzerBasic {
         this.overrideResolver = new OverrideResolver();
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
+        this.varianceChecker = new VarianceChecker(bindingTrace);
 
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
@@ -172,6 +175,7 @@ public class InjectorForTopDownAnalyzerBasic {
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
         this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
+        this.topDownAnalyzer.setVarianceChecker(varianceChecker);
 
         bodyResolver.setAnnotationResolver(annotationResolver);
         bodyResolver.setCallResolver(callResolver);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java

@@ -32,6 +32,7 @@ import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.resolve.lazy.LazyImportScope;
 import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.varianceChecker.VarianceChecker;
 
 import javax.inject.Inject;
 import java.util.ArrayList;
@@ -59,6 +60,10 @@ public class LazyTopDownAnalyzer {
     @NotNull
     private OverloadResolver overloadResolver = null;
 
+    @SuppressWarnings("ConstantConditions")
+    @NotNull
+    private VarianceChecker varianceChecker = null;
+
     @SuppressWarnings("ConstantConditions")
     @NotNull
     private ModuleDescriptor moduleDescriptor = null;
@@ -95,6 +100,11 @@ public class LazyTopDownAnalyzer {
         this.overrideResolver = overrideResolver;
     }
 
+    @Inject
+    public void setVarianceChecker(@NotNull VarianceChecker varianceChecker) {
+        this.varianceChecker = varianceChecker;
+    }
+
     @Inject
     public void setOverloadResolver(@NotNull OverloadResolver overloadResolver) {
         this.overloadResolver = overloadResolver;
@@ -309,6 +319,8 @@ public class LazyTopDownAnalyzer {
 
         overrideResolver.check(c);
 
+        varianceChecker.check(c);
+
         resolveImportsInAllFiles(c, resolveSession);
 
         declarationResolver.resolveAnnotationsOnFiles(c, resolveSession.getScopeProvider());

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java

@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.lang.resolve.varianceChecker.VarianceChecker;
 
 import javax.inject.Inject;
 import java.util.Arrays;
@@ -47,6 +48,9 @@ public class TopDownAnalyzer {
     @SuppressWarnings("NullableProblems") @NotNull
     private OverrideResolver overrideResolver;
 
+    @SuppressWarnings("NullableProblems") @NotNull
+    private VarianceChecker varianceChecker;
+
     @SuppressWarnings("NullableProblems") @NotNull
     private OverloadResolver overloadResolver;
 
@@ -77,6 +81,11 @@ public class TopDownAnalyzer {
         this.overrideResolver = overrideResolver;
     }
 
+    @Inject
+    public void setVarianceChecker(@NotNull VarianceChecker varianceChecker) {
+        this.varianceChecker = varianceChecker;
+    }
+
     @Inject
     public void setOverloadResolver(@NotNull OverloadResolver overloadResolver) {
         this.overloadResolver = overloadResolver;
@@ -109,6 +118,7 @@ public class TopDownAnalyzer {
         typeHierarchyResolver.process(c, outerScope, owner, declarations);
         declarationResolver.process(c);
         overrideResolver.process(c);
+        varianceChecker.process(c);
         lockScopes(c);
 
         overloadResolver.process(c);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.kt

@@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.FAKE_OVE
 import org.jetbrains.jet.lang.resolve.DelegationResolver.generateDelegatedMembers
 import org.jetbrains.jet.storage.NotNullLazyValue
 import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.jet.lang.resolve.varianceChecker.VarianceChecker
 
 public open class LazyClassMemberScope(resolveSession: ResolveSession,
                                   declarationProvider: ClassMemberDeclarationProvider,
@@ -184,6 +185,7 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession,
             if (descriptor.getKind() != FAKE_OVERRIDE && descriptor.getKind() != DELEGATION) {
                 OverridingUtil.resolveUnknownVisibilityForMember(descriptor, OverrideResolver.createCannotInferVisibilityReporter(trace))
             }
+//            VarianceChecker.recordPrivateToThisIfNeeded(trace, descriptor); todo make visibility lazy and enable
         }
     }
 

js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java

@@ -65,6 +65,7 @@ import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
+import org.jetbrains.jet.lang.resolve.varianceChecker.VarianceChecker;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -121,6 +122,7 @@ public class InjectorForTopDownAnalyzerForJs {
     private final TopDownAnalyzer topDownAnalyzer;
     private final TypeHierarchyResolver typeHierarchyResolver;
     private final ScriptHeaderResolver scriptHeaderResolver;
+    private final VarianceChecker varianceChecker;
 
     public InjectorForTopDownAnalyzerForJs(
         @NotNull Project project,
@@ -178,6 +180,7 @@ public class InjectorForTopDownAnalyzerForJs {
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
+        this.varianceChecker = new VarianceChecker(bindingTrace);
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
         this.resolveSession.setDescriptorResolver(descriptorResolver);
@@ -195,6 +198,7 @@ public class InjectorForTopDownAnalyzerForJs {
         this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
         this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
+        this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
 
         annotationResolver.setCallResolver(callResolver);
         annotationResolver.setStorageManager(storageManager);
@@ -292,6 +296,7 @@ public class InjectorForTopDownAnalyzerForJs {
         topDownAnalyzer.setOverrideResolver(overrideResolver);
         topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
         topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
+        topDownAnalyzer.setVarianceChecker(varianceChecker);
 
         typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
         typeHierarchyResolver.setImportsResolver(importsResolver);