diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForExplicitDeclaration.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForExplicitDeclaration.java index a0ca44e8415..0b91e3176c0 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForExplicitDeclaration.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForExplicitDeclaration.java @@ -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> 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 getOwnInnerClasses() { + // TODO: Should return inner class wrapper + return Arrays.asList(getDelegate().getInnerClasses()); + } } diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForPackage.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForPackage.java index a3c47a2e1c9..978a17de48d 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForPackage.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForPackage.java @@ -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 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) { diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinWrappingLightClass.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinWrappingLightClass.java new file mode 100644 index 00000000000..7729bc83eaa --- /dev/null +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinWrappingLightClass.java @@ -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 getOwnFields() { + return ContainerUtil.map(getDelegate().getFields(), new Function() { + @Override + public PsiField fun(PsiField field) { + return new LightField(myManager, field, KotlinWrappingLightClass.this); + } + }); + } + + @NotNull + @Override + public List getOwnMethods() { + return ContainerUtil.map(getDelegate().getMethods(), new Function() { + @Override + public PsiMethod fun(PsiMethod method) { + return new LightMethod(myManager, method, KotlinWrappingLightClass.this); + } + }); + } +} diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/light/LightField.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/light/LightField.java new file mode 100644 index 00000000000..0205398a85c --- /dev/null +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/light/LightField.java @@ -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(); + } +}