From a8400d2abdd1898b9352a3c08eb8dfa3dde02bf8 Mon Sep 17 00:00:00 2001 From: m0rkeulv Date: Sun, 8 Sep 2024 13:08:13 +0200 Subject: [PATCH] Fixed incorrect use of caching and reworked caching of expression evaluations --- .../psi/impl/AbstractHaxeNamedComponent.java | 8 +-- .../plugins/haxe/model/HaxeClassModel.java | 30 +++++------ .../haxe/model/HaxeEnumExtractorModel.java | 19 +++---- .../plugins/haxe/model/HaxeExprFileModel.java | 8 ++- .../plugins/haxe/model/HaxeFileModel.java | 7 ++- .../plugins/haxe/model/HaxeMemberModel.java | 8 +-- .../plugins/haxe/model/HaxeMethodModel.java | 7 ++- .../haxe/model/HaxeStdTypesFileModel.java | 8 ++- .../haxe/model/type/HaxeClassReference.java | 7 ++- .../model/type/HaxeExpressionEvaluator.java | 48 ++++------------- .../HaxeExpressionEvaluatorCacheService.java | 51 +++++++++++++++++++ .../plugins/haxe/model/type/ResultHolder.java | 12 ++--- src/main/resources/META-INF/plugin.xml | 4 ++ 13 files changed, 116 insertions(+), 101 deletions(-) create mode 100644 src/main/java/com/intellij/plugins/haxe/model/type/HaxeExpressionEvaluatorCacheService.java diff --git a/src/main/java/com/intellij/plugins/haxe/lang/psi/impl/AbstractHaxeNamedComponent.java b/src/main/java/com/intellij/plugins/haxe/lang/psi/impl/AbstractHaxeNamedComponent.java index c1354b113..40a694bd5 100644 --- a/src/main/java/com/intellij/plugins/haxe/lang/psi/impl/AbstractHaxeNamedComponent.java +++ b/src/main/java/com/intellij/plugins/haxe/lang/psi/impl/AbstractHaxeNamedComponent.java @@ -67,15 +67,15 @@ public AbstractHaxeNamedComponent(@NotNull ASTNode node) { @Nullable @NonNls public String getName() { - return CachedValuesManager.getProjectPsiDependentCache(this, AbstractHaxeNamedComponent::_getName).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(this, AbstractHaxeNamedComponent::_getName); } - private static CachedValueProvider.Result _getName(AbstractHaxeNamedComponent namedComponent) { + private static String _getName(AbstractHaxeNamedComponent namedComponent) { final HaxeComponentName name = namedComponent.getComponentName(); if (name != null) { - return new CachedValueProvider.Result<>(name.getText(), name, namedComponent); + return name.getText(); } else { - return new CachedValueProvider.Result<>(namedComponent._getNameFromSuper(), namedComponent); + return namedComponent._getNameFromSuper(); } } private String _getNameFromSuper() { diff --git a/src/main/java/com/intellij/plugins/haxe/model/HaxeClassModel.java b/src/main/java/com/intellij/plugins/haxe/model/HaxeClassModel.java index fbb035338..e421bcf71 100644 --- a/src/main/java/com/intellij/plugins/haxe/model/HaxeClassModel.java +++ b/src/main/java/com/intellij/plugins/haxe/model/HaxeClassModel.java @@ -462,22 +462,22 @@ private SpecificTypeReference setSpecificsConstraints(@NotNull HaxeMethodModel m //caching implicit cast method lookup results @NotNull private List getCastToMethods() { - return CachedValuesManager.getProjectPsiDependentCache(haxeClass, HaxeClassModel::getCastToMethodsCached).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(haxeClass, HaxeClassModel::getCastToMethodsCached); } - private static CachedValueProvider.Result> getCastToMethodsCached(@NotNull HaxeClass haxeClass) { + private static List getCastToMethodsCached(@NotNull HaxeClass haxeClass) { List castToMethods = getMethodsWithMetadata(haxeClass.getModel(), "to", HaxeMeta.COMPILE_TIME, null); - return CachedValueProvider.Result.create(castToMethods, haxeClass); + return List.copyOf(castToMethods); } //caching implicit cast method lookup results @NotNull private List getCastFromMethods() { - return CachedValuesManager.getProjectPsiDependentCache(haxeClass, HaxeClassModel::getCastFromMethodsCached).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(haxeClass, HaxeClassModel::getCastFromMethodsCached); } - private static CachedValueProvider.Result> getCastFromMethodsCached(@NotNull HaxeClass haxeClass) { + private static List getCastFromMethodsCached(@NotNull HaxeClass haxeClass) { List castFromMethods = getMethodsWithMetadata(haxeClass.getModel(), "from", HaxeMeta.COMPILE_TIME, null); - return CachedValueProvider.Result.create(castFromMethods, haxeClass); + return List.copyOf(castFromMethods); } @NotNull @@ -677,20 +677,20 @@ public PsiIdentifier getNamePsi() { } @NotNull public List getExtendsList() { - return CachedValuesManager.getProjectPsiDependentCache(haxeClass, HaxeClassModel::getHaxeExtendsListCached).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(haxeClass, HaxeClassModel::getHaxeExtendsListCached); } - private static CachedValueProvider.Result> getHaxeExtendsListCached(@NotNull HaxeClass haxeClass) { + private static List getHaxeExtendsListCached(@NotNull HaxeClass haxeClass) { List list = haxeClass.getHaxeExtendsList(); - return CachedValueProvider.Result.create(list, haxeClass); + return List.copyOf(list); } @NotNull public List getImplementsList() { - return CachedValuesManager.getProjectPsiDependentCache(haxeClass, HaxeClassModel::getHaxeImplementsListCached).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(haxeClass, HaxeClassModel::getHaxeImplementsListCached); } - private static CachedValueProvider.Result> getHaxeImplementsListCached(@NotNull HaxeClass haxeClass) { + private static List getHaxeImplementsListCached(@NotNull HaxeClass haxeClass) { List list = haxeClass.getHaxeImplementsList(); - return CachedValueProvider.Result.create(list, haxeClass); + return List.copyOf(list); } @NotNull @@ -826,13 +826,13 @@ public List getGenericParams() { @Nullable private HaxeGenericParam getGenericParamPsi() { - return CachedValuesManager.getProjectPsiDependentCache(haxeClass, HaxeClassModel::getGenericParamPsiCached).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(haxeClass, HaxeClassModel::getGenericParamPsiCached); } - private static CachedValueProvider.Result getGenericParamPsiCached(@NotNull HaxeClass haxeClass) { + private static HaxeGenericParam getGenericParamPsiCached(@NotNull HaxeClass haxeClass) { boolean isAnonymous = haxeClass instanceof HaxeAnonymousType; HaxeGenericParam param = isAnonymous ? getGenericParamFromParent(haxeClass) : haxeClass.getGenericParam(); - return CachedValueProvider.Result.create(param, haxeClass); + return param; } /** diff --git a/src/main/java/com/intellij/plugins/haxe/model/HaxeEnumExtractorModel.java b/src/main/java/com/intellij/plugins/haxe/model/HaxeEnumExtractorModel.java index 7d8d682ce..5220c4dd8 100644 --- a/src/main/java/com/intellij/plugins/haxe/model/HaxeEnumExtractorModel.java +++ b/src/main/java/com/intellij/plugins/haxe/model/HaxeEnumExtractorModel.java @@ -36,7 +36,7 @@ public HaxeEnumValueModel getEnumValueModel() { @Nullable private PsiElement resolveEnumValueCached() { - return CachedValuesManager.getProjectPsiDependentCache(extractor, HaxeEnumExtractorModel::computeResolveEnumValue).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(extractor, HaxeEnumExtractorModel::computeResolveEnumValue); } @@ -95,22 +95,15 @@ public HaxeGenericResolver getGenericResolver() { } private @NotNull PsiElement[] getChildrenCached() { - return CachedValuesManager.getProjectPsiDependentCache(extractor, HaxeEnumExtractorModel::computeChildren).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(extractor, HaxeEnumExtractorModel::computeChildren); } - private static CachedValueProvider.Result computeChildren(HaxeEnumArgumentExtractor extractor) { - PsiElement[] children = extractor.getEnumExtractorArgumentList().getChildren(); - PsiElement[] elements = ArrayUtils.addAll(children, extractor); - return new CachedValueProvider.Result<>(children, (Object[])elements); + private static PsiElement[] computeChildren(HaxeEnumArgumentExtractor extractor) { + return extractor.getEnumExtractorArgumentList().getChildren(); } - private static CachedValueProvider.Result computeResolveEnumValue(HaxeEnumArgumentExtractor extractor) { - PsiElement resolve = extractor.getEnumValueReference().getReferenceExpression().resolve(); - if (resolve != null) { - return new CachedValueProvider.Result<>(resolve, extractor, resolve); - }else { - return new CachedValueProvider.Result<>(null, extractor); - } + private static PsiElement computeResolveEnumValue(HaxeEnumArgumentExtractor extractor) { + return extractor.getEnumValueReference().getReferenceExpression().resolve(); } @NotNull diff --git a/src/main/java/com/intellij/plugins/haxe/model/HaxeExprFileModel.java b/src/main/java/com/intellij/plugins/haxe/model/HaxeExprFileModel.java index c68077575..4a2e3f52b 100644 --- a/src/main/java/com/intellij/plugins/haxe/model/HaxeExprFileModel.java +++ b/src/main/java/com/intellij/plugins/haxe/model/HaxeExprFileModel.java @@ -19,12 +19,10 @@ protected boolean isReferencingCurrentFile(FullyQualifiedInfo info) { } public static HaxeExprFileModel fromFile(@NotNull HaxeFile file) { - return CachedValuesManager.getProjectPsiDependentCache(file, HaxeExprFileModel::cacheValueProvider).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(file, HaxeExprFileModel::cacheValueProvider); } - private static CachedValueProvider.Result cacheValueProvider(@NotNull HaxeFile file) { - return CachedValueProvider.Result.create(new HaxeExprFileModel(file), - ModificationTracker.EVER_CHANGED, - ProjectRootModificationTracker.getInstance(file.getProject())); + private static HaxeExprFileModel cacheValueProvider(@NotNull HaxeFile file) { + return new HaxeExprFileModel(file); } } diff --git a/src/main/java/com/intellij/plugins/haxe/model/HaxeFileModel.java b/src/main/java/com/intellij/plugins/haxe/model/HaxeFileModel.java index 5812feead..c82849d2a 100644 --- a/src/main/java/com/intellij/plugins/haxe/model/HaxeFileModel.java +++ b/src/main/java/com/intellij/plugins/haxe/model/HaxeFileModel.java @@ -129,13 +129,12 @@ private List getChildren() { } @NotNull private static List getChildren(HaxeFile file) { - return CachedValuesManager.getProjectPsiDependentCache(file, HaxeFileModel::_getChildren).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(file, HaxeFileModel::_getChildren); } - private static CachedValueProvider.Result> _getChildren(HaxeFile file) { + private static List _getChildren(HaxeFile file) { PsiElement[] children = file.getChildren(); - List list = Arrays.asList(children); - return new CachedValueProvider.Result<>(list, file); + return Arrays.asList(children); } @NotNull diff --git a/src/main/java/com/intellij/plugins/haxe/model/HaxeMemberModel.java b/src/main/java/com/intellij/plugins/haxe/model/HaxeMemberModel.java index 466764c19..4bc537c3e 100644 --- a/src/main/java/com/intellij/plugins/haxe/model/HaxeMemberModel.java +++ b/src/main/java/com/intellij/plugins/haxe/model/HaxeMemberModel.java @@ -105,7 +105,7 @@ private boolean isOverriddenPublicMethod() { @Override @Nullable public HaxeClassModel getDeclaringClass() { - return CachedValuesManager.getProjectPsiDependentCache(getMemberPsi(), HaxeMemberModel::_getDeclaringClass).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(getMemberPsi(), HaxeMemberModel::_getDeclaringClass); } ///TODO make model reusable and cache result @@ -115,12 +115,12 @@ public HaxeModuleModel getDeclaringModule() { return new HaxeModuleModel(module); } - private static CachedValueProvider.Result _getDeclaringClass(PsiMember member) { + private static HaxeClassModel _getDeclaringClass(PsiMember member) { PsiClass containingClass = member.getContainingClass(); if (containingClass instanceof HaxeClass haxeClass) { - return new CachedValueProvider.Result<>(haxeClass.getModel(), member); + return haxeClass.getModel(); }else { - return new CachedValueProvider.Result<>(null, member); + return null; } } diff --git a/src/main/java/com/intellij/plugins/haxe/model/HaxeMethodModel.java b/src/main/java/com/intellij/plugins/haxe/model/HaxeMethodModel.java index 793a07e4a..f0d0a7846 100644 --- a/src/main/java/com/intellij/plugins/haxe/model/HaxeMethodModel.java +++ b/src/main/java/com/intellij/plugins/haxe/model/HaxeMethodModel.java @@ -164,7 +164,7 @@ public ResultHolder getReturnType(@Nullable HaxeGenericResolver resolver) { if ((resolver == null || resolver.isEmpty()) // must not use resolver && haxeMethod.getReturnType() !=null // must have type tag && haxeMethod.getGenericParam() != null) { // must not have generics - return CachedValuesManager.getProjectPsiDependentCache(haxeMethod, HaxeMethodModel::getReturnTypeCacheProvider).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(haxeMethod, HaxeMethodModel::getReturnTypeCacheProvider); }else { Boolean data = haxeMethod.getUserData(isVoidReturn); if (data == Boolean.TRUE) { @@ -180,9 +180,8 @@ public ResultHolder getReturnType(@Nullable HaxeGenericResolver resolver) { } } - private static CachedValueProvider.Result getReturnTypeCacheProvider(HaxeMethod haxeMethod) { - ResultHolder type = HaxeTypeResolver.getFieldOrMethodReturnType(haxeMethod, null); - return new CachedValueProvider.Result<>(type, haxeMethod); + private static ResultHolder getReturnTypeCacheProvider(HaxeMethod haxeMethod) { + return HaxeTypeResolver.getFieldOrMethodReturnType(haxeMethod, null); } public SpecificFunctionReference getFunctionType(@Nullable HaxeGenericResolver resolver) { diff --git a/src/main/java/com/intellij/plugins/haxe/model/HaxeStdTypesFileModel.java b/src/main/java/com/intellij/plugins/haxe/model/HaxeStdTypesFileModel.java index 646a7035e..bdb0fe208 100644 --- a/src/main/java/com/intellij/plugins/haxe/model/HaxeStdTypesFileModel.java +++ b/src/main/java/com/intellij/plugins/haxe/model/HaxeStdTypesFileModel.java @@ -35,13 +35,11 @@ protected boolean isReferencingCurrentFile(FullyQualifiedInfo info) { } public static HaxeStdTypesFileModel fromFile(@NotNull HaxeFile file) { - return CachedValuesManager.getProjectPsiDependentCache(file, HaxeStdTypesFileModel::cacheValueProvider).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(file, HaxeStdTypesFileModel::cacheValueProvider); } - private static CachedValueProvider.Result cacheValueProvider(@NotNull HaxeFile file) { - return CachedValueProvider.Result.create(new HaxeStdTypesFileModel(file), - ModificationTracker.EVER_CHANGED, - ProjectRootModificationTracker.getInstance(file.getProject())); + private static HaxeStdTypesFileModel cacheValueProvider(@NotNull HaxeFile file) { + return new HaxeStdTypesFileModel(file); } } diff --git a/src/main/java/com/intellij/plugins/haxe/model/type/HaxeClassReference.java b/src/main/java/com/intellij/plugins/haxe/model/type/HaxeClassReference.java index 6781e5368..52ab71ecd 100644 --- a/src/main/java/com/intellij/plugins/haxe/model/type/HaxeClassReference.java +++ b/src/main/java/com/intellij/plugins/haxe/model/type/HaxeClassReference.java @@ -71,15 +71,14 @@ public HaxeClassReference(String name, @NotNull PsiElement elementContext, boole private String getClassName(HaxeClassModel clazz) { if(clazz.getPsi().getParent() != null) { - return CachedValuesManager.getProjectPsiDependentCache(clazz.getPsi(), HaxeClassReference::getNameCached).getValue(); + return CachedValuesManager.getProjectPsiDependentCache(clazz.getPsi(), HaxeClassReference::getNameCached); }else { return getClassNameInternal(clazz.getPsi().getModel()); } } - private static CachedValueProvider.Result getNameCached(HaxeClass aClass) { - String name = getClassNameInternal(aClass.getModel()); - return CachedValueProvider.Result.create(name, aClass); + private static String getNameCached(HaxeClass aClass) { + return getClassNameInternal(aClass.getModel()); } private static String getClassNameInternal(HaxeClassModel clazz) { diff --git a/src/main/java/com/intellij/plugins/haxe/model/type/HaxeExpressionEvaluator.java b/src/main/java/com/intellij/plugins/haxe/model/type/HaxeExpressionEvaluator.java index 6ee02cdfa..801fb054f 100644 --- a/src/main/java/com/intellij/plugins/haxe/model/type/HaxeExpressionEvaluator.java +++ b/src/main/java/com/intellij/plugins/haxe/model/type/HaxeExpressionEvaluator.java @@ -118,7 +118,9 @@ static ResultHolder handle(final PsiElement element, final HaxeGenericResolver resolver) { try { ProgressIndicatorProvider.checkCanceled(); - return _handle(element, context, resolver); + + HaxeExpressionEvaluatorCacheService service = element.getProject().getService(HaxeExpressionEvaluatorCacheService.class); + return service.handleWithResultCaching(element, context, resolver); } catch (NullPointerException e) { // Make sure that these get into the log, because the GeneralHighlightingPass swallows them. @@ -139,7 +141,7 @@ static ResultHolder handle(final PsiElement element, } @NotNull - static private ResultHolder _handle(final PsiElement element, + static ResultHolder _handle(final PsiElement element, final HaxeExpressionEvaluatorContext context, HaxeGenericResolver optionalResolver) { if (element == null) { @@ -187,8 +189,7 @@ static private ResultHolder _handle(final PsiElement element, } if (element instanceof HaxeIfStatement ifStatement) { - //return handleIfStatement(context, resolver, ifStatement); - return resolveWithCache(ifStatement, resolver, () -> handleIfStatement(context, resolver, ifStatement)); + return handleIfStatement(context, resolver, ifStatement); } } @@ -216,7 +217,7 @@ static private ResultHolder _handle(final PsiElement element, return handleValueIterator(context, resolver, valueIterator); } if (element instanceof HaxeIteratorkey || element instanceof HaxeIteratorValue) { - return resolveWithCache(element, resolver, () -> findIteratorType(element)); + return findIteratorType(element); } @@ -229,7 +230,7 @@ static private ResultHolder _handle(final PsiElement element, if (element instanceof HaxeParameter parameter) { boolean isUntyped = parameter.getTypeTag() == null && parameter.getVarInit() == null; if (isUntyped) { - return resolveWithCache(element, resolver, () -> handleParameter(context, resolver, parameter)); + return handleParameter(context, resolver, parameter); } return handleParameter(context, resolver, parameter); } @@ -237,7 +238,7 @@ static private ResultHolder _handle(final PsiElement element, } if (element instanceof HaxeEnumExtractedValueReference extractedValue) { - return resolveWithCache(extractedValue, resolver, () -> handleEnumExtractedValue(extractedValue, resolver)); + return handleEnumExtractedValue(extractedValue, resolver); } @@ -256,11 +257,11 @@ static private ResultHolder _handle(final PsiElement element, } if (element instanceof HaxeCallExpression callExpression) { - return resolveWithCache(callExpression, resolver, () -> handleCallExpression(context, resolver, callExpression)); + return handleCallExpression(context, resolver, callExpression); } if (element instanceof HaxeReferenceExpression referenceExpression) { - return resolveWithCache(referenceExpression, resolver, () -> handleReferenceExpression(context, resolver, referenceExpression)); + return handleReferenceExpression(context, resolver, referenceExpression); } if (element instanceof HaxeCastExpression castExpression) { @@ -335,7 +336,7 @@ static private ResultHolder _handle(final PsiElement element, } if (element instanceof HaxeFunctionLiteral function) { - return resolveWithCache(function, resolver, () -> handleFunctionLiteral(context, resolver, function)); + return handleFunctionLiteral(context, resolver, function); } if (element instanceof HaxeObjectLiteralImpl objectLiteral) { @@ -452,33 +453,6 @@ private static ResultHolder handleMacroStatement(HaxeExpressionEvaluatorContext return HaxeMacroTypeUtil.getExpr(macroStatement).createHolder(); } - private static ResultHolder resolveWithCache(@NotNull PsiElement element, @NotNull HaxeGenericResolver resolver, Supplier resolveLogic) { - Map map = resultCache.get(); - Map hitCounter = resultCacheHits.get(); - String resolverAsString = resolver.toCacheString(); - if (map.containsKey(element) && map.get(element).resolverAsString().equals(resolverAsString)) { - CacheRecord cacheRecord = map.get(element); - hitCounter.get(element).incrementAndGet(); - return cacheRecord.holder(); - }else { - ResultHolder result = resolveLogic.get(); - if (!result.isUnknown()) { - - if (result.getClassType() != null) { - if (!result.isTypeParameter() && result.getClassType().getGenericResolver().isEmpty()) { - hitCounter.put(element, new AtomicInteger(0)); - map.put(element, new CacheRecord(result, resolverAsString)); - } - }else if (result.isFunctionType() && result.getFunctionType() != null) { - if (!containsUnknowns(result.getFunctionType())) { - hitCounter.put(element, new AtomicInteger(0)); - map.put(element, new CacheRecord(result, resolverAsString)); - } - } - } - return result; - } - } private static boolean containsUnknowns(SpecificFunctionReference type) { if (type.getReturnType().isUnknown()) return true; diff --git a/src/main/java/com/intellij/plugins/haxe/model/type/HaxeExpressionEvaluatorCacheService.java b/src/main/java/com/intellij/plugins/haxe/model/type/HaxeExpressionEvaluatorCacheService.java new file mode 100644 index 000000000..687b096f0 --- /dev/null +++ b/src/main/java/com/intellij/plugins/haxe/model/type/HaxeExpressionEvaluatorCacheService.java @@ -0,0 +1,51 @@ +package com.intellij.plugins.haxe.model.type; + +import com.intellij.psi.PsiElement; +import com.intellij.psi.util.PsiModificationTracker; +import org.jetbrains.annotations.NotNull; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import static com.intellij.plugins.haxe.model.type.HaxeExpressionEvaluator._handle; + +/** + * To avoid unnecessary re-evaluation of elements used by other expressions (ex. functions without type tags etc) + * We cache the evaluation result until a Psi change happens, we dont want to cache for longer as ResultHolder + * contains SpecificTypeReference elements both as the type and as generics and these contain PsiElements + * that might become invalid + */ +public class HaxeExpressionEvaluatorCacheService implements PsiModificationTracker.Listener { + + private final Map cacheMap = new ConcurrentHashMap<>(); + + + public @NotNull ResultHolder handleWithResultCaching(final PsiElement element, + final HaxeExpressionEvaluatorContext context, + final HaxeGenericResolver resolver) { + + EvaluationKey key = new EvaluationKey(element, resolver == null ? "NO_RESOLVER" : resolver.toCacheString()); + if (cacheMap.containsKey(key)) { + return cacheMap.get(key); + } + else { + ResultHolder holder = _handle(element, context, resolver); + if (!holder.isUnknown()) { + cacheMap.put(key, holder); + } + return holder; + } + } + + @Override + public void modificationCountChanged() { + clearCaches(); + } + + private void clearCaches() { + cacheMap.clear(); + } +} + +record EvaluationKey(PsiElement element, String evalParamString) { +} \ No newline at end of file diff --git a/src/main/java/com/intellij/plugins/haxe/model/type/ResultHolder.java b/src/main/java/com/intellij/plugins/haxe/model/type/ResultHolder.java index fadac53cd..ec55a9ea1 100644 --- a/src/main/java/com/intellij/plugins/haxe/model/type/ResultHolder.java +++ b/src/main/java/com/intellij/plugins/haxe/model/type/ResultHolder.java @@ -20,22 +20,25 @@ package com.intellij.plugins.haxe.model.type; import com.intellij.psi.PsiElement; +import lombok.EqualsAndHashCode; +import lombok.Getter; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.LinkedList; import java.util.List; +@EqualsAndHashCode public class ResultHolder { static public ResultHolder[] EMPTY = new ResultHolder[0]; + @Getter private final PsiElement origin; + @NotNull private SpecificTypeReference type; - private boolean initExpression = false; private boolean canMutate = true; private int mutationCount = 0; - private PsiElement origin; public ResultHolder(@NotNull SpecificTypeReference type) { this(type, null); @@ -186,9 +189,6 @@ public PsiElement getElementContext() { public ResultHolder withOrigin(PsiElement origin) { return new ResultHolder(this.getType(), origin); } - public PsiElement getOrigin() { - return origin; - } public boolean isInvalid() { return type.isInvalid(); @@ -213,7 +213,7 @@ public static boolean containsTypeParameters(ResultHolder holder) { } } if (type instanceof SpecificFunctionReference function) { - if(!function.getTypeParameters().isEmpty()) return true; + return !function.getTypeParameters().isEmpty(); } return false; } diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml index 3231d5863..bea622f5b 100644 --- a/src/main/resources/META-INF/plugin.xml +++ b/src/main/resources/META-INF/plugin.xml @@ -317,6 +317,8 @@ + + +