#525521563

Committed 01 Jun 2025 02:15PM UTC coverage: 82.332% (+0.04%) from 82.289%

Build # #525521563

Build Type

push

github

Committed by

hurricup

Commit Message

Bounded wildcards

Run Details

2 of 2 new or added lines in 2 files covered. (100.0%)

69 existing lines in 17 files now uncovered.

30882 of 37509 relevant lines covered (82.33%)

0.82 hits per line

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

97.14

/plugin/core/src/main/java/com/perl5/lang/perl/psi/utils/PerlSubArgument.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.psi.utils;

import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.stubs.StubInputStream;
import com.intellij.psi.stubs.StubOutputStream;
import com.perl5.lang.perl.idea.configuration.settings.PerlSharedSettings;
import com.perl5.lang.perl.lexer.PerlLexer;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;

import static com.perl5.lang.perl.util.PerlScalarUtil.DEFAULT_SELF_NAME;


public class PerlSubArgument {

  public static final @NonNls String NEW_VALUE_VALUE = "new_value";
  private final @NotNull PerlVariableType myArgumentType;
  private final @NotNull String myArgumentName;

  private final @NotNull String myVariableClass;

  private Boolean myIsOptional;

  private PerlSubArgument(@NotNull PerlVariableType variableType,
                          @NotNull String variableName,
                          @NotNull String variableClass,
                          boolean isOptional) {
    myArgumentType = variableType;
    myArgumentName = variableName;
    myIsOptional = isOptional;
    myVariableClass = variableClass;
  }

  public @NotNull PerlVariableType getArgumentType() {
    return myArgumentType;
  }

  public @NotNull String getArgumentName() {
    return myArgumentName;
  }

  public Boolean isOptional() {
    return myIsOptional;
  }

  public void setOptional(Boolean optional) {
    myIsOptional = optional;
  }

  public @NotNull String getVariableClass() {
    return myVariableClass;
  }

  public String toStringShort() {
    return StringUtil.isNotEmpty(myArgumentName) ? myArgumentType.getSigil() + myArgumentName : PerlLexer.STRING_UNDEF;
  }

  public String toStringLong() {
    if (StringUtil.isEmpty(myArgumentName)) {
      return PerlLexer.STRING_UNDEF;
    }

    String shortName = myArgumentType.getSigil() + myArgumentName;
    return StringUtil.isNotEmpty(myVariableClass) ? myVariableClass + " " + shortName : shortName;
  }

  @Override
  public String toString() {
    String toString = toStringLong();
    return myIsOptional ? "[" + toString + "]" : toString;
  }

  private void serialize(@NotNull StubOutputStream dataStream) throws IOException {
    dataStream.writeName(myArgumentType.toString());
    dataStream.writeName(myArgumentName);
    dataStream.writeName(myVariableClass);
    dataStream.writeBoolean(myIsOptional);
  }

  public boolean isSelf(Project project) {
    return getArgumentType() == PerlVariableType.SCALAR && PerlSharedSettings.getInstance(project).isSelfName(getArgumentName());
  }

  public boolean isEmpty() {
    return StringUtil.isEmpty(myArgumentName);
  }

  public PerlContextType getContextType() {
    if (myArgumentType == PerlVariableType.SCALAR || myArgumentType == PerlVariableType.CODE || myArgumentType == PerlVariableType.GLOB) {
      return PerlContextType.SCALAR;
    }
    return PerlContextType.LIST;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }

    PerlSubArgument argument = (PerlSubArgument)o;

