org.jetbrains.plugins.groovy.lang.psi.impl.statements.typedef.GrTypeDefinitionMembersCache Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of groovy-psi Show documentation
Show all versions of groovy-psi Show documentation
A packaging of the IntelliJ Community Edition groovy-psi library.
This is release number 1 of trunk branch 142.
The newest version!
/*
* Copyright 2000-2014 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.plugins.groovy.lang.psi.impl.statements.typedef;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.util.Condition;
import com.intellij.openapi.util.SimpleModificationTracker;
import com.intellij.psi.*;
import com.intellij.psi.infos.CandidateInfo;
import com.intellij.psi.util.*;
import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierFlags;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrField;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrImplementsClause;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinitionBody;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrAccessorMethod;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrReflectedMethod;
import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightMethodBuilder;
import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrTraitField;
import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrTraitMethod;
import org.jetbrains.plugins.groovy.lang.psi.util.GrClassImplUtil;
import org.jetbrains.plugins.groovy.lang.psi.util.GrTraitUtil;
import org.jetbrains.plugins.groovy.lang.resolve.ast.AstTransformContributor;
import java.util.*;
/**
* Created by Max Medvedev on 03/03/14
*/
public class GrTypeDefinitionMembersCache {
private static final Logger LOG = Logger.getInstance(GrTypeDefinitionMembersCache.class);
private static final Condition CONSTRUCTOR_CONDITION = new Condition() {
@Override
public boolean value(PsiMethod method) {
return method.isConstructor();
}
};
private final SimpleModificationTracker myTreeChangeTracker = new SimpleModificationTracker();
private final GrTypeDefinition myDefinition;
public GrTypeDefinitionMembersCache(GrTypeDefinition definition) {
myDefinition = definition;
}
public GrMethod[] getCodeMethods() {
return CachedValuesManager.getCachedValue(myDefinition, new CachedValueProvider() {
@Nullable
@Override
public Result compute() {
GrTypeDefinitionBody body = myDefinition.getBody();
GrMethod[] methods = body != null ? body.getMethods() : GrMethod.EMPTY_ARRAY;
return Result.create(methods, myTreeChangeTracker);
}
});
}
public GrMethod[] getCodeConstructors() {
return CachedValuesManager.getCachedValue(myDefinition, new CachedValueProvider() {
@Nullable
@Override
public Result compute() {
GrTypeDefinitionBody body = myDefinition.getBody();
GrMethod[] methods;
if (body != null) {
List result = ContainerUtil.findAll(body.getMethods(), CONSTRUCTOR_CONDITION);
methods = result.toArray(new GrMethod[result.size()]);
}
else {
methods = GrMethod.EMPTY_ARRAY;
}
return Result.create(methods, myTreeChangeTracker);
}
});
}
public PsiMethod[] getConstructors() {
return CachedValuesManager.getCachedValue(myDefinition, new CachedValueProvider() {
@Nullable
@Override
public Result compute() {
List result = ContainerUtil.findAll(myDefinition.getMethods(), CONSTRUCTOR_CONDITION);
return Result.create(result.toArray(new PsiMethod[result.size()]), myTreeChangeTracker,
PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
}
});
}
public PsiClass[] getInnerClasses() {
return CachedValuesManager.getCachedValue(myDefinition, new CachedValueProvider() {
@Nullable
@Override
public Result compute() {
final GrTypeDefinitionBody body = myDefinition.getBody();
PsiClass[] inners = body != null ? body.getInnerClasses() : PsiClass.EMPTY_ARRAY;
return Result.create(inners, myTreeChangeTracker);
}
});
}
public GrField[] getFields() {
return CachedValuesManager.getCachedValue(myDefinition, new CachedValueProvider() {
@Nullable
@Override
public Result compute() {
List fields = getFieldsImpl();
return Result.create(fields.toArray(new GrField[fields.size()]), myTreeChangeTracker, PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
}
});
}
private List getFieldsImpl() {
List fields = ContainerUtil.newArrayList(myDefinition.getCodeFields());
fields.addAll(new TraitCollector().collectFields());
fields.addAll(getSyntheticFields());
return fields;
}
private List getSyntheticFields() {
return CachedValuesManager.getCachedValue(myDefinition, new CachedValueProvider>() {
@Nullable
@Override
public Result> compute() {
return Result.create(AstTransformContributor.runContributorsForFields(myDefinition), myTreeChangeTracker,
PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
}
});
}
public PsiMethod[] getMethods() {
return CachedValuesManager.getCachedValue(myDefinition, new CachedValueProvider() {
@Override
public Result compute() {
List result = ContainerUtil.newArrayList();
GrClassImplUtil.collectMethodsFromBody(myDefinition, result);
result.addAll(new TraitCollector().collectMethods(result));
for (PsiMethod method : AstTransformContributor.runContributorsForMethods(myDefinition)) {
GrClassImplUtil.addExpandingReflectedMethods(result, method);
}
for (GrField field : getSyntheticFields()) {
if (!field.isProperty()) continue;
ContainerUtil.addIfNotNull(result, field.getSetter());
Collections.addAll(result, field.getGetters());
}
return Result.create(result.toArray(new PsiMethod[result.size()]), myTreeChangeTracker,
PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
}
});
}
public void dropCaches() {
myTreeChangeTracker.incModificationCount();
}
private class TraitCollector {
private abstract class TraitProcessor {
private final ArrayList result = ContainerUtil.newArrayList();
private final Set processed = ContainerUtil.newHashSet();
public TraitProcessor(@NotNull GrTypeDefinition superClass, @NotNull PsiSubstitutor substitutor) {
process(superClass, substitutor);
}
@NotNull
public List getResult() {
return result;
}
private void process(@NotNull GrTypeDefinition trait, @NotNull PsiSubstitutor substitutor) {
assert trait.isTrait();
if (!processed.add(trait)) return;
processTrait(trait, substitutor);
List traits = getSuperTraitsByCorrectOrder(trait.getSuperTypes());
for (PsiClassType.ClassResolveResult resolveResult :traits) {
PsiClass superClass = resolveResult.getElement();
if (GrTraitUtil.isTrait(superClass)) {
final PsiSubstitutor superSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(superClass, trait, substitutor);
process((GrTypeDefinition)superClass, superSubstitutor);
}
}
}
protected abstract void processTrait(@NotNull GrTypeDefinition trait, @NotNull PsiSubstitutor substitutor);
protected void addCandidate(T element, PsiSubstitutor substitutor) {
result.add(new CandidateInfo(element, substitutor));
}
}
@NotNull
public List collectMethods(@NotNull List codeMethods) {
if (myDefinition.isInterface() && !myDefinition.isTrait()) return Collections.emptyList();
GrImplementsClause clause = myDefinition.getImplementsClause();
if (clause == null) return Collections.emptyList();
PsiClassType[] types = clause.getReferencedTypes();
List traits = getSuperTraitsByCorrectOrder(types);
if (traits.isEmpty()) return Collections.emptyList();
Set existingSignatures = ContainerUtil.newHashSet(ContainerUtil.map(codeMethods, new Function() {
@Override
public MethodSignature fun(PsiMethod method) {
return method.getSignature(PsiSubstitutor.EMPTY);
}
}));
List result = ContainerUtil.newArrayList();
for (PsiClassType.ClassResolveResult resolveResult : traits) {
GrTypeDefinition trait = (GrTypeDefinition)resolveResult.getElement();
LOG.assertTrue(trait != null);
List concreteTraitMethods = new TraitProcessor(trait, resolveResult.getSubstitutor()) {
protected void processTrait(@NotNull GrTypeDefinition trait, @NotNull PsiSubstitutor substitutor) {
for (GrMethod method : trait.getCodeMethods()) {
if (!method.getModifierList().hasExplicitModifier(PsiModifier.ABSTRACT)) {
addCandidate(method, substitutor);
}
}
for (GrField field : trait.getCodeFields()) {
if (!field.isProperty()) continue;
for (GrAccessorMethod method : field.getGetters()) {
addCandidate(method, substitutor);
}
GrAccessorMethod setter = field.getSetter();
if (setter != null) {
addCandidate(setter, substitutor);
}
}
}
}.getResult();
for (CandidateInfo candidateInfo : concreteTraitMethods) {
List methodsToAdd = getExpandingMethods(candidateInfo);
for (GrMethod impl : methodsToAdd) {
if (existingSignatures.add(impl.getSignature(PsiSubstitutor.EMPTY))) {
result.add(impl);
}
}
}
}
return result;
}
@NotNull
public List collectFields() {
if (myDefinition.isInterface() && !myDefinition.isTrait()) return Collections.emptyList();
List result = ContainerUtil.newArrayList();
if (myDefinition.isTrait()) {
for (GrField field : myDefinition.getCodeFields()) {
result.add(new GrTraitField(field, myDefinition, PsiSubstitutor.EMPTY));
}
}
GrImplementsClause clause = myDefinition.getImplementsClause();
if (clause == null) return result;
PsiClassType[] types = clause.getReferencedTypes();
List traits = getSuperTraitsByCorrectOrder(types);
for (PsiClassType.ClassResolveResult resolveResult : traits) {
GrTypeDefinition trait = (GrTypeDefinition)resolveResult.getElement();
LOG.assertTrue(trait != null);
List traitFields = new TraitProcessor(trait, resolveResult.getSubstitutor()) {
protected void processTrait(@NotNull GrTypeDefinition trait, @NotNull PsiSubstitutor substitutor) {
for (GrField field : trait.getCodeFields()) {
addCandidate(field, substitutor);
}
}
}.getResult();
for (CandidateInfo candidateInfo : traitFields) {
result.add(new GrTraitField(((PsiField)candidateInfo.getElement()), myDefinition, candidateInfo.getSubstitutor()));
}
}
if (myDefinition.isTrait()) {
for (GrField field : myDefinition.getCodeFields()) {
result.add(new GrTraitField(field, myDefinition, PsiSubstitutor.EMPTY));
}
}
return result;
}
@NotNull
private List getExpandingMethods(@NotNull CandidateInfo candidateInfo) {
PsiMethod method = (PsiMethod)candidateInfo.getElement();
GrLightMethodBuilder implementation = GrTraitMethod.create(method, candidateInfo.getSubstitutor()).setContainingClass(myDefinition);
implementation.getModifierList().removeModifier(GrModifierFlags.ABSTRACT_MASK);
GrReflectedMethod[] reflectedMethods = implementation.getReflectedMethods();
return reflectedMethods.length > 0 ? Arrays.asList(reflectedMethods) : Collections.singletonList(implementation);
}
@NotNull
private List getSuperTraitsByCorrectOrder(@NotNull PsiClassType[] types) {
List traits = ContainerUtil.newArrayList();
for (int i = types.length - 1; i >= 0; i--) {
PsiClassType.ClassResolveResult resolveResult = types[i].resolveGenerics();
PsiClass superClass = resolveResult.getElement();
if (GrTraitUtil.isTrait(superClass)) {
traits.add(resolveResult);
}
}
return traits;
}
}
}