Extract interface out of JavaClass

2013-08-19 19:40:50 +04:00
parent c64cfd7f76
commit ac4561a9e2
8 changed files with 259 additions and 165 deletions
@@ -21,6 +21,7 @@ import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
+import org.jetbrains.jet.lang.resolve.java.structure.JavaClassImpl;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaPackageImpl;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -39,7 +40,7 @@ public class JavaClassFinderImpl implements JavaClassFinder {
    @Override
    public JavaClass findClass(@NotNull FqName fqName) {
        PsiClass psiClass = psiClassFinder.findPsiClass(fqName);
-        return psiClass == null ? null : new JavaClass(psiClass);
+        return psiClass == null ? null : new JavaClassImpl(psiClass);
    }

    @Nullable
@@ -18,18 +18,18 @@ package org.jetbrains.jet.lang.resolve.java;

 import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
+import org.jetbrains.jet.lang.resolve.java.structure.JavaClassImpl;

 public class JavaResolverPsiUtils {
    private JavaResolverPsiUtils() {
    }

    public static boolean isCompiledKotlinClass(@NotNull PsiClass psiClass) {
-        return DescriptorResolverUtils.isCompiledKotlinClass(new JavaClass(psiClass));
+        return DescriptorResolverUtils.isCompiledKotlinClass(new JavaClassImpl(psiClass));
    }

    public static boolean isCompiledKotlinPackageClass(@NotNull PsiClass psiClass) {
-        return DescriptorResolverUtils.isCompiledKotlinPackageClass(new JavaClass(psiClass));
+        return DescriptorResolverUtils.isCompiledKotlinPackageClass(new JavaClassImpl(psiClass));
    }

    public static boolean isCompiledKotlinClassOrPackageClass(@NotNull PsiClass psiClass) {
@@ -16,175 +16,69 @@

 package org.jetbrains.jet.lang.resolve.java.structure;

-import com.intellij.psi.JavaPsiFacade;
 import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiCompiledElement;
-import com.intellij.psi.PsiTypeParameter;
-import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassKind;
 import org.jetbrains.jet.lang.descriptors.Modality;
-import org.jetbrains.jet.lang.descriptors.Visibility;
-import org.jetbrains.jet.lang.resolve.java.jetAsJava.JetJavaMirrorMarker;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;

 import java.util.Collection;

-import static org.jetbrains.jet.lang.resolve.java.structure.JavaElementCollectionFromPsiArrayUtil.*;
+public interface JavaClass
+        extends JavaClassifier, JavaNamedElement, JavaTypeParameterListOwner, JavaModifierListOwner, JavaAnnotationOwner {
+    @NotNull
+    @Override
+    PsiClass getPsi();

-public class JavaClass extends JavaClassifierImpl
-        implements JavaNamedElement, JavaTypeParameterListOwner, JavaModifierListOwner, JavaAnnotationOwner {
-    public enum OriginKind {
+    @NotNull
+    Collection<JavaClass> getInnerClasses();
+
+    @Nullable
+    FqName getFqName();
+
+    boolean isInterface();
+
+    boolean isAnnotationType();
+
+    boolean isEnum();
+
+    @NotNull
+    ClassKind getKind();
+
+    @Nullable
+    JavaClass getOuterClass();
+
+    @NotNull
+    Modality getModality();
+
+    @NotNull
+    Collection<JavaClassifierType> getSupertypes();
+
+    @NotNull
+    Collection<JavaMethod> getMethods();
+
+    @NotNull
+    Collection<JavaMethod> getAllMethods();
+
+    @NotNull
+    Collection<JavaField> getFields();
+
+    @NotNull
+    Collection<JavaField> getAllFields();
+
+    @NotNull
+    Collection<JavaMethod> getConstructors();
+
+    @NotNull
+    JavaClassifierType getDefaultType();
+
+    @NotNull
+    OriginKind getOriginKind();
+
+    enum OriginKind {
        COMPILED,
        SOURCE,
        KOTLIN_LIGHT_CLASS
    }
-
-    public JavaClass(@NotNull PsiClass psiClass) {
-        super(psiClass);
-        assert !(psiClass instanceof PsiTypeParameter)
-                : "PsiTypeParameter should be wrapped in JavaTypeParameter, not JavaClass: use JavaClassifier.create()";
-    }
-
-    @NotNull
-    public Collection<JavaClass> getInnerClasses() {
-        return classes(getPsi().getInnerClasses());
-    }
-
-    @Nullable
-    public FqName getFqName() {
-        String qualifiedName = getPsi().getQualifiedName();
-        return qualifiedName == null ? null : new FqName(qualifiedName);
-    }
-
-    @NotNull
-    @Override
-    public Name getName() {
-        return Name.identifier(getPsi().getName());
-    }
-
-    public boolean isInterface() {
-        return getPsi().isInterface();
-    }
-
-    public boolean isAnnotationType() {
-        return getPsi().isAnnotationType();
-    }
-
-    public boolean isEnum() {
-        return getPsi().isEnum();
-    }
-
-    @NotNull
-    public ClassKind getKind() {
-        if (isInterface()) {
-            return isAnnotationType() ? ClassKind.ANNOTATION_CLASS : ClassKind.TRAIT;
-        }
-        return isEnum() ? ClassKind.ENUM_CLASS : ClassKind.CLASS;
-    }
-
-    @Nullable
-    public JavaClass getOuterClass() {
-        PsiClass outer = getPsi().getContainingClass();
-        return outer == null ? null : new JavaClass(outer);
-    }
-
-    @NotNull
-    public Modality getModality() {
-        return isAnnotationType() ? Modality.FINAL : Modality.convertFromFlags(isAbstract() || isInterface(), !isFinal());
-    }
-
-    @NotNull
-    @Override
-    public Collection<JavaTypeParameter> getTypeParameters() {
-        return typeParameters(getPsi().getTypeParameters());
-    }
-
-    @SuppressWarnings("unchecked")
-    @NotNull
-    public Collection<JavaClassifierType> getSupertypes() {
-        // TODO: getPsi().getSuperTypes() ?
-        Collection<JavaClassifierType> superClasses = classifierTypes(getPsi().getExtendsListTypes());
-        Collection<JavaClassifierType> superInterfaces = classifierTypes(getPsi().getImplementsListTypes());
-        return ContainerUtil.collect(ContainerUtil.concat(superClasses, superInterfaces).iterator());
-    }
-
-    @NotNull
-    public Collection<JavaMethod> getMethods() {
-        return methods(getPsi().getMethods());
-    }
-
-    @NotNull
-    public Collection<JavaMethod> getAllMethods() {
-        return methods(getPsi().getAllMethods());
-    }
-
-    @NotNull
-    public Collection<JavaField> getFields() {
-        return fields(getPsi().getFields());
-    }
-
-    @NotNull
-    public Collection<JavaField> getAllFields() {
-        return fields(getPsi().getAllFields());
-    }
-
-    @NotNull
-    public Collection<JavaMethod> getConstructors() {
-        return methods(getPsi().getConstructors());
-    }
-
-    @Override
-    public boolean isAbstract() {
-        return JavaElementUtil.isAbstract(this);
-    }
-
-    @Override
-    public boolean isStatic() {
-        return JavaElementUtil.isStatic(this);
-    }
-
-    @Override
-    public boolean isFinal() {
-        return JavaElementUtil.isFinal(this);
-    }
-
-    @NotNull
-    @Override
-    public Visibility getVisibility() {
-        return JavaElementUtil.getVisibility(this);
-    }
-
-    @NotNull
-    @Override
-    public Collection<JavaAnnotation> getAnnotations() {
-        return JavaElementUtil.getAnnotations(this);
-    }
-
-    @Nullable
-    @Override
-    public JavaAnnotation findAnnotation(@NotNull FqName fqName) {
-        return JavaElementUtil.findAnnotation(this, fqName);
-    }
-
-    @NotNull
-    public JavaClassifierType getDefaultType() {
-        return new JavaClassifierTypeImpl(JavaPsiFacade.getElementFactory(getPsi().getProject()).createType(getPsi()));
-    }
-
-    @NotNull
-    public OriginKind getOriginKind() {
-        PsiClass psiClass = getPsi();
-        if (psiClass instanceof JetJavaMirrorMarker) {
-            return OriginKind.KOTLIN_LIGHT_CLASS;
-        }
-        else if (psiClass instanceof PsiCompiledElement) {
-            return OriginKind.COMPILED;
-        }
-        else {
-            return OriginKind.SOURCE;
-        }
-    }
 }
@@ -0,0 +1,199 @@
+/*
+ * 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.structure;
+
+import com.intellij.psi.JavaPsiFacade;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiCompiledElement;
+import com.intellij.psi.PsiTypeParameter;
+import com.intellij.util.containers.ContainerUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.ClassKind;
+import org.jetbrains.jet.lang.descriptors.Modality;
+import org.jetbrains.jet.lang.descriptors.Visibility;
+import org.jetbrains.jet.lang.resolve.java.jetAsJava.JetJavaMirrorMarker;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
+
+import java.util.Collection;
+
+import static org.jetbrains.jet.lang.resolve.java.structure.JavaElementCollectionFromPsiArrayUtil.*;
+
+public class JavaClassImpl extends JavaClassifierImpl implements JavaClass {
+    public JavaClassImpl(@NotNull PsiClass psiClass) {
+        super(psiClass);
+        assert !(psiClass instanceof PsiTypeParameter)
+                : "PsiTypeParameter should be wrapped in JavaTypeParameter, not JavaClass: use JavaClassifier.create()";
+    }
+
+    @Override
+    @NotNull
+    public Collection<JavaClass> getInnerClasses() {
+        return classes(getPsi().getInnerClasses());
+    }
+
+    @Override
+    @Nullable
+    public FqName getFqName() {
+        String qualifiedName = getPsi().getQualifiedName();
+        return qualifiedName == null ? null : new FqName(qualifiedName);
+    }
+
+    @NotNull
+    @Override
+    public Name getName() {
+        return Name.identifier(getPsi().getName());
+    }
+
+    @Override
+    public boolean isInterface() {
+        return getPsi().isInterface();
+    }
+
+    @Override
+    public boolean isAnnotationType() {
+        return getPsi().isAnnotationType();
+    }
+
+    @Override
+    public boolean isEnum() {
+        return getPsi().isEnum();
+    }
+
+    @Override
+    @NotNull
+    public ClassKind getKind() {
+        if (isInterface()) {
+            return isAnnotationType() ? ClassKind.ANNOTATION_CLASS : ClassKind.TRAIT;
+        }
+        return isEnum() ? ClassKind.ENUM_CLASS : ClassKind.CLASS;
+    }
+
+    @Override
+    @Nullable
+    public JavaClass getOuterClass() {
+        PsiClass outer = getPsi().getContainingClass();
+        return outer == null ? null : new JavaClassImpl(outer);
+    }
+
+    @Override
+    @NotNull
+    public Modality getModality() {
+        return isAnnotationType() ? Modality.FINAL : Modality.convertFromFlags(isAbstract() || isInterface(), !isFinal());
+    }
+
+    @NotNull
+    @Override
+    public Collection<JavaTypeParameter> getTypeParameters() {
+        return typeParameters(getPsi().getTypeParameters());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    @NotNull
+    public Collection<JavaClassifierType> getSupertypes() {
+        // TODO: getPsi().getSuperTypes() ?
+        Collection<JavaClassifierType> superClasses = classifierTypes(getPsi().getExtendsListTypes());
+        Collection<JavaClassifierType> superInterfaces = classifierTypes(getPsi().getImplementsListTypes());
+        return ContainerUtil.collect(ContainerUtil.concat(superClasses, superInterfaces).iterator());
+    }
+
+    @Override
+    @NotNull
+    public Collection<JavaMethod> getMethods() {
+        return methods(getPsi().getMethods());
+    }
+
+    @Override
+    @NotNull
+    public Collection<JavaMethod> getAllMethods() {
+        return methods(getPsi().getAllMethods());
+    }
+
+    @Override
+    @NotNull
+    public Collection<JavaField> getFields() {
+        return fields(getPsi().getFields());
+    }
+
+    @Override
+    @NotNull
+    public Collection<JavaField> getAllFields() {
+        return fields(getPsi().getAllFields());
+    }
+
+    @Override
+    @NotNull
+    public Collection<JavaMethod> getConstructors() {
+        return methods(getPsi().getConstructors());
+    }
+
+    @Override
+    public boolean isAbstract() {
+        return JavaElementUtil.isAbstract(this);
+    }
+
+    @Override
+    public boolean isStatic() {
+        return JavaElementUtil.isStatic(this);
+    }
+
+    @Override
+    public boolean isFinal() {
+        return JavaElementUtil.isFinal(this);
+    }
+
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return JavaElementUtil.getVisibility(this);
+    }
+
+    @NotNull
+    @Override
+    public Collection<JavaAnnotation> getAnnotations() {
+        return JavaElementUtil.getAnnotations(this);
+    }
+
+    @Nullable
+    @Override
+    public JavaAnnotation findAnnotation(@NotNull FqName fqName) {
+        return JavaElementUtil.findAnnotation(this, fqName);
+    }
+
+    @Override
+    @NotNull
+    public JavaClassifierType getDefaultType() {
+        return new JavaClassifierTypeImpl(JavaPsiFacade.getElementFactory(getPsi().getProject()).createType(getPsi()));
+    }
+
+    @Override
+    @NotNull
+    public OriginKind getOriginKind() {
+        PsiClass psiClass = getPsi();
+        if (psiClass instanceof JetJavaMirrorMarker) {
+            return OriginKind.KOTLIN_LIGHT_CLASS;
+        }
+        else if (psiClass instanceof PsiCompiledElement) {
+            return OriginKind.COMPILED;
+        }
+        else {
+            return OriginKind.SOURCE;
+        }
+    }
+}
@@ -37,7 +37,7 @@ public abstract class JavaClassifierImpl extends JavaElementImpl implements Java
            return new JavaTypeParameterImpl((PsiTypeParameter) psiClass);
        }
        else {
-            return new JavaClass(psiClass);
+            return new JavaClassImpl(psiClass);
        }
    }
 }
@@ -34,7 +34,7 @@ public class JavaElementCollectionFromPsiArrayUtil {
        if (classes.length == 0) return Collections.emptyList();
        List<JavaClass> result = new ArrayList<JavaClass>(classes.length);
        for (PsiClass psiClass : classes) {
-            result.add(new JavaClass(psiClass));
+            result.add(new JavaClassImpl(psiClass));
        }
        return result;
    }
@@ -50,7 +50,7 @@ public abstract class JavaMemberImpl extends JavaElementImpl implements JavaMemb
    public JavaClass getContainingClass() {
        PsiClass psiClass = getPsi().getContainingClass();
        assert psiClass != null : "Member must have a containing class: " + getPsi();
-        return new JavaClass(psiClass);
+        return new JavaClassImpl(psiClass);
    }

    @Override
@@ -62,7 +62,7 @@ public class JavaTypeParameterImpl extends JavaClassifierImpl implements JavaTyp
            return new JavaMethodImpl((PsiMethod) owner);
        }
        else if (owner instanceof PsiClass) {
-            return new JavaClass((PsiClass) owner);
+            return new JavaClassImpl((PsiClass) owner);
        }
        else if (owner != null) {
            throw new UnsupportedOperationException("Unsupported type parameter list owner: " + owner);