Remove big chunk of code related to using old annotations

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

@@ -28,8 +28,6 @@ import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
@@ -37,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolv
 import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer;
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver;
@@ -58,8 +57,6 @@ public class InjectorForJavaDescriptorResolver {
     private final JavaClassResolver javaClassResolver;
     private final JavaAnnotationResolver javaAnnotationResolver;
     private final JavaCompileTimeConstResolver javaCompileTimeConstResolver;
-    private final JavaClassObjectResolver javaClassObjectResolver;
-    private final JavaSupertypeResolver javaSupertypeResolver;
     private final JavaFunctionResolver javaFunctionResolver;
     private final JavaValueParameterResolver javaValueParameterResolver;
     private final JavaSignatureResolver javaSignatureResolver;
@@ -67,6 +64,7 @@ public class InjectorForJavaDescriptorResolver {
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     private final ErrorReporter errorReporter;
     private final JavaNamespaceResolver javaNamespaceResolver;
+    private final JavaSupertypeResolver javaSupertypeResolver;
     private final JavaConstructorResolver javaConstructorResolver;
     private final JavaInnerClassResolver javaInnerClassResolver;
     private final JavaPropertyResolver javaPropertyResolver;
@@ -88,8 +86,6 @@ public class InjectorForJavaDescriptorResolver {
         this.javaClassResolver = new JavaClassResolver();
         this.javaAnnotationResolver = new JavaAnnotationResolver();
         this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
-        this.javaClassObjectResolver = new JavaClassObjectResolver();
-        this.javaSupertypeResolver = new JavaSupertypeResolver();
         this.javaFunctionResolver = new JavaFunctionResolver();
         this.javaValueParameterResolver = new JavaValueParameterResolver();
         this.javaSignatureResolver = new JavaSignatureResolver();
@@ -97,6 +93,7 @@ public class InjectorForJavaDescriptorResolver {
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
         this.errorReporter = new ErrorReporter();
         this.javaNamespaceResolver = new JavaNamespaceResolver();
+        this.javaSupertypeResolver = new JavaSupertypeResolver();
         this.javaConstructorResolver = new JavaConstructorResolver();
         this.javaInnerClassResolver = new JavaInnerClassResolver();
         this.javaPropertyResolver = new JavaPropertyResolver();
@@ -122,7 +119,6 @@ public class InjectorForJavaDescriptorResolver {
         javaTypeTransformer.setResolver(javaDescriptorResolver);
 
         javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
         javaClassResolver.setFunctionResolver(javaFunctionResolver);
         javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
         javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
@@ -138,15 +134,6 @@ public class InjectorForJavaDescriptorResolver {
         javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
         javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
 
-        javaClassObjectResolver.setSemanticServices(javaSemanticServices);
-        javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver);
-        javaClassObjectResolver.setTrace(bindingTrace);
-
-        javaSupertypeResolver.setClassResolver(javaClassResolver);
-        javaSupertypeResolver.setSemanticServices(javaSemanticServices);
-        javaSupertypeResolver.setTrace(bindingTrace);
-        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
-
         javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
         javaFunctionResolver.setParameterResolver(javaValueParameterResolver);
         javaFunctionResolver.setSignatureResolver(javaSignatureResolver);
@@ -172,6 +159,10 @@ public class InjectorForJavaDescriptorResolver {
         javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
         javaNamespaceResolver.setTrace(bindingTrace);
 
+        javaSupertypeResolver.setClassResolver(javaClassResolver);
+        javaSupertypeResolver.setTrace(bindingTrace);
+        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
+
         javaConstructorResolver.setTrace(bindingTrace);
         javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
         javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);

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

@@ -28,8 +28,6 @@ import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
@@ -37,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolv
 import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer;
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver;
@@ -58,8 +57,6 @@ public class InjectorForJavaSemanticServices {
     private final JavaClassResolver javaClassResolver;
     private final JavaAnnotationResolver javaAnnotationResolver;
     private final JavaCompileTimeConstResolver javaCompileTimeConstResolver;
-    private final JavaClassObjectResolver javaClassObjectResolver;
-    private final JavaSupertypeResolver javaSupertypeResolver;
     private final JavaFunctionResolver javaFunctionResolver;
     private final JavaValueParameterResolver javaValueParameterResolver;
     private final JavaSignatureResolver javaSignatureResolver;
@@ -67,6 +64,7 @@ public class InjectorForJavaSemanticServices {
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     private final ErrorReporter errorReporter;
     private final JavaNamespaceResolver javaNamespaceResolver;
+    private final JavaSupertypeResolver javaSupertypeResolver;
     private final JavaConstructorResolver javaConstructorResolver;
     private final JavaInnerClassResolver javaInnerClassResolver;
     private final JavaPropertyResolver javaPropertyResolver;
@@ -86,8 +84,6 @@ public class InjectorForJavaSemanticServices {
         this.javaClassResolver = new JavaClassResolver();
         this.javaAnnotationResolver = new JavaAnnotationResolver();
         this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
-        this.javaClassObjectResolver = new JavaClassObjectResolver();
-        this.javaSupertypeResolver = new JavaSupertypeResolver();
         this.javaFunctionResolver = new JavaFunctionResolver();
         this.javaValueParameterResolver = new JavaValueParameterResolver();
         this.javaSignatureResolver = new JavaSignatureResolver();
@@ -95,6 +91,7 @@ public class InjectorForJavaSemanticServices {
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
         this.errorReporter = new ErrorReporter();
         this.javaNamespaceResolver = new JavaNamespaceResolver();
+        this.javaSupertypeResolver = new JavaSupertypeResolver();
         this.javaConstructorResolver = new JavaConstructorResolver();
         this.javaInnerClassResolver = new JavaInnerClassResolver();
         this.javaPropertyResolver = new JavaPropertyResolver();
@@ -122,7 +119,6 @@ public class InjectorForJavaSemanticServices {
         javaTypeTransformer.setResolver(javaDescriptorResolver);
 
         javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
         javaClassResolver.setFunctionResolver(javaFunctionResolver);
         javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
         javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
@@ -138,15 +134,6 @@ public class InjectorForJavaSemanticServices {
         javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
         javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
 
-        javaClassObjectResolver.setSemanticServices(javaSemanticServices);
-        javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver);
-        javaClassObjectResolver.setTrace(bindingTrace);
-
-        javaSupertypeResolver.setClassResolver(javaClassResolver);
-        javaSupertypeResolver.setSemanticServices(javaSemanticServices);
-        javaSupertypeResolver.setTrace(bindingTrace);
-        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
-
         javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
         javaFunctionResolver.setParameterResolver(javaValueParameterResolver);
         javaFunctionResolver.setSignatureResolver(javaSignatureResolver);
@@ -172,6 +159,10 @@ public class InjectorForJavaSemanticServices {
         javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
         javaNamespaceResolver.setTrace(bindingTrace);
 
+        javaSupertypeResolver.setClassResolver(javaClassResolver);
+        javaSupertypeResolver.setTrace(bindingTrace);
+        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
+
         javaConstructorResolver.setTrace(bindingTrace);
         javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
         javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);

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

@@ -53,8 +53,6 @@ import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
@@ -62,6 +60,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolv
 import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer;
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver;
@@ -108,8 +107,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final JavaClassResolver javaClassResolver;
     private final JavaAnnotationResolver javaAnnotationResolver;
     private final JavaCompileTimeConstResolver javaCompileTimeConstResolver;
-    private final JavaClassObjectResolver javaClassObjectResolver;
-    private final JavaSupertypeResolver javaSupertypeResolver;
     private final JavaFunctionResolver javaFunctionResolver;
     private final JavaValueParameterResolver javaValueParameterResolver;
     private final JavaSignatureResolver javaSignatureResolver;
@@ -117,6 +114,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     private final ErrorReporter errorReporter;
     private final JavaNamespaceResolver javaNamespaceResolver;
+    private final JavaSupertypeResolver javaSupertypeResolver;
     private final JavaConstructorResolver javaConstructorResolver;
     private final JavaInnerClassResolver javaInnerClassResolver;
     private final JavaPropertyResolver javaPropertyResolver;
@@ -164,8 +162,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.javaClassResolver = new JavaClassResolver();
         this.javaAnnotationResolver = new JavaAnnotationResolver();
         this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
-        this.javaClassObjectResolver = new JavaClassObjectResolver();
-        this.javaSupertypeResolver = new JavaSupertypeResolver();
         this.javaFunctionResolver = new JavaFunctionResolver();
         this.javaValueParameterResolver = new JavaValueParameterResolver();
         this.javaSignatureResolver = new JavaSignatureResolver();
@@ -173,6 +169,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
         this.errorReporter = new ErrorReporter();
         this.javaNamespaceResolver = new JavaNamespaceResolver();
+        this.javaSupertypeResolver = new JavaSupertypeResolver();
         this.javaConstructorResolver = new JavaConstructorResolver();
         this.javaInnerClassResolver = new JavaInnerClassResolver();
         this.javaPropertyResolver = new JavaPropertyResolver();
@@ -300,7 +297,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaTypeTransformer.setResolver(javaDescriptorResolver);
 
         javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
         javaClassResolver.setFunctionResolver(javaFunctionResolver);
         javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
         javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
@@ -316,15 +312,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
         javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
 
-        javaClassObjectResolver.setSemanticServices(javaSemanticServices);
-        javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver);
-        javaClassObjectResolver.setTrace(bindingTrace);
-
-        javaSupertypeResolver.setClassResolver(javaClassResolver);
-        javaSupertypeResolver.setSemanticServices(javaSemanticServices);
-        javaSupertypeResolver.setTrace(bindingTrace);
-        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
-
         javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
         javaFunctionResolver.setParameterResolver(javaValueParameterResolver);
         javaFunctionResolver.setSignatureResolver(javaSignatureResolver);
@@ -350,6 +337,10 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
         javaNamespaceResolver.setTrace(bindingTrace);
 
+        javaSupertypeResolver.setClassResolver(javaClassResolver);
+        javaSupertypeResolver.setTrace(bindingTrace);
+        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
+
         javaConstructorResolver.setTrace(bindingTrace);
         javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
         javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);

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

@@ -23,9 +23,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.constants.StringValue;
-import org.jetbrains.jet.lang.resolve.java.kt.PsiAnnotationWithFlags;
-import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMemberWrapper;
-import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -63,36 +60,9 @@ public final class DescriptorResolverUtils {
         return Collections.emptyList();
     }
 
-    public static Modality resolveModality(PsiMemberWrapper memberWrapper, boolean isFinal) {
-        if (memberWrapper instanceof PsiMethodWrapper) {
-            PsiMethodWrapper method = (PsiMethodWrapper) memberWrapper;
-            if (method.getJetMethodAnnotation().hasForceOpenFlag()) {
-                return Modality.OPEN;
-            }
-            if (method.getJetMethodAnnotation().hasForceFinalFlag()) {
-                return Modality.FINAL;
-            }
-        }
-
-        return Modality.convertFromFlags(memberWrapper.isAbstract(), !isFinal);
-    }
-
     public static Visibility resolveVisibility(
-            @NotNull PsiModifierListOwner modifierListOwner,
+            @NotNull PsiModifierListOwner modifierListOwner
-            @Nullable PsiAnnotationWithFlags annotation
     ) {
-        if (annotation != null) {
-            if (annotation.hasPrivateFlag()) {
-                return Visibilities.PRIVATE;
-            }
-            else if (annotation.hasInternalFlag()) {
-                return Visibilities.INTERNAL;
-            }
-            else if (annotation.hasProtectedFlag()) {
-                return Visibilities.PROTECTED;
-            }
-        }
-
         if (modifierListOwner.hasModifierProperty(PsiModifier.PUBLIC)) {
             return Visibilities.PUBLIC;
         }
@@ -159,7 +129,7 @@ public final class DescriptorResolverUtils {
 
     /**
      * @return true if {@code member} is a static member of enum class, which is to be put into its class object (and not into the
-     * corresponding package). This applies to enum entries, values() and valueOf(String) methods
+     *         corresponding package). This applies to enum entries, values() and valueOf(String) methods
      */
     public static boolean shouldBeInEnumClassObject(@NotNull PsiMember member) {
         PsiClass psiClass = member.getContainingClass();
@@ -169,7 +139,7 @@ public final class DescriptorResolverUtils {
 
         if (!(member instanceof PsiMethod)) return false;
         String signature = PsiFormatUtil.formatMethod((PsiMethod) member,
-                PsiSubstitutor.EMPTY, SHOW_NAME | SHOW_PARAMETERS, SHOW_TYPE | SHOW_FQ_CLASS_NAMES);
+                                                      PsiSubstitutor.EMPTY, SHOW_NAME | SHOW_PARAMETERS, SHOW_TYPE | SHOW_FQ_CLASS_NAMES);
 
         return "values()".equals(signature) ||
                "valueOf(java.lang.String)".equals(signature);

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

@@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve.java;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.java.kt.JetPackageClassAnnotation;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -40,7 +39,8 @@ public class PackageClassUtils {
     }
 
     public static boolean isPackageClass(@NotNull PsiClass psiClass) {
-        return JetPackageClassAnnotation.get(psiClass).isDefined();
+        //TODO: read kotlin info
+        return psiClass.getName().endsWith("Package");
     }
 
     public static boolean isPackageClass(@NotNull FqName fqName) {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java

@@ -25,11 +25,8 @@ import com.intellij.psi.impl.PsiSubstitutorImpl;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
-import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils;
-import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.JetTypeImpl;
@@ -71,7 +68,7 @@ class PropagationHeuristics {
                     JetType elementType = type.getArguments().get(0).getType();
 
                     if (JetTypeChecker.INSTANCE.isSubtypeOf(elementType, elementTypeInSuper)
-                            && !JetTypeChecker.INSTANCE.equalTypes(elementType, elementTypeInSuper)) {
+                        && !JetTypeChecker.INSTANCE.equalTypes(elementType, elementTypeInSuper)) {
                         JetTypeImpl betterTypeInSuper = new JetTypeImpl(
                                 arrayTypeFromSuper.getAnnotations(),
                                 arrayTypeFromSuper.getConstructor(),
@@ -127,21 +124,7 @@ class PropagationHeuristics {
 
     @NotNull
     static List<PsiMethod> getSuperMethods(@NotNull PsiMethod method) {
-        List<PsiMethod> superMethods = Lists.newArrayList();
+        return new SuperMethodCollector(method).collect();
-        for (PsiMethod superMethod : new SuperMethodCollector(method).collect()) {
-            CallableMemberDescriptor.Kind kindFromFlags =
-                    DescriptorKindUtils.flagsToKind(new PsiMethodWrapper(superMethod).getJetMethodAnnotation().kind());
-            if (kindFromFlags == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
-                // This is for the case when a Kotlin class inherits a non-abstract method from a trait:
-                // from Kotlin's point of view it is fake override, from Java's it is normal override.
-                // We replace this "fake override" method with original method from the trait.
-                superMethods.addAll(getSuperMethods(superMethod));
-            }
-            else {
-                superMethods.add(superMethod);
-            }
-        }
-        return superMethods;
     }
 
     private PropagationHeuristics() {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassObjectAnnotation.java

@@ -1,44 +0,0 @@
-/*
- * Copyright 2010-2013 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.kt;
-
-import com.intellij.psi.PsiAnnotation;
-import com.intellij.psi.PsiClass;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
-
-public class JetClassObjectAnnotation extends PsiAnnotationWithAbiVersion {
-
-    private static final JetClassObjectAnnotation NULL_ANNOTATION = new JetClassObjectAnnotation(null);
-
-    static {
-        NULL_ANNOTATION.checkInitialized();
-    }
-
-    private JetClassObjectAnnotation(@Nullable PsiAnnotation psiAnnotation) {
-        super(psiAnnotation);
-    }
-
-    @NotNull
-    public static JetClassObjectAnnotation get(@NotNull PsiClass psiClass) {
-        PsiAnnotation annotation =
-                JavaAnnotationResolver.findOwnAnnotation(psiClass, JvmStdlibNames.JET_CLASS_OBJECT.getFqName().asString());
-        return annotation != null ? new JetClassObjectAnnotation(annotation) : NULL_ANNOTATION;
-    }
-}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetConstructorAnnotation.java

@@ -1,54 +0,0 @@
-/*
- * Copyright 2010-2013 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.kt;
-
-import com.intellij.psi.PsiAnnotation;
-import com.intellij.psi.PsiMethod;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
-
-public class JetConstructorAnnotation extends PsiAnnotationWithFlags {
-    private static final JetConstructorAnnotation NULL_ANNOTATION = new JetConstructorAnnotation(null);
-    static {
-        NULL_ANNOTATION.checkInitialized();
-    }
-
-    private JetConstructorAnnotation(@Nullable PsiAnnotation psiAnnotation) {
-        super(psiAnnotation);
-    }
-
-    @Override
-    protected void initialize() {
-        super.initialize();
-        hidden = getBooleanAttribute(JvmStdlibNames.JET_CONSTRUCTOR_HIDDEN_FIELD, false);
-    }
-
-    private boolean hidden;
-
-    /** @deprecated */
-    public boolean hidden() {
-        checkInitialized();
-        return hidden;
-    }
-
-    public static JetConstructorAnnotation get(PsiMethod constructor) {
-        PsiAnnotation annotation =
-                JavaAnnotationResolver.findOwnAnnotation(constructor, JvmStdlibNames.JET_CONSTRUCTOR.getFqName().asString());
-        return annotation != null ? new JetConstructorAnnotation(annotation) : NULL_ANNOTATION;
-    }
-}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetMethodAnnotation.java

@@ -1,75 +0,0 @@
-/*
- * Copyright 2010-2013 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.kt;
-
-import com.intellij.psi.PsiAnnotation;
-import com.intellij.psi.PsiMethod;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
-
-public class JetMethodAnnotation extends PsiAnnotationWithFlags {
-    private static final JetMethodAnnotation NULL_ANNOTATION = new JetMethodAnnotation(null);
-    static {
-        NULL_ANNOTATION.checkInitialized();
-    }
-
-    private String typeParameters;
-    private String returnType;
-    private String propertyType;
-
-    private JetMethodAnnotation(@Nullable PsiAnnotation psiAnnotation) {
-        super(psiAnnotation);
-    }
-
-    @Override
-    protected void initialize() {
-        super.initialize();
-        typeParameters = getStringAttribute(JvmStdlibNames.JET_METHOD_TYPE_PARAMETERS_FIELD, "");
-        returnType = getStringAttribute(JvmStdlibNames.JET_METHOD_RETURN_TYPE_FIELD, "");
-        propertyType = getStringAttribute(JvmStdlibNames.JET_METHOD_PROPERTY_TYPE_FIELD, "");
-    }
-
-    public int kind() {
-        return flags() & JvmStdlibNames.FLAG_METHOD_KIND_MASK;
-    }
-
-    @NotNull
-    public String typeParameters() {
-        checkInitialized();
-        return typeParameters;
-    }
-
-    @NotNull
-    public String returnType() {
-        checkInitialized();
-        return returnType;
-    }
-
-    @NotNull
-    public String propertyType() {
-        checkInitialized();
-        return propertyType;
-    }
-
-    public static JetMethodAnnotation get(PsiMethod psiMethod) {
-        PsiAnnotation annotation =
-                JavaAnnotationResolver.findOwnAnnotation(psiMethod, JvmStdlibNames.JET_METHOD.getFqName().asString());
-        return annotation != null ? new JetMethodAnnotation(annotation) : NULL_ANNOTATION;
-    }
-}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetPackageClassAnnotation.java

@@ -1,42 +0,0 @@
-/*
- * Copyright 2010-2013 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.kt;
-
-import com.intellij.psi.PsiAnnotation;
-import com.intellij.psi.PsiClass;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
-
-public class JetPackageClassAnnotation extends PsiAnnotationWithAbiVersion {
-    private static final JetPackageClassAnnotation NULL_ANNOTATION = new JetPackageClassAnnotation(null);
-    static {
-        NULL_ANNOTATION.checkInitialized();
-    }
-
-    private JetPackageClassAnnotation(@Nullable PsiAnnotation psiAnnotation) {
-        super(psiAnnotation);
-    }
-
-    @NotNull
-    public static JetPackageClassAnnotation get(PsiClass psiClass) {
-        PsiAnnotation annotation = JavaAnnotationResolver.findOwnAnnotation(psiClass,
-                                                                                  JvmStdlibNames.JET_PACKAGE_CLASS.getFqName().asString());
-        return annotation != null ? new JetPackageClassAnnotation(annotation) : NULL_ANNOTATION;
-    }
-}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetTypeParameterAnnotation.java

@@ -1,46 +0,0 @@
-/*
- * Copyright 2010-2013 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.kt;
-
-import com.intellij.psi.PsiAnnotation;
-import com.intellij.psi.PsiParameter;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
-
-public class JetTypeParameterAnnotation extends PsiAnnotationWrapper {
-    private static final JetTypeParameterAnnotation NULL_ANNOTATION = new JetTypeParameterAnnotation(null);
-    static {
-        NULL_ANNOTATION.checkInitialized();
-    }
-
-    private JetTypeParameterAnnotation(@Nullable PsiAnnotation psiAnnotation) {
-        super(psiAnnotation);
-    }
-
-    @Override
-    protected void initialize() {
-    }
-
-    @NotNull
-    public static JetTypeParameterAnnotation get(@NotNull PsiParameter psiParameter) {
-        PsiAnnotation annotation =
-                JavaAnnotationResolver.findOwnAnnotation(psiParameter, JvmStdlibNames.JET_TYPE_PARAMETER.getFqName().asString());
-        return annotation != null ? new JetTypeParameterAnnotation(annotation) : NULL_ANNOTATION;
-    }
-}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 
 public class JetValueParameterAnnotation extends PsiAnnotationWrapper {
     private static final JetValueParameterAnnotation NULL_ANNOTATION = new JetValueParameterAnnotation(null);
+
     static {
         NULL_ANNOTATION.checkInitialized();
     }
@@ -32,7 +33,6 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper {
     private String name;
     private String type;
     private boolean receiver;
-    private boolean hasDefaultValue;
     private boolean vararg;
 
     private JetValueParameterAnnotation(@Nullable PsiAnnotation psiAnnotation) {
@@ -44,7 +44,6 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper {
         name = getStringAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_NAME_FIELD, "");
         type = getStringAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_TYPE_FIELD, "");
         receiver = getBooleanAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_RECEIVER_FIELD, false);
-        hasDefaultValue = getBooleanAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_HAS_DEFAULT_VALUE_FIELD, false);
         vararg = getBooleanAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_VARARG, false);
     }
 
@@ -64,11 +63,6 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper {
         checkInitialized();
         return receiver;
     }
-    
-    public boolean hasDefaultValue() {
-        checkInitialized();
-        return hasDefaultValue;
-    }
 
     public boolean vararg() {
         checkInitialized();

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/PsiAnnotationWithFlags.java

@@ -36,28 +36,4 @@ public abstract class PsiAnnotationWithFlags extends PsiAnnotationWrapper {
         checkInitialized();
         return flags;
     }
-
-    public final boolean hasPropertyFlag() {
-        return (flags() & JvmStdlibNames.FLAG_PROPERTY_BIT) != 0;
-    }
-
-    public final boolean hasForceFinalFlag() {
-        return (flags() & JvmStdlibNames.FLAG_FORCE_FINAL_BIT) != 0;
-    }
-
-    public final boolean hasForceOpenFlag() {
-        return (flags() & JvmStdlibNames.FLAG_FORCE_OPEN_BIT) != 0;
-    }
-
-    public final boolean hasInternalFlag() {
-        return (flags() & JvmStdlibNames.FLAG_INTERNAL_BIT) != 0;
-    }
-
-    public final boolean hasProtectedFlag() {
-        return (flags() & JvmStdlibNames.FLAG_PROTECTED_BIT) != 0;
-    }
-
-    public final boolean hasPrivateFlag() {
-        return (flags() & JvmStdlibNames.FLAG_PRIVATE_BIT) != 0;
-    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/ClassPsiDeclarationProviderImpl.java

@@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve.java.provider;
 import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 
 import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.JAVA;
@@ -47,7 +46,8 @@ public class ClassPsiDeclarationProviderImpl extends PsiDeclarationProviderBase
     @Override
     @NotNull
     protected MembersCache buildMembersCache() {
-        return MembersCache.buildMembersByNameCache(new MembersCache(), psiClassFinder, psiClass, null, staticMembers, getDeclarationOrigin() == KOTLIN);
+        return MembersCache.buildMembersByNameCache(new MembersCache(), psiClassFinder, psiClass, null, staticMembers,
+                                                    getDeclarationOrigin() == KOTLIN);
     }
 
     @Override
@@ -64,7 +64,7 @@ public class ClassPsiDeclarationProviderImpl extends PsiDeclarationProviderBase
 
     @NotNull
     private static DeclarationOrigin determineOrigin(@Nullable PsiClass psiClass) {
-        return ((psiClass != null) && DescriptorResolverUtils.isKotlinClass(psiClass)) ? KOTLIN : JAVA;
+        return JAVA;
     }
 
     @Override

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/KotlinNamespacePsiDeclarationProvider.java

@@ -1,58 +0,0 @@
-/*
- * Copyright 2010-2013 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.provider;
-
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiPackage;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
-
-import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOTLIN;
-
-public final class KotlinNamespacePsiDeclarationProvider extends ClassPsiDeclarationProviderImpl implements PackagePsiDeclarationProvider {
-    @NotNull
-    private final PsiPackage psiPackage;
-
-    public KotlinNamespacePsiDeclarationProvider(
-            @NotNull PsiPackage psiPackage,
-            @NotNull PsiClass psiClass,
-            @NotNull PsiClassFinder psiClassFinder
-    ) {
-        super(psiClass, true, psiClassFinder);
-        this.psiPackage = psiPackage;
-    }
-
-    @NotNull
-    @Override
-    public PsiPackage getPsiPackage() {
-        return psiPackage;
-    }
-
-    @NotNull
-    @Override
-    protected MembersCache buildMembersCache() {
-        MembersCache cacheWithMembers = super.buildMembersCache();
-        MembersCache.buildMembersByNameCache(cacheWithMembers, psiClassFinder, null, psiPackage, true, getDeclarationOrigin() == KOTLIN);
-        return cacheWithMembers;
-    }
-
-    @NotNull
-    @Override
-    public DeclarationOrigin getDeclarationOrigin() {
-        return KOTLIN;
-    }
-}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java

@@ -19,16 +19,15 @@ package org.jetbrains.jet.lang.resolve.java.provider;
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Multimap;
-import com.intellij.openapi.util.Ref;
 import com.intellij.psi.*;
-import com.intellij.psi.util.MethodSignature;
 import com.intellij.psi.util.MethodSignatureBackedByPsiMethod;
 import com.intellij.psi.util.PsiFormatUtil;
 import com.intellij.util.ArrayUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.java.*;
+import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker;
-import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
+import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
+import org.jetbrains.jet.lang.resolve.java.TypeSource;
 import org.jetbrains.jet.lang.resolve.java.prop.PropertyNameUtils;
 import org.jetbrains.jet.lang.resolve.java.prop.PropertyParseResult;
 import org.jetbrains.jet.lang.resolve.java.wrapper.*;
@@ -129,9 +128,6 @@ public final class MembersCache {
         private void process() {
             for (PsiClass psiClass : psiClasses) {
                 if (!(psiClass instanceof JetJavaMirrorMarker)) { // to filter out JetLightClasses
-                    if (JetClassAnnotation.get(psiClass).kind() == JvmStdlibNames.FLAG_CLASS_KIND_OBJECT) {
-                        processObjectClass(psiClass);
-                    }
                     if (isSamInterface(psiClass)) {
                         processSamInterface(psiClass);
                     }
@@ -139,16 +135,6 @@ public final class MembersCache {
             }
         }
 
-        private void processObjectClass(@NotNull PsiClass psiClass) {
-            PsiField instanceField = psiClass.findFieldByName(JvmAbi.INSTANCE_FIELD, false);
-            if (instanceField != null) {
-                NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(psiClass.getName()));
-
-                TypeSource type = new TypeSource("", instanceField.getType(), instanceField);
-                namedMembers.addPropertyAccessor(new PropertyPsiDataElement(new PsiFieldWrapper(instanceField), type, null));
-            }
-        }
-
         private void processSamInterface(@NotNull PsiClass psiClass) {
             NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(psiClass.getName()));
             namedMembers.setSamInterface(psiClass);
@@ -248,9 +234,7 @@ public final class MembersCache {
                 return false;
             }
 
-            //process private accessors
+            if (member.isPrivate()) {
-            if (member.isPrivate()
-                && !(member instanceof PsiMethodWrapper && ((PsiMethodWrapper)member).getJetMethodAnnotation().hasPropertyFlag())) {
                 return false;
             }
 
@@ -288,90 +272,25 @@ public final class MembersCache {
             if (propertyParseResult != null && propertyParseResult.isGetter()) {
                 processGetter(ownMethod, method, propertyParseResult);
             }
-            else if (propertyParseResult != null && !propertyParseResult.isGetter()) {
+            else if (propertyParseResult != null) {
                 processSetter(method, propertyParseResult);
             }
 
-            if (!method.getJetMethodAnnotation().hasPropertyFlag()) {
+            NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(method.getName()));
-                NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(method.getName()));
+            namedMembers.addMethod(method);
-                namedMembers.addMethod(method);
-            }
         }
 
+        //TODO: manually!!!!
         private void processSetter(PsiMethodWrapper method, PropertyParseResult propertyParseResult) {
+            //TODO
             String propertyName = propertyParseResult.getPropertyName();
-            NamedMembers members = getOrCreateEmpty(Name.identifier(propertyName));
+            getOrCreateEmpty(Name.identifier(propertyName));
-
-            if (method.getJetMethodAnnotation().hasPropertyFlag()) {
-                if (method.getParameters().size() == 0) {
-                    // TODO: report error properly
-                    throw new IllegalStateException();
-                }
-
-                int i = 0;
-
-                TypeSource receiverType = null;
-                PsiParameterWrapper p1 = method.getParameter(0);
-                if (p1.getJetValueParameter().receiver()) {
-                    receiverType = new TypeSource(p1.getJetValueParameter().type(), p1.getPsiParameter().getType(), p1.getPsiParameter());
-                    ++i;
-                }
-
-                while (i < method.getParameters().size() && method.getParameter(i).getJetTypeParameter().isDefined()) {
-                    ++i;
-                }
-
-                if (i + 1 != method.getParameters().size()) {
-                    throw new IllegalStateException();
-                }
-
-                PsiParameterWrapper propertyTypeParameter = method.getParameter(i);
-                TypeSource propertyType =
-                        new TypeSource(method.getJetMethodAnnotation().propertyType(), propertyTypeParameter.getPsiParameter().getType(),
-                                       propertyTypeParameter.getPsiParameter());
-
-                members.addPropertyAccessor(new PropertyPsiDataElement(method, false, propertyType, receiverType));
-            }
         }
 
         private void processGetter(PsiMethod ownMethod, PsiMethodWrapper method, PropertyParseResult propertyParseResult) {
+            //TODO:
             String propertyName = propertyParseResult.getPropertyName();
-            NamedMembers members = getOrCreateEmpty(Name.identifier(propertyName));
+            getOrCreateEmpty(Name.identifier(propertyName));
-
-            // TODO: some java properties too
-            if (method.getJetMethodAnnotation().hasPropertyFlag()) {
-
-                int i = 0;
-
-                TypeSource receiverType;
-                if (i < method.getParameters().size() && method.getParameter(i).getJetValueParameter().receiver()) {
-                    PsiParameterWrapper receiverParameter = method.getParameter(i);
-                    receiverType =
-                            new TypeSource(receiverParameter.getJetValueParameter().type(), receiverParameter.getPsiParameter().getType(),
-                                           receiverParameter.getPsiParameter());
-                    ++i;
-                }
-                else {
-                    receiverType = null;
-                }
-
-                while (i < method.getParameters().size() && method.getParameter(i).getJetTypeParameter().isDefined()) {
-                    // TODO: store is reified
-                    ++i;
-                }
-
-                if (i != method.getParameters().size()) {
-                    // TODO: report error properly
-                    throw new IllegalStateException("something is wrong with method " + ownMethod);
-                }
-
-                // TODO: what if returnType == null?
-                PsiType returnType = method.getReturnType();
-                assert returnType != null;
-                TypeSource propertyType = new TypeSource(method.getJetMethodAnnotation().propertyType(), returnType, method.getPsiMethod());
-
-                members.addPropertyAccessor(new PropertyPsiDataElement(method, true, propertyType, receiverType));
-            }
         }
 
         private void createEmptyEntry(@NotNull Name identifier) {
@@ -413,9 +332,6 @@ public final class MembersCache {
     // Returns null if not SAM interface
     @Nullable
     public static PsiMethod getSamInterfaceMethod(@NotNull PsiClass psiClass) {
-        if (DescriptorResolverUtils.isKotlinClass(psiClass)) {
-            return null;
-        }
         String qualifiedName = psiClass.getQualifiedName();
         if (qualifiedName == null || qualifiedName.startsWith(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.asString() + ".")) {
             return null;

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/PsiDeclarationProviderFactory.java

@@ -38,12 +38,6 @@ public final class PsiDeclarationProviderFactory {
         return new ClassPsiDeclarationProviderImpl(psiClass, false, psiClassFinder);
     }
 
-    @NotNull
-    public KotlinNamespacePsiDeclarationProvider createDeclarationForKotlinNamespace(
-            @NotNull PsiPackage psiPackage, @NotNull PsiClass psiClass) {
-        return new KotlinNamespacePsiDeclarationProvider(psiPackage, psiClass, psiClassFinder);
-    }
-
     @NotNull
     public PackagePsiDeclarationProvider createDeclarationProviderForNamespaceWithoutMembers(@NotNull PsiPackage psiPackage) {
         return new PackagePsiDeclarationProviderImpl(psiPackage, psiClassFinder);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java

@@ -1,168 +0,0 @@
-/*
- * Copyright 2010-2013 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.resolver;
-
-import com.intellij.psi.PsiClass;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.ClassKind;
-import org.jetbrains.jet.lang.descriptors.Modality;
-import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
-import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
-import org.jetbrains.jet.lang.resolve.java.kt.JetClassObjectAnnotation;
-import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
-import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope;
-import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.FqNameBase;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
-import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
-import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
-import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
-
-import javax.inject.Inject;
-import java.util.Collections;
-
-import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod;
-import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValuesMethod;
-import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
-
-public final class JavaClassObjectResolver {
-
-    private BindingTrace trace;
-    private JavaSemanticServices semanticServices;
-    private JavaSupertypeResolver supertypesResolver;
-
-    @Inject
-    public void setSupertypesResolver(JavaSupertypeResolver supertypesResolver) {
-        this.supertypesResolver = supertypesResolver;
-    }
-
-    @Inject
-    public void setTrace(BindingTrace trace) {
-        this.trace = trace;
-    }
-
-    @Inject
-    public void setSemanticServices(JavaSemanticServices semanticServices) {
-        this.semanticServices = semanticServices;
-    }
-
-    @Nullable
-    public ClassDescriptorFromJvmBytecode createClassObjectDescriptor(
-            @NotNull ClassDescriptor containing,
-            @NotNull PsiClass psiClass
-    ) {
-        DescriptorResolverUtils.checkPsiClassIsNotJet(psiClass);
-
-        if (psiClass.isEnum()) {
-            return createClassObjectDescriptorForEnum(containing, psiClass);
-        }
-
-        if (!DescriptorResolverUtils.isKotlinClass(psiClass)) {
-            return null;
-        }
-
-        PsiClass classObjectPsiClass = getClassObjectPsiClass(psiClass);
-        if (classObjectPsiClass == null) {
-            return null;
-        }
-
-        return createClassObjectFromPsi(containing, classObjectPsiClass);
-    }
-
-    @NotNull
-    private ClassDescriptorFromJvmBytecode createClassObjectFromPsi(
-            @NotNull ClassDescriptor containing,
-            @NotNull PsiClass classObjectPsiClass
-    ) {
-        String qualifiedName = classObjectPsiClass.getQualifiedName();
-        assert qualifiedName != null;
-        FqName fqName = new FqName(qualifiedName);
-        ClassPsiDeclarationProvider classObjectData = semanticServices.getPsiDeclarationProviderFactory().createBinaryClassData(classObjectPsiClass);
-        ClassDescriptorFromJvmBytecode classObjectDescriptor
-                = new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false);
-        classObjectDescriptor.setSupertypes(supertypesResolver.getSupertypes(classObjectDescriptor,
-                                                                             new PsiClassWrapper(classObjectPsiClass),
-                                                                             classObjectData,
-                                                                             Collections.<TypeParameterDescriptor>emptyList()));
-        setUpClassObjectDescriptor(classObjectDescriptor, containing, fqName, classObjectData, getClassObjectName(containing.getName()));
-        return classObjectDescriptor;
-    }
-
-    @NotNull
-    private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum(
-            @NotNull ClassDescriptor containing,
-            @NotNull PsiClass psiClass
-    ) {
-        ClassDescriptorFromJvmBytecode classObjectDescriptor = createSyntheticClassObject(containing, psiClass);
-
-        classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, trace));
-        classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, trace));
-
-        return classObjectDescriptor;
-    }
-
-    @NotNull
-    private ClassDescriptorFromJvmBytecode createSyntheticClassObject(
-            @NotNull ClassDescriptor containing,
-            @NotNull PsiClass psiClass
-    ) {
-        FqNameUnsafe fqName = DescriptorResolverUtils.getFqNameForClassObject(psiClass);
-        ClassDescriptorFromJvmBytecode classObjectDescriptor =
-                new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false);
-        ClassPsiDeclarationProvider data = semanticServices.getPsiDeclarationProviderFactory().createSyntheticClassObjectClassData(psiClass);
-        setUpClassObjectDescriptor(classObjectDescriptor, containing, fqName, data, getClassObjectName(containing.getName().asString()));
-        return classObjectDescriptor;
-    }
-
-    private void setUpClassObjectDescriptor(
-            @NotNull ClassDescriptorFromJvmBytecode classObjectDescriptor,
-            @NotNull ClassDescriptor containing,
-            @NotNull FqNameBase fqName,
-            @NotNull ClassPsiDeclarationProvider data,
-            @NotNull Name classObjectName
-    ) {
-        classObjectDescriptor.setName(classObjectName);
-        classObjectDescriptor.setModality(Modality.FINAL);
-        classObjectDescriptor.setVisibility(containing.getVisibility());
-        classObjectDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
-        classObjectDescriptor.createTypeConstructor();
-        JavaClassNonStaticMembersScope classMembersScope = new JavaClassNonStaticMembersScope(classObjectDescriptor, data, semanticServices);
-        WritableScopeImpl writableScope =
-                new WritableScopeImpl(classMembersScope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, "Member lookup scope");
-        writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
-        classObjectDescriptor.setScopeForMemberLookup(writableScope);
-        classObjectDescriptor.setScopeForConstructorResolve(classMembersScope);
-    }
-
-
-    @Nullable
-    private static PsiClass getClassObjectPsiClass(@NotNull PsiClass ownerClass) {
-        for (PsiClass inner : ownerClass.getInnerClasses()) {
-            if (JetClassObjectAnnotation.get(inner).isDefined()) {
-                return inner;
-            }
-        }
-        return null;
-    }
-}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java

@@ -32,7 +32,6 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
-import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.provider.MembersCache;
 import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils;
@@ -44,16 +43,20 @@ import org.jetbrains.jet.lang.resolve.name.FqNameBase;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 import javax.inject.Inject;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.List;
+
-import java.util.Map;
+import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod;
-import java.util.Set;
+import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValuesMethod;
+import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
 
 public final class JavaClassResolver {
 
@@ -85,7 +88,6 @@ public final class JavaClassResolver {
     private JavaAnnotationResolver annotationResolver;
     private PsiClassFinder psiClassFinder;
     private JavaNamespaceResolver namespaceResolver;
-    private JavaClassObjectResolver classObjectResolver;
     private JavaSupertypeResolver supertypesResolver;
     private JavaFunctionResolver functionResolver;
     private DeserializedDescriptorResolver kotlinDescriptorResolver;
@@ -108,11 +110,6 @@ public final class JavaClassResolver {
         this.signatureResolver = signatureResolver;
     }
 
-    @Inject
-    public void setClassObjectResolver(JavaClassObjectResolver classObjectResolver) {
-        this.classObjectResolver = classObjectResolver;
-    }
-
     @Inject
     public void setSemanticServices(JavaSemanticServices semanticServices) {
         this.semanticServices = semanticServices;
@@ -258,6 +255,7 @@ public final class JavaClassResolver {
 
         return doCreateClassDescriptor(fqName, psiClass, taskList, containingDeclaration);
     }
+
     @NotNull
     private ClassDescriptorFromJvmBytecode doCreateClassDescriptor(
             @NotNull FqName fqName,
@@ -265,12 +263,7 @@ public final class JavaClassResolver {
             @NotNull PostponedTasks taskList,
             @NotNull ClassOrNamespaceDescriptor containingDeclaration
     ) {
-        JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass);
+        ClassKind kind = getClassKind(psiClass);
-        if (jetClassAnnotation.isDefined()) {
-            AbiVersionUtil.checkAbiVersion(psiClass, jetClassAnnotation.getAbiVersion(), trace);
-        }
-
-        ClassKind kind = getClassKind(psiClass, jetClassAnnotation);
         ClassPsiDeclarationProvider classData = semanticServices.getPsiDeclarationProviderFactory().createBinaryClassData(psiClass);
         ClassDescriptorFromJvmBytecode classDescriptor = new ClassDescriptorFromJvmBytecode(
                 containingDeclaration, kind, isInnerClass(psiClass));
@@ -279,12 +272,12 @@ public final class JavaClassResolver {
         classDescriptor.setName(Name.identifier(psiClass.getName()));
 
         List<JavaSignatureResolver.TypeParameterDescriptorInitialization> typeParameterDescriptorInitializations
-                = signatureResolver.createUninitializedClassTypeParameters(psiClass, classDescriptor);
+                = JavaSignatureResolver.createUninitializedClassTypeParameters(psiClass, classDescriptor);
 
         classDescriptor.setTypeParameterDescriptors(getTypeParametersDescriptors(typeParameterDescriptorInitializations));
         List<JetType> supertypes = Lists.newArrayList();
         classDescriptor.setSupertypes(supertypes);
-        classDescriptor.setVisibility(DescriptorResolverUtils.resolveVisibility(psiClass, jetClassAnnotation));
+        classDescriptor.setVisibility(DescriptorResolverUtils.resolveVisibility(psiClass));
         classDescriptor.setModality(resolveModality(psiClass, classDescriptor));
         classDescriptor.createTypeConstructor();
         JavaClassNonStaticMembersScope membersScope = new JavaClassNonStaticMembersScope(classDescriptor, classData, semanticServices);
@@ -298,9 +291,9 @@ public final class JavaClassResolver {
         List<TypeParameterDescriptor> classTypeParameters = classDescriptor.getTypeConstructor().getParameters();
         supertypes.addAll(supertypesResolver.getSupertypes(classDescriptor, new PsiClassWrapper(psiClass), classData, classTypeParameters));
 
-        ClassDescriptorFromJvmBytecode classObjectDescriptor = classObjectResolver.createClassObjectDescriptor(classDescriptor, psiClass);
+        if (psiClass.isEnum()) {
-        cache(DescriptorResolverUtils.getFqNameForClassObject(psiClass), classObjectDescriptor);
+            ClassDescriptorFromJvmBytecode classObjectDescriptor = createClassObjectDescriptorForEnum(classDescriptor, psiClass);
-        if (classObjectDescriptor != null) {
+            cache(DescriptorResolverUtils.getFqNameForClassObject(psiClass), classObjectDescriptor);
             classDescriptor.getBuilder().setClassObjectDescriptor(classObjectDescriptor);
         }
 
@@ -468,20 +461,65 @@ public final class JavaClassResolver {
     }
 
     @NotNull
-    private static ClassKind getClassKind(@NotNull PsiClass psiClass, @NotNull JetClassAnnotation jetClassAnnotation) {
+    private static ClassKind getClassKind(@NotNull PsiClass psiClass) {
         if (psiClass.isInterface()) {
             return (psiClass.isAnnotationType() ? ClassKind.ANNOTATION_CLASS : ClassKind.TRAIT);
         }
         if (psiClass.isEnum()) {
             return ClassKind.ENUM_CLASS;
         }
-        else {
+        return ClassKind.CLASS;
-            return jetClassAnnotation.kind() == JvmStdlibNames.FLAG_CLASS_KIND_OBJECT ? ClassKind.OBJECT : ClassKind.CLASS;
-        }
     }
 
     @Nullable
     public ClassDescriptor resolveClass(FqName name) {
         return resolveClass(name, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
     }
+
+    @NotNull
+    private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum(
+            @NotNull ClassDescriptor containing,
+            @NotNull PsiClass psiClass
+    ) {
+        ClassDescriptorFromJvmBytecode classObjectDescriptor = createSyntheticClassObject(containing, psiClass);
+
+        classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, trace));
+        classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, trace));
+
+        return classObjectDescriptor;
+    }
+
+    @NotNull
+    private ClassDescriptorFromJvmBytecode createSyntheticClassObject(
+            @NotNull ClassDescriptor containing,
+            @NotNull PsiClass psiClass
+    ) {
+        ClassDescriptorFromJvmBytecode classObjectDescriptor =
+                new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false);
+        ClassPsiDeclarationProvider data =
+                semanticServices.getPsiDeclarationProviderFactory().createSyntheticClassObjectClassData(psiClass);
+        setUpClassObjectDescriptor(classObjectDescriptor, containing, data, getClassObjectName(containing.getName().asString()));
+        return classObjectDescriptor;
+    }
+
+    private void setUpClassObjectDescriptor(
+            @NotNull ClassDescriptorFromJvmBytecode classObjectDescriptor,
+            @NotNull ClassDescriptor containing,
+            @NotNull ClassPsiDeclarationProvider data,
+            @NotNull Name classObjectName
+    ) {
+        classObjectDescriptor.setName(classObjectName);
+        classObjectDescriptor.setModality(Modality.FINAL);
+        classObjectDescriptor.setVisibility(containing.getVisibility());
+        classObjectDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
+        classObjectDescriptor.createTypeConstructor();
+        JavaClassNonStaticMembersScope classMembersScope =
+                new JavaClassNonStaticMembersScope(classObjectDescriptor, data, semanticServices);
+        WritableScopeImpl writableScope =
+                new WritableScopeImpl(classMembersScope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION,
+                                      "Member lookup scope");
+        writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
+        classObjectDescriptor.setScopeForMemberLookup(writableScope);
+        classObjectDescriptor.setScopeForConstructorResolve(classMembersScope);
+    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java

@@ -30,7 +30,6 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
-import org.jetbrains.jet.lang.resolve.java.kt.JetConstructorAnnotation;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -102,7 +101,8 @@ public final class JavaConstructorResolver {
                             containingClass,
                             Collections.<AnnotationDescriptor>emptyList(),
                             true);
-                    constructorDescriptor.initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList(), constructorVisibility, isStatic);
+                    constructorDescriptor
+                            .initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList(), constructorVisibility, isStatic);
                     constructors.add(constructorDescriptor);
                     trace.record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
                 }
@@ -175,27 +175,14 @@ public final class JavaConstructorResolver {
     ) {
         PsiMethodWrapper constructor = new PsiMethodWrapper(psiConstructor);
 
-        JetConstructorAnnotation constructorAnnotation = constructor.getJetConstructorAnnotation();
-        //noinspection deprecation
-        if (constructorAnnotation.hidden()) {
-            return null;
-        }
-
-        // Do not resolve kotlin constructors without JetConstructorAnnotation
-        if (DescriptorResolverUtils.isKotlinClass(psiClass) && !constructorAnnotation.isDefined()) {
-            return null;
-        }
-
         if (trace.get(BindingContext.CONSTRUCTOR, psiConstructor) != null) {
             return trace.get(BindingContext.CONSTRUCTOR, psiConstructor);
         }
 
-        boolean primary = constructor.getJetConstructorAnnotation().isDefined();
-
         ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(
                 classDescriptor,
                 Collections.<AnnotationDescriptor>emptyList(), // TODO
-                primary);
+                false);
 
         String context = "constructor of class " + psiClass.getQualifiedName();
         JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = valueParameterResolver.resolveParameterDescriptors(
@@ -219,7 +206,7 @@ public final class JavaConstructorResolver {
 
         constructorDescriptor.initialize(classDescriptor.getTypeConstructor().getParameters(),
                                          valueParameterDescriptors.getDescriptors(),
-                                         DescriptorResolverUtils.resolveVisibility(psiConstructor, constructorAnnotation),
+                                         DescriptorResolverUtils.resolveVisibility(psiConstructor),
                                          aStatic);
         trace.record(BindingContext.CONSTRUCTOR, psiConstructor, constructorDescriptor);
         return constructorDescriptor;

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java

@@ -34,7 +34,6 @@ import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesPropagationData;
-import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils;
 import org.jetbrains.jet.lang.resolve.java.provider.*;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -115,11 +114,6 @@ public final class JavaFunctionResolver {
             return null;
         }
 
-        // TODO: ugly
-        if (method.getJetMethodAnnotation().hasPropertyFlag()) {
-            return null;
-        }
-
         PsiMethod psiMethod = method.getPsiMethod();
         PsiClass containingClass = psiMethod.getContainingClass();
         if (declarationOrigin == KOTLIN) {
@@ -139,7 +133,7 @@ public final class JavaFunctionResolver {
                 ownerDescriptor,
                 annotationResolver.resolveAnnotations(psiMethod),
                 Name.identifier(method.getName()),
-                DescriptorKindUtils.flagsToKind(method.getJetMethodAnnotation().kind())
+                CallableMemberDescriptor.Kind.DECLARATION
         );
 
         String context = "method " + method.getName() + " in class " + psiClass.getQualifiedName();
@@ -159,7 +153,7 @@ public final class JavaFunctionResolver {
         List<String> signatureErrors = Lists.newArrayList();
 
         List<FunctionDescriptor> superFunctions;
-        if (ownerDescriptor instanceof ClassDescriptor && !method.getJetMethodAnnotation().isDefined()) { // don't propagate for Kotlin functions
+        if (ownerDescriptor instanceof ClassDescriptor) {
             SignaturesPropagationData signaturesPropagationData = new SignaturesPropagationData(
                     (ClassDescriptor) ownerDescriptor, returnType, valueParameterDescriptors, methodTypeParameters, method, trace);
             superFunctions = signaturesPropagationData.getSuperFunctions();
@@ -192,8 +186,8 @@ public final class JavaFunctionResolver {
                 methodTypeParameters,
                 valueParameterDescriptors.getDescriptors(),
                 returnType,
-                DescriptorResolverUtils.resolveModality(method, method.isFinal()),
+                Modality.convertFromFlags(method.isAbstract(), !method.isFinal()),
-                DescriptorResolverUtils.resolveVisibility(psiMethod, method.getJetMethodAnnotation()),
+                DescriptorResolverUtils.resolveVisibility(psiMethod),
                 /*isInline = */ false
         );
 
@@ -210,8 +204,8 @@ public final class JavaFunctionResolver {
         }
 
         if (!RawTypesCheck.hasRawTypesInHierarchicalSignature(psiMethod)
-                && JavaMethodSignatureUtil.isMethodReturnTypeCompatible(psiMethod)
+            && JavaMethodSignatureUtil.isMethodReturnTypeCompatible(psiMethod)
-                && !containsErrorType(superFunctions, functionDescriptorImpl)) {
+            && !containsErrorType(superFunctions, functionDescriptorImpl)) {
             if (signatureErrors.isEmpty()) {
                 checkFunctionsOverrideCorrectly(method, superFunctions, functionDescriptorImpl);
             }
@@ -276,13 +270,11 @@ public final class JavaFunctionResolver {
 
         Set<SimpleFunctionDescriptor> functionsFromCurrent = Sets.newHashSet();
         for (PsiMethodWrapper method : namedMembers.getMethods()) {
-            SimpleFunctionDescriptor function = resolveMethodToFunctionDescriptor(psiClass, method, scopeData.getDeclarationOrigin(), owner, true);
+            SimpleFunctionDescriptor function =
+                    resolveMethodToFunctionDescriptor(psiClass, method, scopeData.getDeclarationOrigin(), owner, true);
             if (function != null) {
                 functionsFromCurrent.add(function);
-
+                ContainerUtil.addIfNotNull(functionsFromCurrent, resolveSamAdapter(function));
-                if (!DescriptorResolverUtils.isKotlinClass(psiClass)) {
-                    ContainerUtil.addIfNotNull(functionsFromCurrent, resolveSamAdapter(function));
-                }
             }
         }
 
@@ -296,20 +288,20 @@ public final class JavaFunctionResolver {
             ClassDescriptor classDescriptor = (ClassDescriptor) owner;
 
             OverrideResolver.generateOverridesInFunctionGroup(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor,
-                  new OverrideResolver.DescriptorSink() {
+                                                              new OverrideResolver.DescriptorSink() {
-                      @Override
+                                                                  @Override
-                      public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
+                                                                  public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
-                          fakeOverrides.add((FunctionDescriptor) fakeOverride);
+                                                                      fakeOverrides.add((FunctionDescriptor) fakeOverride);
-                      }
+                                                                  }
 
-                      @Override
+                                                                  @Override
-                      public void conflict(
+                                                                  public void conflict(
-                              @NotNull CallableMemberDescriptor fromSuper,
+                                                                          @NotNull CallableMemberDescriptor fromSuper,
-                              @NotNull CallableMemberDescriptor fromCurrent
+                                                                          @NotNull CallableMemberDescriptor fromCurrent
-                      ) {
+                                                                  ) {
-                          // nop
+                                                                      // nop
-                      }
+                                                                  }
-                  });
+                                                              });
         }
 
         OverrideResolver.resolveUnknownVisibilities(fakeOverrides, trace);
@@ -426,18 +418,12 @@ public final class JavaFunctionResolver {
             @NotNull TypeVariableResolver typeVariableResolver
     ) {
 
-        String returnTypeFromAnnotation = method.getJetMethodAnnotation().returnType();
+        TypeUsage typeUsage = JavaTypeTransformer
+                .adjustTypeUsageWithMutabilityAnnotations(method.getPsiMethod(), TypeUsage.MEMBER_SIGNATURE_COVARIANT);
+        JetType transformedType = typeTransformer.transformToType(returnType, typeUsage, typeVariableResolver);
 
-        JetType transformedType;
+        if (JavaAnnotationResolver
-        if (returnTypeFromAnnotation.length() > 0) {
+                    .findAnnotationWithExternal(method.getPsiMethod(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) !=
-            transformedType = typeTransformer.transformToType(returnTypeFromAnnotation, typeVariableResolver);
-        }
-        else {
-            TypeUsage typeUsage = JavaTypeTransformer.adjustTypeUsageWithMutabilityAnnotations(method.getPsiMethod(), TypeUsage.MEMBER_SIGNATURE_COVARIANT);
-            transformedType = typeTransformer.transformToType(returnType, typeUsage, typeVariableResolver);
-        }
-
-        if (JavaAnnotationResolver.findAnnotationWithExternal(method.getPsiMethod(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) !=
             null) {
             return TypeUtils.makeNullableAsSpecified(transformedType, false);
         }
@@ -473,7 +459,11 @@ public final class JavaFunctionResolver {
         return false;
     }
 
-    private static SimpleFunctionDescriptor recordSamConstructor(ClassDescriptorFromJvmBytecode klass, SimpleFunctionDescriptor constructorFunction, BindingTrace trace) {
+    private static SimpleFunctionDescriptor recordSamConstructor(
+            ClassDescriptorFromJvmBytecode klass,
+            SimpleFunctionDescriptor constructorFunction,
+            BindingTrace trace
+    ) {
         trace.record(JavaBindingContext.SAM_CONSTRUCTOR_TO_INTERFACE, constructorFunction, klass);
         trace.record(BindingContext.SOURCE_DESCRIPTOR_FOR_SYNTHESIZED, constructorFunction, klass);
         return constructorFunction;

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java

@@ -20,8 +20,6 @@ import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
-import org.jetbrains.jet.lang.resolve.java.JvmAbi;
-import org.jetbrains.jet.lang.resolve.java.kt.JetClassObjectAnnotation;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
@@ -56,19 +54,12 @@ public final class JavaInnerClassResolver {
         PsiClass[] innerPsiClasses = psiClass.getInnerClasses();
         List<ClassDescriptor> result = new ArrayList<ClassDescriptor>(innerPsiClasses.length);
         for (PsiClass innerPsiClass : innerPsiClasses) {
-            if (shouldBeIgnored(innerPsiClass)) {
-                continue;
-            }
             ClassDescriptor classDescriptor = resolveInnerClass(innerPsiClass);
             result.add(classDescriptor);
         }
         return result;
     }
 
-    private static boolean shouldBeIgnored(PsiClass innerPsiClass) {
-        return JetClassObjectAnnotation.get(innerPsiClass).isDefined();
-    }
-
     @NotNull
     private ClassDescriptor resolveInnerClass(@NotNull PsiClass innerPsiClass) {
         String name = innerPsiClass.getQualifiedName();

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java

@@ -37,7 +37,6 @@ import org.jetbrains.jet.lang.resolve.java.provider.MembersCache;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaBaseScope;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScopeWithoutMembers;
-import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -201,7 +200,7 @@ public final class JavaNamespaceResolver {
     }
 
     private static boolean isOldKotlinPackageClass(@NotNull PsiClass psiClass) {
-        return new PsiClassWrapper(psiClass).getJetPackageClass().isDefined();
+        return hasAnnotation(psiClass, JvmStdlibNames.JET_PACKAGE_CLASS.getFqName());
     }
 
     private static boolean hasKotlinPackageAnnotation(@NotNull PsiClass psiClass) {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java

@@ -30,8 +30,6 @@ import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeFieldSignatureData;
-import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils;
-import org.jetbrains.jet.lang.resolve.java.kt.JetMethodAnnotation;
 import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers;
 import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.wrapper.*;
@@ -45,6 +43,7 @@ import java.util.*;
 
 import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.JAVA;
 
+//TODO: getters and setter are not working
 public final class JavaPropertyResolver {
 
     private JavaSemanticServices semanticServices;
@@ -174,17 +173,16 @@ public final class JavaPropertyResolver {
 
         PropertyPsiDataElement characteristicMember = psiData.getCharacteristicMember();
 
-        Visibility visibility = DescriptorResolverUtils.resolveVisibility(psiData.getCharacteristicPsi(), null);
+        Visibility visibility = DescriptorResolverUtils.resolveVisibility(psiData.getCharacteristicPsi());
         CallableMemberDescriptor.Kind kind = CallableMemberDescriptor.Kind.DECLARATION;
 
         PropertyPsiDataElement getter = psiData.getGetter();
         if (getter != null) {
-            JetMethodAnnotation methodAnnotation = ((PsiMethodWrapper) getter.getMember()).getJetMethodAnnotation();
+            visibility = DescriptorResolverUtils.resolveVisibility(psiData.getCharacteristicPsi());
-            visibility = DescriptorResolverUtils.resolveVisibility(psiData.getCharacteristicPsi(), methodAnnotation);
-            kind = DescriptorKindUtils.flagsToKind(methodAnnotation.kind());
         }
 
-        PropertyDescriptorImpl propertyDescriptor = createPropertyDescriptor(owner, propertyName, psiData, isFinal, isVar, visibility, kind);
+        PropertyDescriptorImpl propertyDescriptor =
+                createPropertyDescriptor(owner, propertyName, psiData, isFinal, isVar, visibility, kind);
 
         PropertyGetterDescriptorImpl getterDescriptor = resolveGetter(visibility, kind, getter, propertyDescriptor);
         PropertySetterDescriptorImpl setterDescriptor = resolveSetter(psiData, kind, propertyDescriptor);
@@ -209,9 +207,7 @@ public final class JavaPropertyResolver {
         );
         initializeSetterAndGetter(propertyDescriptor, getterDescriptor, setterDescriptor, propertyType, psiData);
 
-        if (kind == CallableMemberDescriptor.Kind.DECLARATION) {
+        trace.record(BindingContext.VARIABLE, psiData.getCharacteristicPsi(), propertyDescriptor);
-            trace.record(BindingContext.VARIABLE, psiData.getCharacteristicPsi(), propertyDescriptor);
-        }
 
         if (scopeData.getDeclarationOrigin() == JAVA) {
             trace.record(JavaBindingContext.IS_DECLARED_IN_JAVA, propertyDescriptor);
@@ -277,8 +273,8 @@ public final class JavaPropertyResolver {
             return new PropertyDescriptorImpl(
                     owner,
                     annotationResolver.resolveAnnotations(psiData.getCharacteristicPsi()),
-                    DescriptorResolverUtils.resolveModality(psiData.getCharacteristicMember().getMember(),
+                    Modality.convertFromFlags(psiData.getCharacteristicMember().getMember().isAbstract(),
-                                                            isFinal || psiData.isPropertyForNamedObject()),
+                                              !(isFinal || psiData.isPropertyForNamedObject())),
                     visibility,
                     isVar,
                     propertyName,
@@ -310,6 +306,7 @@ public final class JavaPropertyResolver {
         return propertyType;
     }
 
+    //TODO: doesn't work
     private static void initializeSetterAndGetter(
             @NotNull PropertyDescriptor propertyDescriptor,
             @Nullable PropertyGetterDescriptorImpl getterDescriptor,
@@ -325,13 +322,11 @@ public final class JavaPropertyResolver {
             assert setter != null;
             List<PsiParameterWrapper> parameters = ((PsiMethodWrapper) setter.getMember()).getParameters();
             assert parameters.size() != 0;
-            int valueIndex = parameters.size() - 1;
-            PsiParameterWrapper valueParameter = parameters.get(valueIndex);
             setterDescriptor.initialize(new ValueParameterDescriptorImpl(
                     setterDescriptor,
                     0,
                     Collections.<AnnotationDescriptor>emptyList(),
-                    Name.identifierNoValidate(valueParameter.getJetValueParameter().name()),
+                    Name.identifierNoValidate(""),
                     propertyDescriptor.getType(),
                     false,
                     null));
@@ -368,12 +363,11 @@ public final class JavaPropertyResolver {
         if (setter == null) {
             return null;
         }
-        Visibility setterVisibility = DescriptorResolverUtils.resolveVisibility(setter.getMember().getPsiMember(), null);
+        Visibility setterVisibility = DescriptorResolverUtils.resolveVisibility(setter.getMember().getPsiMember());
         if (setter.getMember() instanceof PsiMethodWrapper) {
             setterVisibility = DescriptorResolverUtils.resolveVisibility(
-                    setter.getMember().getPsiMember(),
+                    setter.getMember().getPsiMember()
-                    ((PsiMethodWrapper) setter.getMember())
+            );
-                            .getJetMethodAnnotation());
         }
         return new PropertySetterDescriptorImpl(
                 propertyDescriptor,

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java

@@ -21,12 +21,14 @@ import com.intellij.psi.*;
 import jet.typeinfo.TypeInfoVariance;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.*;
-import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.JetType;
@@ -72,7 +74,10 @@ public final class JavaSignatureResolver {
         @Nullable
         private final List<JetType> upperBoundsForKotlin;
 
-        private TypeParameterDescriptorInitialization(@NotNull TypeParameterDescriptorImpl descriptor, @NotNull PsiTypeParameter psiTypeParameter) {
+        private TypeParameterDescriptorInitialization(
+                @NotNull TypeParameterDescriptorImpl descriptor,
+                @NotNull PsiTypeParameter psiTypeParameter
+        ) {
             this.origin = TypeParameterDescriptorOrigin.JAVA;
             this.descriptor = descriptor;
             this.psiTypeParameter = psiTypeParameter;
@@ -96,7 +101,6 @@ public final class JavaSignatureResolver {
     }
 
 
-
     @NotNull
     private static PsiTypeParameter getPsiTypeParameterByName(PsiTypeParameterListOwner clazz, String name) {
         for (PsiTypeParameter typeParameter : clazz.getTypeParameters()) {
@@ -108,7 +112,6 @@ public final class JavaSignatureResolver {
     }
 
 
-
     private abstract class JetSignatureTypeParameterVisitor extends JetSignatureExceptionsAdapter {
 
         @NotNull
@@ -124,8 +127,8 @@ public final class JavaSignatureResolver {
                 @NotNull PsiTypeParameterListOwner psiOwner,
                 @NotNull String name,
                 @NotNull TypeVariableResolver typeVariableResolver,
-                @NotNull TypeParameterDescriptorImpl typeParameterDescriptor)
+                @NotNull TypeParameterDescriptorImpl typeParameterDescriptor
-        {
+        ) {
             if (name.isEmpty()) {
                 throw new IllegalStateException();
             }
@@ -164,7 +167,8 @@ public final class JavaSignatureResolver {
         @Override
         public void visitFormalTypeParameterEnd() {
             PsiTypeParameter psiTypeParameter = getPsiTypeParameterByName(psiOwner, name);
-            TypeParameterDescriptorInitialization typeParameterDescriptorInitialization = new TypeParameterDescriptorInitialization(typeParameterDescriptor, psiTypeParameter, upperBounds);
+            TypeParameterDescriptorInitialization typeParameterDescriptorInitialization =
+                    new TypeParameterDescriptorInitialization(typeParameterDescriptor, psiTypeParameter, upperBounds);
             done(typeParameterDescriptorInitialization);
         }
 
@@ -182,7 +186,11 @@ public final class JavaSignatureResolver {
         private final TypeVariableResolver typeVariableResolver;
 
 
-        private JetSignatureTypeParametersVisitor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull PsiTypeParameterListOwner psiOwner, @NotNull String context) {
+        private JetSignatureTypeParametersVisitor(
+                @NotNull DeclarationDescriptor containingDeclaration,
+                @NotNull PsiTypeParameterListOwner psiOwner,
+                @NotNull String context
+        ) {
             this.containingDeclaration = containingDeclaration;
             this.psiOwner = psiOwner;
 
@@ -219,37 +227,41 @@ public final class JavaSignatureResolver {
         }
     }
 
-        /**
+    /**
      * @see #resolveMethodTypeParametersFromJetSignature(String, PsiMethod, DeclarationDescriptor)
      */
-    private List<TypeParameterDescriptorInitialization> resolveClassTypeParametersFromJetSignature(String jetSignature,
+    private List<TypeParameterDescriptorInitialization> resolveClassTypeParametersFromJetSignature(
-            final PsiClass clazz, final ClassDescriptor classDescriptor) {
+            String jetSignature,
+            final PsiClass clazz, final ClassDescriptor classDescriptor
+    ) {
         String context = "class " + clazz.getQualifiedName();
-        JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = new JetSignatureTypeParametersVisitor(classDescriptor, clazz, context) {
+        JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor =
-            @Override
+                new JetSignatureTypeParametersVisitor(classDescriptor, clazz, context) {
-            public JetSignatureVisitor visitSuperclass() {
+                    @Override
-                // TODO
+                    public JetSignatureVisitor visitSuperclass() {
-                return new JetSignatureAdapter();
+                        // TODO
-            }
+                        return new JetSignatureAdapter();
+                    }
 
-            @Override
+                    @Override
-            public JetSignatureVisitor visitInterface() {
+                    public JetSignatureVisitor visitInterface() {
-                // TODO
+                        // TODO
-                return new JetSignatureAdapter();
+                        return new JetSignatureAdapter();
-            }
+                    }
-        };
+                };
         new JetSignatureReader(jetSignature).accept(jetSignatureTypeParametersVisitor);
         return jetSignatureTypeParametersVisitor.r;
     }
 
 
-        private static List<TypeParameterDescriptorInitialization> makeUninitializedTypeParameters(
+    private static List<TypeParameterDescriptorInitialization> makeUninitializedTypeParameters(
-                @NotNull DeclarationDescriptor containingDeclaration,
+            @NotNull DeclarationDescriptor containingDeclaration,
-                @NotNull PsiTypeParameter[] typeParameters
+            @NotNull PsiTypeParameter[] typeParameters
-        ) {
+    ) {
         List<TypeParameterDescriptorInitialization> result = Lists.newArrayList();
         for (PsiTypeParameter typeParameter : typeParameters) {
-            TypeParameterDescriptorInitialization typeParameterDescriptor = makeUninitializedTypeParameter(containingDeclaration, typeParameter);
+            TypeParameterDescriptorInitialization typeParameterDescriptor =
+                    makeUninitializedTypeParameter(containingDeclaration, typeParameter);
             result.add(typeParameterDescriptor);
         }
         return result;
@@ -271,12 +283,15 @@ public final class JavaSignatureResolver {
         return new TypeParameterDescriptorInitialization(typeParameterDescriptor, psiTypeParameter);
     }
 
-    private void initializeTypeParameter(TypeParameterDescriptorInitialization typeParameter, TypeVariableResolver typeVariableByPsiResolver) {
+    private void initializeTypeParameter(
+            TypeParameterDescriptorInitialization typeParameter,
+            TypeVariableResolver typeVariableByPsiResolver
+    ) {
         TypeParameterDescriptorImpl typeParameterDescriptor = typeParameter.descriptor;
         if (typeParameter.origin == TypeParameterDescriptorOrigin.KOTLIN) {
             List<JetType> upperBoundsForKotlin = typeParameter.upperBoundsForKotlin;
             assert upperBoundsForKotlin != null;
-            if (upperBoundsForKotlin.size() == 0){
+            if (upperBoundsForKotlin.size() == 0) {
                 typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType());
             }
             else {
@@ -289,15 +304,19 @@ public final class JavaSignatureResolver {
         }
         else {
             PsiClassType[] referencedTypes = typeParameter.psiTypeParameter.getExtendsList().getReferencedTypes();
-            if (referencedTypes.length == 0){
+            if (referencedTypes.length == 0) {
                 typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType());
             }
             else if (referencedTypes.length == 1) {
-                typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer().transformToType(referencedTypes[0], TypeUsage.UPPER_BOUND, typeVariableByPsiResolver));
+                typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer()
+                                                              .transformToType(referencedTypes[0], TypeUsage.UPPER_BOUND,
+                                                                               typeVariableByPsiResolver));
             }
             else {
                 for (PsiClassType referencedType : referencedTypes) {
-                    typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer().transformToType(referencedType, TypeUsage.UPPER_BOUND, typeVariableByPsiResolver));
+                    typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer()
+                                                                  .transformToType(referencedType, TypeUsage.UPPER_BOUND,
+                                                                                   typeVariableByPsiResolver));
                 }
             }
         }
@@ -319,22 +338,22 @@ public final class JavaSignatureResolver {
         for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) {
             prevTypeParameters.add(psiTypeParameter.descriptor);
             initializeTypeParameter(psiTypeParameter,
-                    TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, typeParametersOwner, context));
+                                    TypeVariableResolvers
+                                            .typeVariableResolverFromTypeParameters(typeParameters, typeParametersOwner, context));
         }
     }
 
 
-    public List<TypeParameterDescriptorInitialization> createUninitializedClassTypeParameters(
+    @NotNull
+    public static List<TypeParameterDescriptorInitialization> createUninitializedClassTypeParameters(
             PsiClass psiClass, ClassDescriptor classDescriptor
     ) {
-        JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass);
+        List<TypeParameterDescriptorInitialization> result = Lists.newArrayList();
-
+        for (PsiTypeParameter typeParameter : psiClass.getTypeParameters()) {
-        if (jetClassAnnotation.signature().length() > 0) {
+            TypeParameterDescriptorInitialization typeParameterDescriptor = makeUninitializedTypeParameter(classDescriptor, typeParameter);
-            return resolveClassTypeParametersFromJetSignature(
+            result.add(typeParameterDescriptor);
-                    jetClassAnnotation.signature(), psiClass, classDescriptor);
         }
-
+        return result;
-        return makeUninitializedTypeParameters(classDescriptor, psiClass.getTypeParameters());
     }
 
 
@@ -343,15 +362,9 @@ public final class JavaSignatureResolver {
             @NotNull DeclarationDescriptor functionDescriptor
     ) {
 
-        List<TypeParameterDescriptorInitialization> typeParametersIntialization;
         PsiMethod psiMethod = method.getPsiMethod();
-        if (method.getJetMethodAnnotation().typeParameters().length() > 0) {
+        List<TypeParameterDescriptorInitialization> typeParametersIntialization =
-            typeParametersIntialization = resolveMethodTypeParametersFromJetSignature(
+                makeUninitializedTypeParameters(functionDescriptor, psiMethod.getTypeParameters());
-                    method.getJetMethodAnnotation().typeParameters(), psiMethod, functionDescriptor);
-        }
-        else {
-            typeParametersIntialization = makeUninitializedTypeParameters(functionDescriptor, psiMethod.getTypeParameters());
-        }
 
         PsiClass psiMethodContainingClass = psiMethod.getContainingClass();
         assert psiMethodContainingClass != null;
@@ -370,15 +383,16 @@ public final class JavaSignatureResolver {
     /**
      * @see #resolveClassTypeParametersFromJetSignature(String, PsiClass, ClassDescriptor)
      */
-    private List<TypeParameterDescriptorInitialization> resolveMethodTypeParametersFromJetSignature(String jetSignature,
+    private List<TypeParameterDescriptorInitialization> resolveMethodTypeParametersFromJetSignature(
-            PsiMethod method, DeclarationDescriptor functionDescriptor)
+            String jetSignature,
-    {
+            PsiMethod method, DeclarationDescriptor functionDescriptor
+    ) {
         PsiClass methodContainingClass = method.getContainingClass();
         assert methodContainingClass != null;
         String context = "method " + method.getName() + " in class " + methodContainingClass.getQualifiedName();
-        JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = new JetSignatureTypeParametersVisitor(functionDescriptor, method, context);
+        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/resolver/JavaSupertypeResolver.java

@@ -18,7 +18,6 @@ package org.jetbrains.jet.lang.resolve.java.resolver;
 
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiClassType;
-import jet.typeinfo.TypeInfoVariance;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
@@ -33,10 +32,6 @@ import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
-import org.jetbrains.jet.rt.signature.JetSignatureAdapter;
-import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter;
-import org.jetbrains.jet.rt.signature.JetSignatureReader;
-import org.jetbrains.jet.rt.signature.JetSignatureVisitor;
 
 import javax.inject.Inject;
 import java.util.ArrayList;
@@ -48,7 +43,6 @@ import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOT
 public final class JavaSupertypeResolver {
 
     private BindingTrace trace;
-    private JavaSemanticServices semanticServices;
     private JavaTypeTransformer typeTransformer;
     private JavaClassResolver classResolver;
 
@@ -57,11 +51,6 @@ public final class JavaSupertypeResolver {
         this.trace = trace;
     }
 
-    @Inject
-    public void setSemanticServices(JavaSemanticServices semanticServices) {
-        this.semanticServices = semanticServices;
-    }
-
     @Inject
     public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
         this.typeTransformer = typeTransformer;
@@ -83,15 +72,10 @@ public final class JavaSupertypeResolver {
 
         String context = "class " + psiClass.getQualifiedName();
 
-        if (psiClass.getJetClass().signature().length() > 0) {
+        TypeVariableResolver typeVariableResolverForSupertypes =
-            readSuperTypes(psiClass, typeParameters, classDescriptor, result, context);
+                TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context);
-        }
+        transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), typeVariableResolverForSupertypes);
-        else {
+        transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), typeVariableResolverForSupertypes);
-            TypeVariableResolver typeVariableResolverForSupertypes =
-                    TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context);
-            transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), typeVariableResolverForSupertypes);
-            transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), typeVariableResolverForSupertypes);
-        }
 
         reportIncompleteHierarchyForErrorTypes(classDescriptor, result);
 
@@ -101,43 +85,6 @@ public final class JavaSupertypeResolver {
         return result;
     }
 
-    private void readSuperTypes(
-            PsiClassWrapper psiClass,
-            List<TypeParameterDescriptor> typeParameters,
-            ClassDescriptor classDescriptor,
-            final List<JetType> result,
-            String context
-    ) {
-        final TypeVariableResolver typeVariableResolver =
-                TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context);
-
-        new JetSignatureReader(psiClass.getJetClass().signature()).accept(new JetSignatureExceptionsAdapter() {
-            @Override
-            public JetSignatureVisitor visitFormalTypeParameter(String name, TypeInfoVariance variance, boolean reified) {
-                // TODO: collect
-                return new JetSignatureAdapter();
-            }
-
-            @Override
-            public JetSignatureVisitor visitSuperclass() {
-                return new JetTypeJetSignatureReader(semanticServices, KotlinBuiltIns.getInstance(),
-                                                     typeVariableResolver) {
-                    @Override
-                    protected void done(@NotNull JetType jetType) {
-                        if (!jetType.equals(KotlinBuiltIns.getInstance().getAnyType())) {
-                            result.add(jetType);
-                        }
-                    }
-                };
-            }
-
-            @Override
-            public JetSignatureVisitor visitInterface() {
-                return visitSuperclass();
-            }
-        });
-    }
-
     private void addBaseClass(
             @NotNull PsiClassWrapper psiClass,
             @NotNull ClassPsiDeclarationProvider classData,
@@ -158,7 +105,7 @@ public final class JavaSupertypeResolver {
             else {
                 //TODO: hack here
                 result.add(KotlinBuiltIns.getInstance().getAnyType());
-               // throw new IllegalStateException("Could not resolve java.lang.Object");
+                // throw new IllegalStateException("Could not resolve java.lang.Object");
             }
         }
     }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java

@@ -22,8 +22,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiParameterWrapper;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -49,34 +49,17 @@ public final class JavaValueParameterResolver {
             PsiParameterWrapper parameter, TypeVariableResolver typeVariableResolver
     ) {
 
-        if (parameter.getJetTypeParameter().isDefined()) {
-            return JvmMethodParameterMeaning.typeInfo();
-        }
-
         PsiType psiType = parameter.getPsiParameter().getType();
 
         // TODO: must be very slow, make it lazy?
         Name name = Name.identifier(getParameterName(i, parameter));
 
-        if (parameter.getJetValueParameter().name().length() > 0) {
+        TypeUsage typeUsage = JavaTypeTransformer
-            name = Name.identifier(parameter.getJetValueParameter().name());
+                .adjustTypeUsageWithMutabilityAnnotations(parameter.getPsiParameter(), TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT);
-        }
+        JetType outType = getTypeTransformer().transformToType(psiType, typeUsage, typeVariableResolver);
-
-        String typeFromAnnotation = parameter.getJetValueParameter().type();
-        boolean receiver = parameter.getJetValueParameter().receiver();
-        boolean hasDefaultValue = parameter.getJetValueParameter().hasDefaultValue();
-
-        JetType outType;
-        if (typeFromAnnotation.length() > 0) {
-            outType = getTypeTransformer().transformToType(typeFromAnnotation, typeVariableResolver);
-        }
-        else {
-            TypeUsage typeUsage = JavaTypeTransformer.adjustTypeUsageWithMutabilityAnnotations(parameter.getPsiParameter(), TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT);
-            outType = getTypeTransformer().transformToType(psiType, typeUsage, typeVariableResolver);
-        }
 
         JetType varargElementType;
-        if (psiType instanceof PsiEllipsisType || parameter.getJetValueParameter().vararg()) {
+        if (psiType instanceof PsiEllipsisType) {
             varargElementType = KotlinBuiltIns.getInstance().getArrayElementType(TypeUtils.makeNotNullable(outType));
             outType = TypeUtils.makeNotNullable(outType);
         }
@@ -84,29 +67,24 @@ public final class JavaValueParameterResolver {
             varargElementType = null;
         }
 
-        if (receiver) {
+        JetType transformedType;
-            return JvmMethodParameterMeaning.receiver(outType);
+        if (JavaAnnotationResolver
+                    .findAnnotationWithExternal(parameter.getPsiParameter(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) !=
+            null) {
+            transformedType = TypeUtils.makeNullableAsSpecified(outType, false);
         }
         else {
-
+            transformedType = outType;
-            JetType transformedType;
-            if (JavaAnnotationResolver.findAnnotationWithExternal(parameter.getPsiParameter(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) !=
-                null) {
-                transformedType = TypeUtils.makeNullableAsSpecified(outType, false);
-            }
-            else {
-                transformedType = outType;
-            }
-            return JvmMethodParameterMeaning.regular(new ValueParameterDescriptorImpl(
-                    containingDeclaration,
-                    i,
-                    Collections.<AnnotationDescriptor>emptyList(), // TODO
-                    name,
-                    transformedType,
-                    hasDefaultValue,
-                    varargElementType
-            ));
         }
+        return JvmMethodParameterMeaning.regular(new ValueParameterDescriptorImpl(
+                containingDeclaration,
+                i,
+                Collections.<AnnotationDescriptor>emptyList(), // TODO
+                name,
+                transformedType,
+                false,
+                varargElementType
+        ));
     }
 
     @NotNull
@@ -182,9 +160,5 @@ public final class JavaValueParameterResolver {
         public static JvmMethodParameterMeaning regular(@NotNull ValueParameterDescriptor valueParameterDescriptor) {
             return new JvmMethodParameterMeaning(JvmMethodParameterKind.REGULAR, null, valueParameterDescriptor);
         }
-
-        public static JvmMethodParameterMeaning typeInfo() {
-            return new JvmMethodParameterMeaning(JvmMethodParameterKind.TYPE_INFO, null, null);
-        }
     }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java

@@ -1,56 +0,0 @@
-/*
- * Copyright 2010-2013 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.scope;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
-import org.jetbrains.jet.lang.resolve.java.provider.KotlinNamespacePsiDeclarationProvider;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
-
-import java.util.Collection;
-import java.util.Set;
-
-public final class JavaScopeForKotlinNamespace extends JavaPackageScope {
-    @NotNull
-    private final KotlinNamespacePsiDeclarationProvider declarationProvider;
-
-    public JavaScopeForKotlinNamespace(
-            @NotNull NamespaceDescriptor descriptor,
-            @NotNull KotlinNamespacePsiDeclarationProvider declarationProvider,
-            @NotNull FqName packageFQN,
-            @NotNull JavaSemanticServices semanticServices
-    ) {
-        super(descriptor, declarationProvider, packageFQN, semanticServices);
-        this.declarationProvider = declarationProvider;
-    }
-
-    @NotNull
-    @Override
-    protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
-        return getResolver().resolveFunctionGroup(name, declarationProvider, descriptor);
-    }
-
-    @NotNull
-    @Override
-    protected Collection<ClassDescriptor> computeInnerClasses() {
-        return getResolver().resolveInnerClasses(declarationProvider);
-    }
-}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PropertyPsiDataElement.java

@@ -35,19 +35,6 @@ public final class PropertyPsiDataElement {
     private final TypeSource type;
     @Nullable
     private final TypeSource receiverType;
-    
-    
-    public PropertyPsiDataElement(
-            @NotNull PsiMethodWrapper method,
-            boolean getter,
-            @NotNull TypeSource type,
-            @Nullable TypeSource receiverType
-    ) {
-        this.member = method;
-        this.type = type;
-        this.receiverType = receiverType;
-        this.getter = getter;
-    }
 
     public PropertyPsiDataElement(@NotNull PsiFieldWrapper field, @NotNull TypeSource type, @Nullable TypeSource receiverType) {
         this.member = field;

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiClassWrapper.java

@@ -18,8 +18,6 @@ package org.jetbrains.jet.lang.resolve.java.wrapper;
 
 import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
-import org.jetbrains.jet.lang.resolve.java.kt.JetPackageClassAnnotation;
 
 public class PsiClassWrapper {
 
@@ -38,23 +36,4 @@ public class PsiClassWrapper {
     public PsiClass getPsiClass() {
         return psiClass;
     }
-    
-    private JetClassAnnotation jetClass;
-    private JetPackageClassAnnotation jetPackageClass;
-
-    @NotNull
-    public JetClassAnnotation getJetClass() {
-        if (jetClass == null) {
-            jetClass = JetClassAnnotation.get(psiClass);
-        }
-        return jetClass;
-    }
-
-    @NotNull
-    public JetPackageClassAnnotation getJetPackageClass() {
-        if (jetPackageClass == null) {
-            jetPackageClass = JetPackageClassAnnotation.get(psiClass);
-        }
-        return jetPackageClass;
-    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiMethodWrapper.java

@@ -22,8 +22,6 @@ import com.intellij.psi.PsiParameter;
 import com.intellij.psi.PsiType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.java.kt.JetConstructorAnnotation;
-import org.jetbrains.jet.lang.resolve.java.kt.JetMethodAnnotation;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -33,8 +31,9 @@ public class PsiMethodWrapper extends PsiMemberWrapper {
     public PsiMethodWrapper(@NotNull PsiMethod psiMethod) {
         super(psiMethod);
     }
-    
+
     private List<PsiParameterWrapper> parameters;
+
     @NotNull
     public List<PsiParameterWrapper> getParameters() {
         if (parameters == null) {
@@ -47,29 +46,6 @@ public class PsiMethodWrapper extends PsiMemberWrapper {
         return parameters;
     }
 
-    @NotNull
-    public PsiParameterWrapper getParameter(int i) {
-        return getParameters().get(i);
-    }
-
-    private JetMethodAnnotation jetMethodAnnotation;
-    @NotNull
-    public JetMethodAnnotation getJetMethodAnnotation() {
-        if (jetMethodAnnotation == null) {
-            jetMethodAnnotation = JetMethodAnnotation.get(getPsiMethod());
-        }
-        return jetMethodAnnotation;
-    }
-
-    private JetConstructorAnnotation jetConstructorAnnotation;
-    @NotNull
-    public JetConstructorAnnotation getJetConstructorAnnotation() {
-        if (jetConstructorAnnotation == null) {
-            jetConstructorAnnotation = JetConstructorAnnotation.get(getPsiMethod());
-        }
-        return jetConstructorAnnotation;
-    }
-
     @Override
     public boolean isAbstract() {
         return psiMember.hasModifierProperty(PsiModifier.ABSTRACT);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiParameterWrapper.java

@@ -18,36 +18,16 @@ package org.jetbrains.jet.lang.resolve.java.wrapper;
 
 import com.intellij.psi.PsiParameter;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.java.kt.JetTypeParameterAnnotation;
-import org.jetbrains.jet.lang.resolve.java.kt.JetValueParameterAnnotation;
 
 public class PsiParameterWrapper {
     private final PsiParameter psiParameter;
 
     public PsiParameterWrapper(@NotNull PsiParameter psiParameter) {
         this.psiParameter = psiParameter;
-
-        this.jetValueParameter = JetValueParameterAnnotation.get(psiParameter);
-        this.jetTypeParameter = JetTypeParameterAnnotation.get(psiParameter);
     }
 
-    @NotNull
-    private final JetValueParameterAnnotation jetValueParameter;
-    @NotNull
-    private final JetTypeParameterAnnotation jetTypeParameter;
-
     @NotNull
     public PsiParameter getPsiParameter() {
         return psiParameter;
     }
-
-    @NotNull
-    public JetValueParameterAnnotation getJetValueParameter() {
-        return jetValueParameter;
-    }
-
-    @NotNull
-    public JetTypeParameterAnnotation getJetTypeParameter() {
-        return jetTypeParameter;
-    }
 }