#525521834

Committed 29 Apr 2026 05:25AM UTC coverage: 76.138% (-0.07%) from 76.208%

Build # #525521834

Build Type

push

github

Committed by

hurricup

Commit Message

Bump gradle-wrapper from 9.4.1 to 9.5.0

Bumps [gradle-wrapper](https://github.com/gradle/gradle) from 9.4.1 to 9.5.0.
- [Release notes](https://github.com/gradle/gradle/releases)
- [Commits](https://github.com/gradle/gradle/compare/v9.4.1...v9.5.0)

---
updated-dependencies:
- dependency-name: gradle-wrapper
  dependency-version: 9.5.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Coverage Stats

14749 of 22542 branches covered (65.43%)

Branch coverage included in aggregate %.

31073 of 37641 relevant lines covered (82.55%)

0.83 hits per line

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

72.22

/plugin/common/src/main/java/com/perl5/lang/perl/psi/light/PerlLightNamespaceDefinitionElement.java

/*
 * Copyright 2015-2026 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.light;

import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.tree.IElementType;
import com.intellij.util.IncorrectOperationException;
import com.perl5.lang.perl.psi.PerlNamespaceDefinitionWithIdentifier;
import com.perl5.lang.perl.psi.PerlNamespaceElement;
import com.perl5.lang.perl.psi.PerlVisitor;
import com.perl5.lang.perl.psi.impl.PerlPolyNamedElement;
import com.perl5.lang.perl.psi.mro.PerlMroType;
import com.perl5.lang.perl.psi.stubs.namespaces.PerlNamespaceDefinitionStub;
import com.perl5.lang.perl.psi.utils.PerlNamespaceAnnotations;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.List;
import java.util.Map;

public class PerlLightNamespaceDefinitionElement extends PerlDelegatingLightNamedElement<PerlPolyNamedElement<?>>
  implements PerlNamespaceDefinitionWithIdentifier {

  private final @NotNull PerlMroType myMroType;

  private final @NotNull List<String> myParentNamespacesNames;

  private final @Nullable PerlNamespaceAnnotations myAnnotations;

  private final @NotNull List<String> myExport;

  private final @NotNull List<String> myExportOk;

  private final @NotNull Map<String, List<String>> myExportTags;

  public PerlLightNamespaceDefinitionElement(@NotNull PerlPolyNamedElement<?> delegate, @NotNull PerlNamespaceDefinitionStub stub) {
    super(delegate, stub.getNamespaceName(), stub.getElementType());
    myMroType = stub.getMroType();
    myParentNamespacesNames = stub.getParentNamespacesNames();
    myAnnotations = stub.getAnnotations();
    myExport = stub.getEXPORT();
    myExportOk = stub.getEXPORT_OK();
    myExportTags = stub.getEXPORT_TAGS();
  }

  public PerlLightNamespaceDefinitionElement(@NotNull PerlPolyNamedElement<?> delegate,
                                             @NotNull String name,
                                             @NotNull IElementType elementType,
                                             @NotNull PsiElement nameIdentifier,
                                             @NotNull PerlMroType mroType,
                                             @NotNull List<String> parentNamespacesNames,
                                             @Nullable PerlNamespaceAnnotations annotations,
                                             @NotNull List<String> export,
                                             @NotNull List<String> exportOk,
                                             @NotNull Map<String, List<String>> exportTags) {
    super(delegate, name, elementType, nameIdentifier);
    myMroType = mroType;
    myParentNamespacesNames = parentNamespacesNames;
    myAnnotations = annotations;
    myExport = export;
    myExportOk = exportOk;
    myExportTags = exportTags;
  }

  @Override
  public @NotNull String getNamespaceName() {
    return getName();
  }

  @Override
  public @NotNull PerlMroType getMroType() {
    return myMroType;
  }

  @Override
  public @NotNull List<String> getParentNamespacesNames() {
    return myParentNamespacesNames;
  }

  @Override
  public @Nullable PerlNamespaceAnnotations getAnnotations() {
    return myAnnotations;
  }

  @Override
  public @NotNull List<String> getEXPORT() {
    return myExport;
  }

  @Override
  public @NotNull List<String> getEXPORT_OK() {
    return myExportOk;
  }

  @Override
  public @NotNull Map<String, List<String>> getEXPORT_TAGS() {
    return myExportTags;
  }

  @Override
  public @Nullable PerlNamespaceElement getNamespaceElement() {
    throw new IncorrectOperationException("should not");
  }

  @Override
  public void accept(@NotNull PsiElementVisitor visitor) {
    if (visitor instanceof PerlVisitor perlVisitor) {
      perlVisitor.visitPerlNamespaceDefinitionWithIdentifier(this);
    }
    else {
      super.accept(visitor);
    }
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (!(o instanceof PerlLightNamespaceDefinitionElement element)) {
      return false;
    }
    if (!super.equals(o)) {
      return false;
    }

    if (getMroType() != element.getMroType()) {
      return false;
    }
    if (!getParentNamespacesNames().equals(element.getParentNamespacesNames())) {
      return false;
    }
    if (getAnnotations() != null ? !getAnnotations().equals(element.getAnnotations()) : element.getAnnotations() != null) {
      return false;
    }
    if (!myExport.equals(element.myExport)) {
      return false;
    }
    if (!myExportOk.equals(element.myExportOk)) {
      return false;
    }
    return myExportTags.equals(element.myExportTags);
  }

  @Override
  public int hashCode() {
    int result = super.hashCode();
    result = 31 * result + getMroType().hashCode();
    result = 31 * result + getParentNamespacesNames().hashCode();
    result = 31 * result + (getAnnotations() != null ? getAnnotations().hashCode() : 0);
    result = 31 * result + myExport.hashCode();
    result = 31 * result + myExportOk.hashCode();
    result = 31 * result + myExportTags.hashCode();
    return result;
  }

  @Override
  public String toString() {
    return "PerlLightNamespaceDefinitionElement{" +
           "myName='" + myName + '\'' +
           ", myMroType=" + myMroType +
           ", myParentNamespacesNames=" + myParentNamespacesNames +
           ", myAnnotations=" + myAnnotations +
           ", myExport=" + myExport +
           ", myExportOk=" + myExportOk +
           ", myExportTags=" + myExportTags +
           '}';
  }
}

1	/*
2	* Copyright 2015-2026 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.light;
18
19	import com.intellij.psi.PsiElement;
20	import com.intellij.psi.PsiElementVisitor;
21	import com.intellij.psi.tree.IElementType;
22	import com.intellij.util.IncorrectOperationException;
23	import com.perl5.lang.perl.psi.PerlNamespaceDefinitionWithIdentifier;
24	import com.perl5.lang.perl.psi.PerlNamespaceElement;
25	import com.perl5.lang.perl.psi.PerlVisitor;
26	import com.perl5.lang.perl.psi.impl.PerlPolyNamedElement;
27	import com.perl5.lang.perl.psi.mro.PerlMroType;
28	import com.perl5.lang.perl.psi.stubs.namespaces.PerlNamespaceDefinitionStub;
29	import com.perl5.lang.perl.psi.utils.PerlNamespaceAnnotations;
30	import org.jetbrains.annotations.NotNull;
31	import org.jetbrains.annotations.Nullable;
32
33	import java.util.List;
34	import java.util.Map;
35
36	public class PerlLightNamespaceDefinitionElement extends PerlDelegatingLightNamedElement<PerlPolyNamedElement<?>>
37	implements PerlNamespaceDefinitionWithIdentifier {
38
39	private final @NotNull PerlMroType myMroType;
40
41	private final @NotNull List<String> myParentNamespacesNames;
42
43	private final @Nullable PerlNamespaceAnnotations myAnnotations;
44
45	private final @NotNull List<String> myExport;
46
47	private final @NotNull List<String> myExportOk;
48
49	private final @NotNull Map<String, List<String>> myExportTags;
50
51	public PerlLightNamespaceDefinitionElement(@NotNull PerlPolyNamedElement<?> delegate, @NotNull PerlNamespaceDefinitionStub stub) {
52	super(delegate, stub.getNamespaceName(), stub.getElementType());	1✔
53	myMroType = stub.getMroType();	1✔
54	myParentNamespacesNames = stub.getParentNamespacesNames();	1✔
55	myAnnotations = stub.getAnnotations();	1✔
56	myExport = stub.getEXPORT();	1✔
57	myExportOk = stub.getEXPORT_OK();	1✔
58	myExportTags = stub.getEXPORT_TAGS();	1✔
59	}	1✔
60
61	public PerlLightNamespaceDefinitionElement(@NotNull PerlPolyNamedElement<?> delegate,
62	@NotNull String name,
63	@NotNull IElementType elementType,
64	@NotNull PsiElement nameIdentifier,
65	@NotNull PerlMroType mroType,
66	@NotNull List<String> parentNamespacesNames,
67	@Nullable PerlNamespaceAnnotations annotations,
68	@NotNull List<String> export,
69	@NotNull List<String> exportOk,
70	@NotNull Map<String, List<String>> exportTags) {
71	super(delegate, name, elementType, nameIdentifier);	1✔
72	myMroType = mroType;	1✔
73	myParentNamespacesNames = parentNamespacesNames;	1✔
74	myAnnotations = annotations;	1✔
75	myExport = export;	1✔
76	myExportOk = exportOk;	1✔
77	myExportTags = exportTags;	1✔
78	}	1✔
79
80	@Override
81	public @NotNull String getNamespaceName() {
82	return getName();	1!
83	}
84
85	@Override
86	public @NotNull PerlMroType getMroType() {
87	return myMroType;	1!
88	}
89
90	@Override
91	public @NotNull List<String> getParentNamespacesNames() {
92	return myParentNamespacesNames;	1!
93	}
94
95	@Override
96	public @Nullable PerlNamespaceAnnotations getAnnotations() {
97	return myAnnotations;	1✔
98	}
99
100	@Override
101	public @NotNull List<String> getEXPORT() {
102	return myExport;	1!
103	}
104
105	@Override
106	public @NotNull List<String> getEXPORT_OK() {
107	return myExportOk;	1!
108	}
109
110	@Override
111	public @NotNull Map<String, List<String>> getEXPORT_TAGS() {
112	return myExportTags;	1!
113	}
114
115	@Override
116	public @Nullable PerlNamespaceElement getNamespaceElement() {
117	throw new IncorrectOperationException("should not");	×
118	}
119
120	@Override
121	public void accept(@NotNull PsiElementVisitor visitor) {
122	if (visitor instanceof PerlVisitor perlVisitor) {	1!
123	perlVisitor.visitPerlNamespaceDefinitionWithIdentifier(this);	1✔
124	}
125	else {
126	super.accept(visitor);	×
127	}
128	}	1✔
129
130	@Override
131	public boolean equals(Object o) {
132	if (this == o) {	1✔
133	return true;	1✔
134	}
135	if (!(o instanceof PerlLightNamespaceDefinitionElement element)) {	1!
136	return false;	×
137	}
138	if (!super.equals(o)) {	1✔
139	return false;	1✔
140	}
141
142	if (getMroType() != element.getMroType()) {	1!
143	return false;	×
144	}
145	if (!getParentNamespacesNames().equals(element.getParentNamespacesNames())) {	1!
146	return false;	×
147	}
148	if (getAnnotations() != null ? !getAnnotations().equals(element.getAnnotations()) : element.getAnnotations() != null) {	1!
149	return false;	×
150	}
151	if (!myExport.equals(element.myExport)) {	1!
152	return false;	×
153	}
154	if (!myExportOk.equals(element.myExportOk)) {	1!
155	return false;	×
156	}
157	return myExportTags.equals(element.myExportTags);	1✔
158	}
159
160	@Override
161	public int hashCode() {
162	int result = super.hashCode();	1✔
163	result = 31 * result + getMroType().hashCode();	1✔
164	result = 31 * result + getParentNamespacesNames().hashCode();	1✔
165	result = 31 * result + (getAnnotations() != null ? getAnnotations().hashCode() : 0);	1!
166	result = 31 * result + myExport.hashCode();	1✔
167	result = 31 * result + myExportOk.hashCode();	1✔
168	result = 31 * result + myExportTags.hashCode();	1✔
169	return result;	1✔
170	}
171
172	@Override
173	public String toString() {
174	return "PerlLightNamespaceDefinitionElement{" +	1✔
175	"myName='" + myName + '\'' +
176	", myMroType=" + myMroType +
177	", myParentNamespacesNames=" + myParentNamespacesNames +
178	", myAnnotations=" + myAnnotations +
179	", myExport=" + myExport +
180	", myExportOk=" + myExportOk +
181	", myExportTags=" + myExportTags +
182	'}';
183	}
184	}

Camelcade / Perl5-IDEA / #525521834

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