Common class for Kotlin light classes with returning light elements for methods and fields

2013-11-01 18:23:26 +04:00
parent 6aeaceae8d
commit aa91ae6843
4 changed files with 293 additions and 7 deletions
@@ -29,12 +29,12 @@ import com.intellij.psi.*;
 import com.intellij.psi.impl.PsiManagerImpl;
 import com.intellij.psi.impl.compiled.ClsFileImpl;
 import com.intellij.psi.impl.java.stubs.PsiJavaFileStub;
-import com.intellij.psi.impl.light.AbstractLightClass;
 import com.intellij.psi.impl.light.LightModifierList;
 import com.intellij.psi.impl.light.LightTypeParameterListBuilder;
 import com.intellij.psi.stubs.PsiClassHolderFileStub;
 import com.intellij.psi.util.CachedValue;
 import com.intellij.psi.util.CachedValuesManager;
+import com.intellij.util.ArrayUtil;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
@@ -52,12 +52,13 @@ import org.jetbrains.jet.lexer.JetKeywordToken;
 import org.jetbrains.jet.plugin.JetLanguage;

 import javax.swing.*;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;

 import static org.jetbrains.jet.lexer.JetTokens.*;

-public class KotlinLightClassForExplicitDeclaration extends AbstractLightClass implements KotlinLightClass, JetJavaMirrorMarker {
+public class KotlinLightClassForExplicitDeclaration extends KotlinWrappingLightClass implements KotlinLightClass, JetJavaMirrorMarker {
    private final static Key<CachedValue<PsiJavaFileStub>> JAVA_API_STUB = Key.create("JAVA_API_STUB");

    @Nullable
@@ -325,7 +326,7 @@ public class KotlinLightClassForExplicitDeclaration extends AbstractLightClass i
            psiModifiers.add(PsiModifier.STATIC);
        }

-        return psiModifiers.toArray(new String[psiModifiers.size()]);
+        return ArrayUtil.toStringArray(psiModifiers);
    }

    private boolean isAbstract(@NotNull JetClassOrObject object) {
@@ -405,4 +406,11 @@ public class KotlinLightClassForExplicitDeclaration extends AbstractLightClass i
            return KotlinLightClass.class.getSimpleName() + ":" + e.toString();
        }
    }
+
+    @NotNull
+    @Override
+    public List<PsiClass> getOwnInnerClasses() {
+        // TODO: Should return inner class wrapper
+        return Arrays.asList(getDelegate().getInnerClasses());
+    }
 }
@@ -22,7 +22,6 @@ import com.intellij.navigation.ItemPresentationProviders;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.java.stubs.PsiJavaFileStub;
-import com.intellij.psi.impl.light.AbstractLightClass;
 import com.intellij.psi.impl.light.LightEmptyImplementsList;
 import com.intellij.psi.impl.light.LightModifierList;
 import com.intellij.psi.javadoc.PsiDocComment;
@@ -40,8 +39,10 @@ import org.jetbrains.jet.plugin.JetLanguage;

 import javax.swing.*;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.List;

