#525521635

Committed 20 Jul 2025 03:45PM UTC coverage: 82.266% (-0.09%) from 82.355%

Build # #525521635

Build Type

push

github

Committed by

hurricup

Commit Message

Build 252.23892.248

Run Details

30936 of 37605 relevant lines covered (82.27%)

0.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.65

/plugin/backend/src/main/java/com/perl5/lang/perl/idea/codeInsight/PerlParameterInfoHandler.java

/*
 * Copyright 2015-2025 Alexandr Evstigneev
 *
 * 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 com.perl5.lang.perl.idea.codeInsight;

import com.intellij.lang.parameterInfo.*;
import com.intellij.openapi.util.Ref;
import com.intellij.psi.PsiElement;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.PsiUtilCore;
import com.perl5.lang.perl.lexer.PerlElementTypes;
import com.perl5.lang.perl.lexer.PerlTokenSets;
import com.perl5.lang.perl.psi.*;
import com.perl5.lang.perl.psi.impl.PerlCompositeElementImpl;
import com.perl5.lang.perl.psi.impl.PsiPerlCallArgumentsImpl;
import com.perl5.lang.perl.psi.impl.PsiPerlCommaSequenceExprImpl;
import com.perl5.lang.perl.psi.impl.PsiPerlParenthesisedExprImpl;
import com.perl5.lang.perl.psi.mixins.PerlMethodMixin;
import com.perl5.lang.perl.psi.references.PerlImplicitDeclarationsService;
import com.perl5.lang.perl.psi.utils.PerlContextType;
import com.perl5.lang.perl.psi.utils.PerlPsiUtil;
import com.perl5.lang.perl.psi.utils.PerlResolveUtilCore;
import com.perl5.lang.perl.util.PerlContextUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;


public class PerlParameterInfoHandler implements ParameterInfoHandler<PsiPerlCallArgumentsImpl, PerlParameterInfo>, PerlElementTypes {
  @Override
  public @Nullable PsiPerlCallArgumentsImpl findElementForParameterInfo(@NotNull CreateParameterInfoContext context) {
    PsiPerlCallArgumentsImpl callArguments = findCallArguments(context);

    if (callArguments != null) {
      PerlParameterInfo[] methodParameterInfos = getMethodCallArguments(callArguments);
      if (methodParameterInfos == null || methodParameterInfos.length == 0) {
        return null;
      }
      markActiveParameters(callArguments, methodParameterInfos, context.getOffset());
      context.setItemsToShow(methodParameterInfos);
    }

    return callArguments;
  }

  @Override
  public void showParameterInfo(@NotNull PsiPerlCallArgumentsImpl container, @NotNull CreateParameterInfoContext context) {
    context.showHint(container, container.getTextOffset(), this);
  }

  @Override
  public @Nullable PsiPerlCallArgumentsImpl findElementForUpdatingParameterInfo(@NotNull UpdateParameterInfoContext context) {
    return findCallArguments(context);
  }

  @Override
  public void updateParameterInfo(@NotNull PsiPerlCallArgumentsImpl container, @NotNull UpdateParameterInfoContext context) {
    markActiveParameters(container, (PerlParameterInfo[])context.getObjectsToView(), context.getOffset());
  }

  @Override
  public void updateUI(PerlParameterInfo parameterInfo, @NotNull ParameterInfoUIContext context) {
    parameterInfo.setUpUIPresentation(context);
  }

  /**
   * Method marks parameters as active/inactive
   *
   * @param container      arguments container
   * @param parameterInfos array of parameter infos
   */
  private static void markActiveParameters(@NotNull PsiPerlCallArgumentsImpl container, PerlParameterInfo[] parameterInfos, int offset) {
    for (PerlParameterInfo parameterInfo : parameterInfos) {
      parameterInfo.setSelected(false);
    }

    markActiveparametersRecursively(container.getFirstChild(), parameterInfos, 0, offset);
  }

  private static int markActiveparametersRecursively(PsiElement element, PerlParameterInfo[] parameterInfos, int currentIndex, int offset) {
    while (element != null) {
      if (parameterInfos.length <= currentIndex) {
        return currentIndex;
      }

      IElementType elementType = PsiUtilCore.getElementType(element);
      if (element instanceof PsiPerlParenthesisedExprImpl || element instanceof PsiPerlCommaSequenceExprImpl) {
        currentIndex = markActiveparametersRecursively(element.getFirstChild(), parameterInfos, currentIndex, offset);
      }
      else {
        if (isComma(elementType)) {
          if (parameterInfos[currentIndex].getArgument().getContextType() == PerlContextType.SCALAR) {
            currentIndex++;
          }
        }
      }

      if (element.getTextRange().getEndOffset() >= offset) {
        if (element instanceof PerlCompositeElementImpl) {
          PerlContextType valueContextType = PerlContextUtil.contextFrom(element);

          if (valueContextType == PerlContextType.SCALAR) {
            if (currentIndex < parameterInfos.length) {
              parameterInfos[currentIndex].setSelected(true);
            }
            return parameterInfos.length;
          }
          else if (valueContextType == PerlContextType.LIST) // consumes all arguments to the end
          {
            while (currentIndex < parameterInfos.length) {
              parameterInfos[currentIndex++].setSelected(true);
            }
            return currentIndex;
          }
        }

        // space, comma or smth
        if (currentIndex < parameterInfos.length) {
          parameterInfos[currentIndex].setSelected(true);
        }
        return parameterInfos.length;
      }
      else if (elementType == SUB_EXPR && element.getFirstChild() instanceof PsiPerlBlock) {
        PsiElement nextSibling = PerlPsiUtil.getNextSignificantSibling(element);
        if (!isComma(PsiUtilCore.getElementType(nextSibling))) {
          currentIndex++;
        }
      }
      else if (isPrintHandleArgument(element)) {
        currentIndex++;
      }

      element = element.getNextSibling();
    }
    return currentIndex;
  }

  private static boolean isPrintHandleArgument(@NotNull PsiElement psiElement) {
    IElementType elementType = PsiUtilCore.getElementType(psiElement);
    if (elementType != BLOCK && elementType != PERL_HANDLE_EXPR && elementType != SCALAR_VARIABLE) {
      return false;
    }
    PsiElement parent = psiElement.getParent();
    if (!(parent instanceof PsiPerlCommaSequenceExpr)) {
      return false;
    }

    PsiElement grandParent = parent.getParent();
    if (!(grandParent instanceof PsiPerlCallArguments)) {
      return false;
    }

    if (!(grandParent.getParent() instanceof PsiPerlPrintExpr)) {
      return false;
    }

    PsiElement nextSibling = PerlPsiUtil.getNextSignificantSibling(psiElement);
    return !isComma(PsiUtilCore.getElementType(nextSibling));
  }

  private static boolean isComma(IElementType elementType) {
    return elementType == FAT_COMMA || elementType == COMMA;
  }

  private static @Nullable PsiPerlCallArgumentsImpl findCallArguments(ParameterInfoContext context) {
    PsiPerlCallArgumentsImpl callArguments =
      ParameterInfoUtils.findParentOfType(context.getFile(), context.getOffset(), PsiPerlCallArgumentsImpl.class);
    if (callArguments != null || context.getOffset() == 0) {
      return callArguments;
    }

    callArguments = ParameterInfoUtils.findParentOfType(context.getFile(), context.getOffset() - 1, PsiPerlCallArgumentsImpl.class);
    if (callArguments != null) {
      return callArguments;
    }

    return ParameterInfoUtils.findParentOfType(context.getFile(), context.getOffset() + 1, PsiPerlCallArgumentsImpl.class);
  }

  private static @Nullable PerlParameterInfo[] getTargetParameterInfo(@Nullable PsiElement target) {
    if (!(target instanceof PerlSubDefinitionElement subDefinitionElement)) {
      return null;
    }
    return PerlParameterInfo.wrapArguments(subDefinitionElement.getSubArgumentsListWithoutSelf());
  }

  private static @Nullable PerlParameterInfo[] getMethodCallArguments(@NotNull PsiPerlCallArgumentsImpl arguments) {
    PsiElement run = arguments.getPrevSibling();
    while (run != null) {
      if (run instanceof PerlMethodMixin methodMixin) {
        PerlSubNameElement subNameElement = methodMixin.getSubNameElement();
        if (subNameElement == null) {
          break;
        }

        Ref<PerlParameterInfo[]> parameterInfoRef = Ref.create();

        PerlResolveUtilCore.processResolveTargets((target, reference) -> {
          PerlParameterInfo[] parameterInfos = getTargetParameterInfo(target);
          if (parameterInfos != null) {
            parameterInfoRef.set(parameterInfos);
            return false;
          }
          return true;
        }, subNameElement);

        if (!parameterInfoRef.isNull()) {
          return parameterInfoRef.get();
        }
      }
      else if (PerlTokenSets.CUSTOM_EXPR_KEYWORDS.contains(PsiUtilCore.getElementType(run))) {
        return getTargetParameterInfo(PerlImplicitDeclarationsService.getInstance(run.getProject()).getCoreSub(run.getText()));
      }
      run = run.getPrevSibling();
    }
    return null;
  }
}