    return myArgumentType == argument.myArgumentType &&
           myArgumentName.equals(argument.myArgumentName) &&
           myVariableClass.equals(argument.myVariableClass) &&
           (Objects.equals(myIsOptional, argument.myIsOptional));
  }

  @Override
  public int hashCode() {
    int result = myArgumentType.hashCode();
    result = 31 * result + myArgumentName.hashCode();
    result = 31 * result + myVariableClass.hashCode();
    result = 31 * result + (myIsOptional != null ? myIsOptional.hashCode() : 0);
    return result;
  }

  public static PerlSubArgument optionalScalar(@NotNull String variableName) {
    return create(PerlVariableType.SCALAR, variableName, true);
  }

  public static PerlSubArgument optionalScalar(@NotNull String variableName, @Nullable String variableClass) {
    return create(PerlVariableType.SCALAR, variableName, variableClass == null ? "" : variableClass, true);
  }

  public static PerlSubArgument mandatoryScalar(@NotNull String variableName) {
    return mandatoryScalar(variableName, "");
  }

  public static @NotNull PerlSubArgument mandatoryScalar(@NotNull String variableName, @NotNull String variableClass) {
    return mandatory(PerlVariableType.SCALAR, variableName, variableClass);
  }

  public static PerlSubArgument mandatory(@NotNull PerlVariableType variableType, @NotNull String variableName) {
    return create(variableType, variableName, false);
  }

  public static PerlSubArgument mandatory(@NotNull PerlVariableType variableType,
                                          @NotNull String variableName,
                                          @NotNull String variableClass) {
    return create(variableType, variableName, variableClass, false);
  }

  public static PerlSubArgument create(@NotNull PerlVariableType variableType, @NotNull String variableName, boolean isOptional) {
    return create(variableType, variableName, "", isOptional);
  }

  public static PerlSubArgument create(@NotNull PerlVariableType variableType,
                                       @NotNull String variableName,
                                       @NotNull String variableClass,
                                       boolean isOptional) {
    return new PerlSubArgument(variableType, variableName, variableClass, isOptional);
  }

  @SuppressWarnings("ConstantConditions")
  private static PerlSubArgument deserialize(@NotNull StubInputStream dataStream) throws IOException {
    PerlVariableType argumentType = PerlVariableType.valueOf(dataStream.readName().toString());
    String argumentName = dataStream.readName().toString();
    String variableClass = dataStream.readName().toString();
    boolean isOptional = dataStream.readBoolean();
    return PerlSubArgument.create(argumentType, argumentName, variableClass, isOptional);
  }

  public static @NotNull List<PerlSubArgument> deserializeList(@NotNull StubInputStream dataStream) throws IOException {
    int argumentsNumber = dataStream.readVarInt();

    if (argumentsNumber <= 0) {
      return Collections.emptyList();
    }
    List<PerlSubArgument> arguments = new ArrayList<>(argumentsNumber);
    for (int i = 0; i < argumentsNumber; i++) {
      arguments.add(deserialize(dataStream));
    }
    return arguments;
  }

  public static PerlSubArgument empty() {
    return mandatoryScalar("");
  }

  public static PerlSubArgument self() {
    return mandatoryScalar(DEFAULT_SELF_NAME);
  }

  public static void serializeList(@NotNull StubOutputStream dataStream, List<? extends PerlSubArgument> arguments) throws IOException {
    dataStream.writeVarInt(arguments.size());
    for (PerlSubArgument argument : arguments) {
      argument.serialize(dataStream);
    }
  }
}

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.psi.utils;
18
19	import com.intellij.openapi.project.Project;
20	import com.intellij.openapi.util.text.StringUtil;
21	import com.intellij.psi.stubs.StubInputStream;
22	import com.intellij.psi.stubs.StubOutputStream;
23	import com.perl5.lang.perl.idea.configuration.settings.PerlSharedSettings;
24	import com.perl5.lang.perl.lexer.PerlLexer;
25	import org.jetbrains.annotations.NonNls;
26	import org.jetbrains.annotations.NotNull;
27	import org.jetbrains.annotations.Nullable;
28
29	import java.io.IOException;
30	import java.util.ArrayList;
31	import java.util.Collections;
32	import java.util.List;
33	import java.util.Objects;
34
35	import static com.perl5.lang.perl.util.PerlScalarUtil.DEFAULT_SELF_NAME;
36
37
38	public class PerlSubArgument {
39
40	public static final @NonNls String NEW_VALUE_VALUE = "new_value";
41	private final @NotNull PerlVariableType myArgumentType;
42	private final @NotNull String myArgumentName;
43
44	private final @NotNull String myVariableClass;
45
46	private Boolean myIsOptional;
47
48	private PerlSubArgument(@NotNull PerlVariableType variableType,
49	@NotNull String variableName,
50	@NotNull String variableClass,
51	boolean isOptional) {	1✔
52	myArgumentType = variableType;	1✔
53	myArgumentName = variableName;	1✔
54	myIsOptional = isOptional;	1✔
55	myVariableClass = variableClass;	1✔
56	}	1✔
57
58	public @NotNull PerlVariableType getArgumentType() {
59	return myArgumentType;	1✔
60	}
61
62	public @NotNull String getArgumentName() {
63	return myArgumentName;	1✔
64	}
65
66	public Boolean isOptional() {
67	return myIsOptional;	1✔
68	}
69
70	public void setOptional(Boolean optional) {
71	myIsOptional = optional;	1✔
72	}	1✔
73
74	public @NotNull String getVariableClass() {
75	return myVariableClass;	1✔
76	}
77
78	public String toStringShort() {
79	return StringUtil.isNotEmpty(myArgumentName) ? myArgumentType.getSigil() + myArgumentName : PerlLexer.STRING_UNDEF;	1✔
80	}
81
82	public String toStringLong() {
83	if (StringUtil.isEmpty(myArgumentName)) {	1✔
84	return PerlLexer.STRING_UNDEF;	1✔
85	}
86
87	String shortName = myArgumentType.getSigil() + myArgumentName;	1✔
88	return StringUtil.isNotEmpty(myVariableClass) ? myVariableClass + " " + shortName : shortName;	1✔
89	}
90
91	@Override
92	public String toString() {
93	String toString = toStringLong();	1✔
94	return myIsOptional ? "[" + toString + "]" : toString;	1✔
95	}
96
97	private void serialize(@NotNull StubOutputStream dataStream) throws IOException {
98	dataStream.writeName(myArgumentType.toString());	1✔
99	dataStream.writeName(myArgumentName);	1✔
100	dataStream.writeName(myVariableClass);	1✔
101	dataStream.writeBoolean(myIsOptional);	1✔
102	}	1✔
103
104	public boolean isSelf(Project project) {
105	return getArgumentType() == PerlVariableType.SCALAR && PerlSharedSettings.getInstance(project).isSelfName(getArgumentName());	1✔
106	}
107
108	public boolean isEmpty() {
109	return StringUtil.isEmpty(myArgumentName);	1✔
110	}
111
112	public PerlContextType getContextType() {
113	if (myArgumentType == PerlVariableType.SCALAR \|\| myArgumentType == PerlVariableType.CODE \|\| myArgumentType == PerlVariableType.GLOB) {	1✔
114	return PerlContextType.SCALAR;	1✔
115	}
116	return PerlContextType.LIST;	1✔
117	}
118
119	@Override
120	public boolean equals(Object o) {
121	if (this == o) {	1✔
UNCOV 122	return true;	×
123	}
124	if (o == null \|\| getClass() != o.getClass()) {	1✔
UNCOV 125	return false;	×
126	}
127
128	PerlSubArgument argument = (PerlSubArgument)o;	1✔
129
130	return myArgumentType == argument.myArgumentType &&	1✔
131	myArgumentName.equals(argument.myArgumentName) &&	1✔
132	myVariableClass.equals(argument.myVariableClass) &&	1✔
133	(Objects.equals(myIsOptional, argument.myIsOptional));	1✔
134	}
135
136	@Override
137	public int hashCode() {
138	int result = myArgumentType.hashCode();	1✔
139	result = 31 * result + myArgumentName.hashCode();	1✔
140	result = 31 * result + myVariableClass.hashCode();	1✔
141	result = 31 * result + (myIsOptional != null ? myIsOptional.hashCode() : 0);	1✔
142	return result;	1✔
143	}
144
145	public static PerlSubArgument optionalScalar(@NotNull String variableName) {
146	return create(PerlVariableType.SCALAR, variableName, true);	1✔
147	}
148
149	public static PerlSubArgument optionalScalar(@NotNull String variableName, @Nullable String variableClass) {
150	return create(PerlVariableType.SCALAR, variableName, variableClass == null ? "" : variableClass, true);	1✔
151	}
152
153	public static PerlSubArgument mandatoryScalar(@NotNull String variableName) {
154	return mandatoryScalar(variableName, "");	1✔
155	}
156
157	public static @NotNull PerlSubArgument mandatoryScalar(@NotNull String variableName, @NotNull String variableClass) {
158	return mandatory(PerlVariableType.SCALAR, variableName, variableClass);	1✔
159	}
160
161	public static PerlSubArgument mandatory(@NotNull PerlVariableType variableType, @NotNull String variableName) {
162	return create(variableType, variableName, false);	1✔
163	}
164
165	public static PerlSubArgument mandatory(@NotNull PerlVariableType variableType,
166	@NotNull String variableName,
167	@NotNull String variableClass) {
168	return create(variableType, variableName, variableClass, false);	1✔
169	}
170
171	public static PerlSubArgument create(@NotNull PerlVariableType variableType, @NotNull String variableName, boolean isOptional) {
172	return create(variableType, variableName, "", isOptional);	1✔
173	}
174
175	public static PerlSubArgument create(@NotNull PerlVariableType variableType,
176	@NotNull String variableName,
177	@NotNull String variableClass,
178	boolean isOptional) {
179	return new PerlSubArgument(variableType, variableName, variableClass, isOptional);	1✔
180	}
181
182	@SuppressWarnings("ConstantConditions")
183	private static PerlSubArgument deserialize(@NotNull StubInputStream dataStream) throws IOException {
184	PerlVariableType argumentType = PerlVariableType.valueOf(dataStream.readName().toString());	1✔
185	String argumentName = dataStream.readName().toString();	1✔
186	String variableClass = dataStream.readName().toString();	1✔
187	boolean isOptional = dataStream.readBoolean();	1✔
188	return PerlSubArgument.create(argumentType, argumentName, variableClass, isOptional);	1✔
189	}
190
191	public static @NotNull List<PerlSubArgument> deserializeList(@NotNull StubInputStream dataStream) throws IOException {
192	int argumentsNumber = dataStream.readVarInt();	1✔
193
194	if (argumentsNumber <= 0) {	1✔
195	return Collections.emptyList();	1✔
196	}
197	List<PerlSubArgument> arguments = new ArrayList<>(argumentsNumber);	1✔
198	for (int i = 0; i < argumentsNumber; i++) {	1✔
199	arguments.add(deserialize(dataStream));	1✔
200	}
201	return arguments;	1✔
202	}
203
204	public static PerlSubArgument empty() {
205	return mandatoryScalar("");	1✔
206	}
207
208	public static PerlSubArgument self() {
209	return mandatoryScalar(DEFAULT_SELF_NAME);	1✔
210	}
211
212	public static void serializeList(@NotNull StubOutputStream dataStream, List<? extends PerlSubArgument> arguments) throws IOException {
213	dataStream.writeVarInt(arguments.size());	1✔
214	for (PerlSubArgument argument : arguments) {	1✔
215	argument.serialize(dataStream);	1✔
216	}	1✔
217	}	1✔
218	}

Camelcade / Perl5-IDEA / #525521563

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