-public class KotlinLightClassForPackage extends AbstractLightClass implements KotlinLightClass, JetJavaMirrorMarker {
+public class KotlinLightClassForPackage extends KotlinWrappingLightClass implements KotlinLightClass, JetJavaMirrorMarker {
    private final FqName packageFqName;
    private final FqName packageClassFqName; // derived from packageFqName
    private final GlobalSearchScope searchScope;
@@ -211,8 +212,8 @@ public class KotlinLightClassForPackage extends AbstractLightClass implements Ko

    @NotNull
    @Override
-    public PsiClassInitializer[] getInitializers() {
-        return PsiClassInitializer.EMPTY_ARRAY;
+    public List<PsiClass> getOwnInnerClasses() {
+        return Collections.emptyList();
    }

    @NotNull
@@ -221,6 +222,12 @@ public class KotlinLightClassForPackage extends AbstractLightClass implements Ko
        return PsiClass.EMPTY_ARRAY;
    }

+    @NotNull
+    @Override
+    public PsiClassInitializer[] getInitializers() {
+        return PsiClassInitializer.EMPTY_ARRAY;
+    }
+
    @Nullable
    @Override
    public PsiClass findInnerClassByName(@NonNls String name, boolean checkBases) {
@@ -0,0 +1,122 @@
+/*
+ * 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.asJava;
+
+import com.intellij.lang.Language;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiField;
+import com.intellij.psi.PsiManager;
+import com.intellij.psi.PsiMethod;
+import com.intellij.psi.impl.PsiClassImplUtil;
+import com.intellij.psi.impl.light.AbstractLightClass;
+import org.jetbrains.jet.asJava.light.LightField;
+import com.intellij.psi.impl.light.LightMethod;
+import com.intellij.psi.impl.source.ClassInnerStuffCache;
+import com.intellij.psi.impl.source.PsiExtensibleClass;
+import com.intellij.util.Function;
+import com.intellij.util.containers.ContainerUtil;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public abstract class KotlinWrappingLightClass extends AbstractLightClass implements PsiExtensibleClass {
+    private final ClassInnerStuffCache myInnersCache = new ClassInnerStuffCache(this);
+
+    protected KotlinWrappingLightClass(PsiManager manager, Language language) {
+        super(manager, language);
+    }
+
+    @Override
+    @NotNull
+    public PsiField[] getFields() {
+        return myInnersCache.getFields();
+    }
+
+    @Override
+    @NotNull
+    public PsiMethod[] getMethods() {
+        return myInnersCache.getMethods();
+    }
+
+    @Override
+    @NotNull
+    public PsiMethod[] getConstructors() {
+        return myInnersCache.getConstructors();
+    }
+
+    @Override
+    @NotNull
+    public PsiClass[] getInnerClasses() {
+        return myInnersCache.getInnerClasses();
+    }
+
+    @Override
+    @NotNull
+    public PsiField[] getAllFields() {
+        return PsiClassImplUtil.getAllFields(this);
+    }
+
+    @Override
+    @NotNull
+    public PsiMethod[] getAllMethods() {
+        return PsiClassImplUtil.getAllMethods(this);
+    }
+
+    @Override
+    @NotNull
+    public PsiClass[] getAllInnerClasses() {
+        return PsiClassImplUtil.getAllInnerClasses(this);
+    }
+
+    @Override
+    public PsiField findFieldByName(String name, boolean checkBases) {
+        return myInnersCache.findFieldByName(name, checkBases);
+    }
+
+    @Override
+    @NotNull
+    public PsiMethod[] findMethodsByName(String name, boolean checkBases) {
+        return myInnersCache.findMethodsByName(name, checkBases);
+    }
+
+    @Override
+    public PsiClass findInnerClassByName(String name, boolean checkBases) {
+        return myInnersCache.findInnerClassByName(name, checkBases);
+    }
+
+    @NotNull
+    @Override
+    public List<PsiField> getOwnFields() {
+        return ContainerUtil.map(getDelegate().getFields(), new Function<PsiField, PsiField>() {
+            @Override
+            public PsiField fun(PsiField field) {
+                return new LightField(myManager, field, KotlinWrappingLightClass.this);
+            }
+        });
+    }
+
+    @NotNull
+    @Override
+    public List<PsiMethod> getOwnMethods() {
+        return ContainerUtil.map(getDelegate().getMethods(), new Function<PsiMethod, PsiMethod>() {
+            @Override
+            public PsiMethod fun(PsiMethod method) {
+                return new LightMethod(myManager, method, KotlinWrappingLightClass.this);
+            }
+        });
+    }
+}
@@ -0,0 +1,149 @@
+/*
+ * 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.asJava.light;
+
+import com.intellij.lang.java.JavaLanguage;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.*;
+import com.intellij.psi.impl.light.LightElement;
+import com.intellij.psi.javadoc.PsiDocComment;
+import com.intellij.psi.search.SearchScope;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+// Copy of com.intellij.psi.impl.light.LightField
+@SuppressWarnings("UnnecessaryFinalOnLocalVariableOrParameter")
+public class LightField extends LightElement implements PsiField {
+    private final PsiField myField;
+    private final PsiClass myContainingClass;
+
+    public LightField(@NotNull final PsiManager manager, @NotNull final PsiField field, @NotNull final PsiClass containingClass) {
+        super(manager, JavaLanguage.INSTANCE);
+        myField = field;
+        myContainingClass = containingClass;
+    }
+
+    @Override
+    public void setInitializer(@Nullable final PsiExpression initializer) throws IncorrectOperationException {
+        throw new IncorrectOperationException("Not supported");
+    }
+
+    @NotNull
+    @Override
+    public SearchScope getUseScope() {
+        return myField.getUseScope();
+    }
+
+    @Override
+    public String getName() {
+        return myField.getName();
+    }
+
+    @NotNull
+    @Override
+    public PsiIdentifier getNameIdentifier() {
+        return myField.getNameIdentifier();
+    }
+
+    @Override
+    public PsiDocComment getDocComment() {
+        return myField.getDocComment();
+    }
+
+    @Override
+    public boolean isDeprecated() {
+        return myField.isDeprecated();
+    }
+
+    @Override
+    public PsiClass getContainingClass() {
+        return myContainingClass;
+    }
+
+    @NotNull
+    @Override
+    public PsiType getType() {
+        return myField.getType();
+    }
+
+    @Override
+    public PsiTypeElement getTypeElement() {
+        return myField.getTypeElement();
+    }
+
+    @Override
+    public PsiExpression getInitializer() {
+        return myField.getInitializer();
+    }
+
+    @Override
+    public boolean hasInitializer() {
+        return myField.hasInitializer();
+    }
+
+    @Override
+    public void normalizeDeclaration() throws IncorrectOperationException {
+        throw new IncorrectOperationException("Not supported");
+    }
+
+    @Override
+    public Object computeConstantValue() {
+        return myField.computeConstantValue();
+    }
+
+    @Override
+    public PsiElement setName(@NonNls @NotNull final String name) throws IncorrectOperationException {
+        throw new IncorrectOperationException("Not supported");
+    }
+
+    @Override
+    public PsiModifierList getModifierList() {
+        return myField.getModifierList();
+    }
+
+    @Override
+    public boolean hasModifierProperty(@NonNls @NotNull final String name) {
+        return myField.hasModifierProperty(name);
+    }
+
+    @Override
+    public String getText() {
+        return myField.getText();
+    }
+
+    @Override
+    public PsiElement copy() {
+        return new LightField(myManager, (PsiField)myField.copy(), myContainingClass);
+    }
+
+    @Override
+    public TextRange getTextRange() {
+        return new TextRange(-1, -1);
+    }
+
+    @Override
+    public boolean isValid() {
+        return myContainingClass.isValid();
+    }
+
+    @Override
+    public String toString() {
+        return "PsiField:" + getName();
+    }
+}