diff --git a/annotations/com/intellij/psi/util/annotations.xml b/annotations/com/intellij/psi/util/annotations.xml index b790b4489b1..a89370620f5 100644 --- a/annotations/com/intellij/psi/util/annotations.xml +++ b/annotations/com/intellij/psi/util/annotations.xml @@ -1,4 +1,8 @@ + + + diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightMethodForDeclaration.kt b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightMethodForDeclaration.kt index 069baad8d90..65418154351 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightMethodForDeclaration.kt +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightMethodForDeclaration.kt @@ -23,14 +23,38 @@ import com.intellij.psi.PsiManager import com.intellij.psi.PsiElement import com.intellij.psi.PsiNamedElement import org.jetbrains.jet.lang.psi.JetDeclaration +import com.intellij.psi.PsiParameterList +import org.jetbrains.jet.plugin.JetLanguage +import kotlin.properties.Delegates +import org.jetbrains.jet.asJava.light.LightParameter +import org.jetbrains.jet.asJava.light.LightParameterListBuilder import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod import com.intellij.psi.PsiParameterList import org.jetbrains.jet.plugin.JetLanguage import kotlin.properties.Delegates +import com.intellij.psi.util.CachedValuesManager +import com.intellij.psi.util.PsiModificationTracker +import com.intellij.psi.util.CachedValueProvider +import com.intellij.openapi.application.Result +import com.intellij.psi.util.CachedValue public class KotlinLightMethodForDeclaration(manager: PsiManager, val method: PsiMethod, val jetDeclaration: JetDeclaration, containingClass: PsiClass): LightMethod(manager, method, containingClass), KotlinLightMethod { + private val paramsList: CachedValue by Delegates.blockingLazy { + val cacheManager = CachedValuesManager.getManager(method.getProject()) + cacheManager.createCachedValue({ + val parameterBuilder = LightParameterListBuilder(getManager(), JetLanguage.INSTANCE) + + for ((index, parameter) in method.getParameterList().getParameters().withIndices()) { + val lightParameter = LightParameter(parameter.getName() ?: "p$index", parameter.getType(), this, JetLanguage.INSTANCE) + parameterBuilder.addParameter(lightParameter) + } + + CachedValueProvider.Result.create(parameterBuilder, PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT) + }, false) + } + override fun getNavigationElement() : PsiElement = jetDeclaration override fun getOriginalElement() : PsiElement = jetDeclaration override fun getOrigin(): JetDeclaration? = jetDeclaration @@ -56,6 +80,8 @@ public class KotlinLightMethodForDeclaration(manager: PsiManager, val method: Ps return super.isEquivalentTo(another) } + override fun getParameterList(): PsiParameterList = paramsList.getValue()!! + override fun copy(): PsiElement? { return KotlinLightMethodForDeclaration(getManager()!!, method, jetDeclaration.copy() as JetDeclaration, getContainingClass()!!) } diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/light/LightParameter.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/light/LightParameter.java new file mode 100644 index 00000000000..73d29e3ee12 --- /dev/null +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/light/LightParameter.java @@ -0,0 +1,69 @@ +/* + * 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.Language; +import com.intellij.psi.*; +import org.jetbrains.annotations.NotNull; + +// Based on com.intellij.psi.impl.light.LightParameter +public class LightParameter extends LightVariableBuilder implements PsiParameter { + public static final LightParameter[] EMPTY_ARRAY = new LightParameter[0]; + + private final String myName; + private final PsiElement myDeclarationScope; + private final boolean myVarArgs; + + public LightParameter(@NotNull String name, @NotNull PsiType type, PsiElement declarationScope, Language language) { + this(name, type, declarationScope, language, type instanceof PsiEllipsisType); + } + + public LightParameter(@NotNull String name, @NotNull PsiType type, PsiElement declarationScope, Language language, boolean isVarArgs) { + super(declarationScope.getManager(), name, type, language); + myName = name; + myDeclarationScope = declarationScope; + myVarArgs = isVarArgs; + } + + @NotNull + @Override + public PsiElement getDeclarationScope() { + return myDeclarationScope; + } + + @Override + public void accept(@NotNull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor)visitor).visitParameter(this); + } + } + + public String toString() { + return "Light Parameter"; + } + + @Override + public boolean isVarArgs() { + return myVarArgs; + } + + @Override + @NotNull + public String getName() { + return myName; + } +} diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/light/LightParameterListBuilder.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/light/LightParameterListBuilder.java new file mode 100644 index 00000000000..5a391bf29f3 --- /dev/null +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/light/LightParameterListBuilder.java @@ -0,0 +1,77 @@ +/* + * 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.Language; +import com.intellij.psi.*; +import com.intellij.psi.impl.light.LightElement; +import org.jetbrains.annotations.NotNull; + +import java.util.ArrayList; +import java.util.List; + +// Copy of com.intellij.psi.impl.light.LightParameterListBuilder +public class LightParameterListBuilder extends LightElement implements PsiParameterList { + private final List myParameters = new ArrayList(); + private PsiParameter[] myCachedParameters; + + public LightParameterListBuilder(PsiManager manager, Language language) { + super(manager, language); + } + + public void addParameter(PsiParameter parameter) { + myParameters.add(parameter); + myCachedParameters = null; + } + + @Override + public String toString() { + return "Light parameter lsit"; + } + + @NotNull + @Override + public PsiParameter[] getParameters() { + if (myCachedParameters == null) { + if (myParameters.isEmpty()) { + myCachedParameters = PsiParameter.EMPTY_ARRAY; + } + else { + myCachedParameters = myParameters.toArray(new PsiParameter[myParameters.size()]); + } + } + + return myCachedParameters; + } + + @Override + public int getParameterIndex(PsiParameter parameter) { + return myParameters.indexOf(parameter); + } + + @Override + public int getParametersCount() { + return myParameters.size(); + } + + @Override + public void accept(@NotNull PsiElementVisitor visitor) { + if (visitor instanceof JavaElementVisitor) { + ((JavaElementVisitor) visitor).visitParameterList(this); + } + } +} diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/light/LightVariableBuilder.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/light/LightVariableBuilder.java new file mode 100644 index 00000000000..6e756828ed2 --- /dev/null +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/light/LightVariableBuilder.java @@ -0,0 +1,151 @@ +/* + * 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.Language; +import com.intellij.lang.java.JavaLanguage; +import com.intellij.navigation.NavigationItem; +import com.intellij.psi.*; +import com.intellij.psi.impl.ElementPresentationUtil; +import com.intellij.psi.impl.light.LightElement; +import com.intellij.psi.impl.light.LightModifierList; +import com.intellij.ui.RowIcon; +import com.intellij.util.IncorrectOperationException; +import com.intellij.util.PlatformIcons; +import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import javax.swing.*; + +// Based on com.intellij.psi.impl.light.LightVariableBuilder +public class LightVariableBuilder extends LightElement implements PsiVariable, NavigationItem { + private final String myName; + private final PsiType myType; + private volatile LightModifierList myModifierList; + private volatile Icon myBaseIcon = PlatformIcons.VARIABLE_ICON; + private String myOriginInfo; + + public LightVariableBuilder(@NotNull String name, @NotNull String type, @NotNull PsiElement navigationElement) { + this(name, JavaPsiFacade.getElementFactory(navigationElement.getProject()).createTypeFromText(type, navigationElement), navigationElement); + } + + public LightVariableBuilder(@NotNull String name, @NotNull PsiType type, @NotNull PsiElement navigationElement) { + this(navigationElement.getManager(), name, type, JavaLanguage.INSTANCE); + setNavigationElement(navigationElement); + } + + public LightVariableBuilder(PsiManager manager, @NotNull String name, @NotNull PsiType type, Language language) { + super(manager, language); + myName = name; + myType = type; + myModifierList = new LightModifierList(manager); + } + + @Override + public String toString() { + return "LightVariableBuilder:" + getName(); + } + + @NotNull + @Override + public PsiType getType() { + return myType; + } + + @Override + @NotNull + public PsiModifierList getModifierList() { + return myModifierList; + } + + public T setModifiers(String... modifiers) { + myModifierList = new LightModifierList(getManager(), getLanguage(), modifiers); + return (T)this; + } + + @Override + public boolean hasModifierProperty(@NonNls @NotNull String name) { + return myModifierList.hasModifierProperty(name); + } + + @NotNull + @Override + public String getName() { + return myName; + } + + @Override + public PsiTypeElement getTypeElement() { + return null; + } + + @Override + public PsiExpression getInitializer() { + return null; + } + + @Override + public boolean hasInitializer() { + return false; + } + + @Override + public void normalizeDeclaration() throws IncorrectOperationException { + } + + @Override + public Object computeConstantValue() { + return null; + } + + @Override + public PsiIdentifier getNameIdentifier() { + return null; + } + + @Override + public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException { + throw new UnsupportedOperationException("setName is not implemented yet in org.jetbrains.jet.asJava.light.LightVariableBuilder"); + } + + @Override + protected boolean isVisibilitySupported() { + return true; + } + + @Override + public Icon getElementIcon(final int flags) { + final RowIcon baseIcon = ElementPresentationUtil.createLayeredIcon(myBaseIcon, this, false); + return ElementPresentationUtil.addVisibilityIcon(this, flags, baseIcon); + } + + public T setBaseIcon(Icon baseIcon) { + myBaseIcon = baseIcon; + return (T)this; + } + + //@Nullable + //@Override + //public String getOriginInfo() { + // return myOriginInfo; + //} + + public void setOriginInfo(@Nullable String originInfo) { + myOriginInfo = originInfo; + } +}