1	/*
2	* Copyright 2015-2025 Alexandr Evstigneev
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	package com.perl5.lang.perl.idea.codeInsight;
18
19	import com.intellij.lang.parameterInfo.*;
20	import com.intellij.openapi.util.Ref;
21	import com.intellij.psi.PsiElement;
22	import com.intellij.psi.tree.IElementType;
23	import com.intellij.psi.util.PsiUtilCore;
24	import com.perl5.lang.perl.lexer.PerlElementTypes;
25	import com.perl5.lang.perl.lexer.PerlTokenSets;
26	import com.perl5.lang.perl.psi.*;
27	import com.perl5.lang.perl.psi.impl.PerlCompositeElementImpl;
28	import com.perl5.lang.perl.psi.impl.PsiPerlCallArgumentsImpl;
29	import com.perl5.lang.perl.psi.impl.PsiPerlCommaSequenceExprImpl;
30	import com.perl5.lang.perl.psi.impl.PsiPerlParenthesisedExprImpl;
31	import com.perl5.lang.perl.psi.mixins.PerlMethodMixin;
32	import com.perl5.lang.perl.psi.references.PerlImplicitDeclarationsService;
33	import com.perl5.lang.perl.psi.utils.PerlContextType;
34	import com.perl5.lang.perl.psi.utils.PerlPsiUtil;
35	import com.perl5.lang.perl.psi.utils.PerlResolveUtilCore;
36	import com.perl5.lang.perl.util.PerlContextUtil;
37	import org.jetbrains.annotations.NotNull;
38	import org.jetbrains.annotations.Nullable;
39
40
41	public class PerlParameterInfoHandler implements ParameterInfoHandler<PsiPerlCallArgumentsImpl, PerlParameterInfo>, PerlElementTypes {	1✔
42	@Override
43	public @Nullable PsiPerlCallArgumentsImpl findElementForParameterInfo(@NotNull CreateParameterInfoContext context) {
44	PsiPerlCallArgumentsImpl callArguments = findCallArguments(context);	1✔
45
46	if (callArguments != null) {	1✔
47	PerlParameterInfo[] methodParameterInfos = getMethodCallArguments(callArguments);	1✔
48	if (methodParameterInfos == null \|\| methodParameterInfos.length == 0) {	1✔
49	return null;	1✔
50	}
51	markActiveParameters(callArguments, methodParameterInfos, context.getOffset());	1✔
52	context.setItemsToShow(methodParameterInfos);	1✔
53	}
54
55	return callArguments;	1✔
56	}
57
58	@Override
59	public void showParameterInfo(@NotNull PsiPerlCallArgumentsImpl container, @NotNull CreateParameterInfoContext context) {
60	context.showHint(container, container.getTextOffset(), this);	×
61	}	×
62
63	@Override
64	public @Nullable PsiPerlCallArgumentsImpl findElementForUpdatingParameterInfo(@NotNull UpdateParameterInfoContext context) {
65	return findCallArguments(context);	×
66	}
67
68	@Override
69	public void updateParameterInfo(@NotNull PsiPerlCallArgumentsImpl container, @NotNull UpdateParameterInfoContext context) {
70	markActiveParameters(container, (PerlParameterInfo[])context.getObjectsToView(), context.getOffset());	×
71	}	×
72
73	@Override
74	public void updateUI(PerlParameterInfo parameterInfo, @NotNull ParameterInfoUIContext context) {
75	parameterInfo.setUpUIPresentation(context);	×
76	}	×
77
78	/**
79	* Method marks parameters as active/inactive
80	*
81	* @param container arguments container
82	* @param parameterInfos array of parameter infos
83	*/
84	private static void markActiveParameters(@NotNull PsiPerlCallArgumentsImpl container, PerlParameterInfo[] parameterInfos, int offset) {
85	for (PerlParameterInfo parameterInfo : parameterInfos) {	1✔
86	parameterInfo.setSelected(false);	1✔
87	}
88
89	markActiveparametersRecursively(container.getFirstChild(), parameterInfos, 0, offset);	1✔
90	}	1✔
91
92	private static int markActiveparametersRecursively(PsiElement element, PerlParameterInfo[] parameterInfos, int currentIndex, int offset) {
93	while (element != null) {	1✔
94	if (parameterInfos.length <= currentIndex) {	1✔
95	return currentIndex;	×
96	}
97
98	IElementType elementType = PsiUtilCore.getElementType(element);	1✔
99	if (element instanceof PsiPerlParenthesisedExprImpl \|\| element instanceof PsiPerlCommaSequenceExprImpl) {	1✔
100	currentIndex = markActiveparametersRecursively(element.getFirstChild(), parameterInfos, currentIndex, offset);	1✔
101	}
102	else {
103	if (isComma(elementType)) {	1✔
104	if (parameterInfos[currentIndex].getArgument().getContextType() == PerlContextType.SCALAR) {	1✔
105	currentIndex++;	1✔
106	}
107	}
108	}
109
110	if (element.getTextRange().getEndOffset() >= offset) {	1✔
111	if (element instanceof PerlCompositeElementImpl) {	1✔
112	PerlContextType valueContextType = PerlContextUtil.contextFrom(element);	1✔
113
114	if (valueContextType == PerlContextType.SCALAR) {	1✔
115	if (currentIndex < parameterInfos.length) {	1✔
116	parameterInfos[currentIndex].setSelected(true);	1✔
117	}
118	return parameterInfos.length;	1✔
119	}
120	else if (valueContextType == PerlContextType.LIST) // consumes all arguments to the end	1✔
121	{
122	while (currentIndex < parameterInfos.length) {	1✔
123	parameterInfos[currentIndex++].setSelected(true);	×
124	}
125	return currentIndex;	1✔
126	}
127	}
128
129	// space, comma or smth
130	if (currentIndex < parameterInfos.length) {	1✔
131	parameterInfos[currentIndex].setSelected(true);	1✔
132	}
133	return parameterInfos.length;	1✔
134	}
135	else if (elementType == SUB_EXPR && element.getFirstChild() instanceof PsiPerlBlock) {	1✔
136	PsiElement nextSibling = PerlPsiUtil.getNextSignificantSibling(element);	1✔
137	if (!isComma(PsiUtilCore.getElementType(nextSibling))) {	1✔
138	currentIndex++;	1✔
139	}
140	}	1✔
141	else if (isPrintHandleArgument(element)) {	1✔
142	currentIndex++;	1✔
143	}
144
145	element = element.getNextSibling();	1✔
146	}	1✔
147	return currentIndex;	1✔
148	}
149
150	private static boolean isPrintHandleArgument(@NotNull PsiElement psiElement) {
151	IElementType elementType = PsiUtilCore.getElementType(psiElement);	1✔
152	if (elementType != BLOCK && elementType != PERL_HANDLE_EXPR && elementType != SCALAR_VARIABLE) {	1✔
153	return false;	1✔
154	}
155	PsiElement parent = psiElement.getParent();	1✔
156	if (!(parent instanceof PsiPerlCommaSequenceExpr)) {	1✔
157	return false;	×
158	}
159
160	PsiElement grandParent = parent.getParent();	1✔
161	if (!(grandParent instanceof PsiPerlCallArguments)) {	1✔
162	return false;	×
163	}
164
165	if (!(grandParent.getParent() instanceof PsiPerlPrintExpr)) {	1✔
166	return false;	×
167	}
168
169	PsiElement nextSibling = PerlPsiUtil.getNextSignificantSibling(psiElement);	1✔
170	return !isComma(PsiUtilCore.getElementType(nextSibling));	1✔
171	}
172
173	private static boolean isComma(IElementType elementType) {
174	return elementType == FAT_COMMA \|\| elementType == COMMA;	1✔
175	}
176
177	private static @Nullable PsiPerlCallArgumentsImpl findCallArguments(ParameterInfoContext context) {
178	PsiPerlCallArgumentsImpl callArguments =	1✔
179	ParameterInfoUtils.findParentOfType(context.getFile(), context.getOffset(), PsiPerlCallArgumentsImpl.class);	1✔
180	if (callArguments != null \|\| context.getOffset() == 0) {	1✔
181	return callArguments;	1✔
182	}
183
184	callArguments = ParameterInfoUtils.findParentOfType(context.getFile(), context.getOffset() - 1, PsiPerlCallArgumentsImpl.class);	1✔
185	if (callArguments != null) {	1✔
186	return callArguments;	1✔
187	}
188
189	return ParameterInfoUtils.findParentOfType(context.getFile(), context.getOffset() + 1, PsiPerlCallArgumentsImpl.class);	1✔
190	}
191
192	private static @Nullable PerlParameterInfo[] getTargetParameterInfo(@Nullable PsiElement target) {
193	if (!(target instanceof PerlSubDefinitionElement subDefinitionElement)) {	1✔
194	return null;	×
195	}
196	return PerlParameterInfo.wrapArguments(subDefinitionElement.getSubArgumentsListWithoutSelf());	1✔
197	}
198
199	private static @Nullable PerlParameterInfo[] getMethodCallArguments(@NotNull PsiPerlCallArgumentsImpl arguments) {
200	PsiElement run = arguments.getPrevSibling();	1✔
201	while (run != null) {	1✔
202	if (run instanceof PerlMethodMixin methodMixin) {	1✔
203	PerlSubNameElement subNameElement = methodMixin.getSubNameElement();	1✔
204	if (subNameElement == null) {	1✔
205	break;	×
206	}
207
208	Ref<PerlParameterInfo[]> parameterInfoRef = Ref.create();	1✔
209
210	PerlResolveUtilCore.processResolveTargets((target, reference) -> {	1✔
211	PerlParameterInfo[] parameterInfos = getTargetParameterInfo(target);	1✔
212	if (parameterInfos != null) {	1✔
213	parameterInfoRef.set(parameterInfos);	1✔
214	return false;	1✔
215	}
216	return true;	×
217	}, subNameElement);
218
219	if (!parameterInfoRef.isNull()) {	1✔
220	return parameterInfoRef.get();	1✔
221	}
222	}	×
223	else if (PerlTokenSets.CUSTOM_EXPR_KEYWORDS.contains(PsiUtilCore.getElementType(run))) {	1✔
224	return getTargetParameterInfo(PerlImplicitDeclarationsService.getInstance(run.getProject()).getCoreSub(run.getText()));	1✔
225	}
226	run = run.getPrevSibling();	1✔
227	}
228	return null;	×
229	}
230	}

Camelcade / Perl5-IDEA / #525521635

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous