#525521567

Committed 03 Jun 2025 07:42AM UTC coverage: 82.347% (+0.008%) from 82.339%

Build # #525521567

Build Type

push

github

Committed by

hurricup

Commit Message

Localization Perl plugin

Run Details

4 of 11 new or added lines in 5 files covered. (36.36%)

96 existing lines in 21 files now uncovered.

30852 of 37466 relevant lines covered (82.35%)

0.82 hits per line

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

97.25

/mason/mason2/core/src/main/java/com/perl5/lang/perl/parser/Mason2TemplatingParserImpl.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.parser;

import com.intellij.lang.PsiBuilder;
import com.intellij.lang.WhitespacesBinders;
import com.intellij.lang.parser.GeneratedParserUtilBase;
import com.intellij.psi.tree.IElementType;
import com.perl5.lang.mason2.Mason2Bundle;

import static com.perl5.lang.perl.parser.PerlElementTypesGenerated.*;


public class Mason2TemplatingParserImpl extends Mason2ParserImpl {

  @Override
  public boolean parseStatement(PsiBuilder b, int l) {
    IElementType tokenType = b.getTokenType();

    boolean r = false;
    PsiBuilder.Marker m = b.mark();

    if (tokenType == MASON_BLOCK_OPENER) {
      PsiBuilder.Marker statementMarker = b.mark();
      b.advanceLexer();
      if (PerlParserProxy.expr(b, l, -1)) {
        // parseStatement filter
        if (GeneratedParserUtilBase.consumeToken(b, MASON_EXPR_FILTER_PIPE)) {
          while (b.getTokenType() == IDENTIFIER) {
            PsiBuilder.Marker fm = b.mark();
            b.advanceLexer();
            fm.collapse(SUB_NAME);
            fm.precede().done(METHOD);

            if (!GeneratedParserUtilBase.consumeToken(b, COMMA)) {
              break;
            }
          }
        }
      }
      if (r = MasonParserUtil.endOrRecover(b, MASON_BLOCK_CLOSER)) {
        statementMarker.done(STATEMENT);
      }
    }
    if (tokenType == MASON_CALL_OPENER) {
      PsiBuilder.Marker statementMarker = b.mark();
      b.advanceLexer();
      PerlParserProxy.expr(b, l, -1);
      if (r = MasonParserUtil.endOrRecover(b, MASON_CALL_CLOSER)) {
        statementMarker.done(MASON_CALL_STATEMENT);
      }
    }
    else if (tokenType == MASON_CLASS_OPENER) {
      r = parsePerlBlock(b, l, MASON_CLASS_CLOSER);
    }
    else if (tokenType == MASON_INIT_OPENER) {
      r = parsePerlBlock(b, l, MASON_INIT_CLOSER);
    }
    else if (tokenType == MASON_PERL_OPENER) {
      r = parsePerlBlock(b, l, MASON_PERL_CLOSER);
    }
    else if (tokenType == MASON_FLAGS_OPENER) {
      b.advanceLexer();
      PsiBuilder.Marker statementMarker = b.mark();

      while (!b.eof() && b.getTokenType() != MASON_FLAGS_CLOSER) {
        if (!PerlParserProxy.expr(b, l, -1)) {
          break;
        }
      }
      statementMarker.done(MASON_FLAGS_STATEMENT);

      r = MasonParserUtil.endOrRecover(b, MASON_FLAGS_CLOSER);
    }
    else if (tokenType == MASON_DOC_OPENER) {
      b.advanceLexer();
      GeneratedParserUtilBase.consumeToken(b, COMMENT_BLOCK);
      r = MasonParserUtil.endOrRecover(b, MASON_DOC_CLOSER);
    }
    else if (tokenType == MASON_TEXT_OPENER) {
      b.advanceLexer();
      PsiBuilder.Marker stringMarker = b.mark();
      if (GeneratedParserUtilBase.consumeToken(b, STRING_CONTENT)) {
        stringMarker.done(MASON_TEXT_BLOCK);
      }
      else {
        stringMarker.drop();
      }
      r = MasonParserUtil.endOrRecover(b, MASON_TEXT_CLOSER);
    }
    else if (tokenType == MASON_METHOD_OPENER) {
      r = parseMasonMethod(b, l, MASON_METHOD_CLOSER, MASON_METHOD_DEFINITION);
    }
    else if (tokenType == MASON_FILTER_OPENER) {
      r = parseMasonMethod(b, l, MASON_FILTER_CLOSER, MASON_FILTER_DEFINITION);
    }
    else if (tokenType == MASON_OVERRIDE_OPENER) {
      r = parseMasonMethod(b, l, MASON_OVERRIDE_CLOSER, MASON_OVERRIDE_DEFINITION);
    }
    else if (SIMPLE_MASON_NAMED_BLOCKS.contains(tokenType)) // simple named blocks
    {
      PsiBuilder.Marker statementMarker = b.mark();
      b.advanceLexer();
      IElementType closeToken = RESERVED_OPENER_TO_CLOSER_MAP.get(tokenType);

      if (GeneratedParserUtilBase.consumeToken(b, SUB_NAME) && GeneratedParserUtilBase.consumeToken(b, MASON_TAG_CLOSER)) {
        PsiBuilder.Marker blockMarker = b.mark();
        PerlParserProxy.block_content(b, l);
        blockMarker.done(BLOCK_BRACELESS);
        blockMarker.setCustomEdgeTokenBinders(WhitespacesBinders.GREEDY_LEFT_BINDER, WhitespacesBinders.GREEDY_RIGHT_BINDER);

        if (r = GeneratedParserUtilBase.consumeToken(b, closeToken)) {
          statementMarker.done(RESERVED_TO_STATEMENT_MAP.get(tokenType));
          statementMarker = null;
        }
      }

      if (statementMarker != null) {
        statementMarker.drop();
      }

      r = r || MasonParserUtil.recoverToGreedy(b, closeToken, Mason2Bundle.message("parsing.error.error"));
    }

    if (r) {
      m.drop();
    }
    else {
      m.rollbackTo();
    }

    return r || super.parseStatement(b, l);
  }

  @Override
  public boolean parseStatementModifier(PsiBuilder b, int l) {
    if (b.getTokenType() == MASON_FILTERED_BLOCK_OPENER) {
      return MasonParserUtil.parsePerlBlock(b, l, MASON_FILTERED_BLOCK_CLOSER, MASON_FILTERED_BLOCK);
    }
    return super.parseStatementModifier(b, l);
  }

  @Override
  public boolean parseTerm(PsiBuilder b, int l) {
    if (b.getTokenType() == MASON_SELF_POINTER) {
      PsiBuilder.Marker m = b.mark();
      b.advanceLexer();
      if (regular_nested_call(b, l)) {
        m.done(MASON_SIMPLE_DEREF_EXPR);
      }
      else {
        m.error(Mason2Bundle.message("parsing.error.error.parsing.filter.expression"));
      }
      return true;
    }
    return super.parseTerm(b, l);
  }

  public static boolean parseMasonMethod(PsiBuilder b, int l, IElementType closeToken, IElementType statementTokenType) {
    boolean r = false;

    PsiBuilder.Marker methodMarker = b.mark();
    b.advanceLexer();
    PsiBuilder.Marker subMarker = b.mark();
    if (GeneratedParserUtilBase.consumeToken(b, SUB_NAME)) {
      subMarker.collapse(SUB_NAME);
      PerlParserProxy.method_signature(b, l);
      if (GeneratedParserUtilBase.consumeToken(b, MASON_TAG_CLOSER)) {
        PsiBuilder.Marker blockMarker = b.mark();
        PerlParserProxy.block_content(b, l);

        if (b.getTokenType() == closeToken) {
          blockMarker.done(BLOCK_BRACELESS);
          blockMarker.setCustomEdgeTokenBinders(WhitespacesBinders.GREEDY_LEFT_BINDER, WhitespacesBinders.GREEDY_RIGHT_BINDER);
          b.advanceLexer();
          methodMarker.done(statementTokenType);
          r = true;
        }
      }
    }

    if (!r) {
      methodMarker.rollbackTo();
    }

    return r || MasonParserUtil.recoverToGreedy(b, closeToken, Mason2Bundle.message("parsing.error.error"));
  }

  protected static boolean parsePerlBlock(PsiBuilder b, int l, IElementType closeToken) {
    return MasonParserUtil.parsePerlBlock(b, l, closeToken, MASON_ABSTRACT_BLOCK);
  }
}

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.parser;
18
19	import com.intellij.lang.PsiBuilder;
20	import com.intellij.lang.WhitespacesBinders;
21	import com.intellij.lang.parser.GeneratedParserUtilBase;
22	import com.intellij.psi.tree.IElementType;
23	import com.perl5.lang.mason2.Mason2Bundle;
24
25	import static com.perl5.lang.perl.parser.PerlElementTypesGenerated.*;
26
27
28	public class Mason2TemplatingParserImpl extends Mason2ParserImpl {	1✔
29
30	@Override
31	public boolean parseStatement(PsiBuilder b, int l) {
32	IElementType tokenType = b.getTokenType();	1✔
33
34	boolean r = false;	1✔
35	PsiBuilder.Marker m = b.mark();	1✔
36
37	if (tokenType == MASON_BLOCK_OPENER) {	1✔
38	PsiBuilder.Marker statementMarker = b.mark();	1✔
39	b.advanceLexer();	1✔
40	if (PerlParserProxy.expr(b, l, -1)) {	1✔
41	// parseStatement filter
42	if (GeneratedParserUtilBase.consumeToken(b, MASON_EXPR_FILTER_PIPE)) {	1✔
43	while (b.getTokenType() == IDENTIFIER) {	1✔
44	PsiBuilder.Marker fm = b.mark();	1✔
45	b.advanceLexer();	1✔
46	fm.collapse(SUB_NAME);	1✔
47	fm.precede().done(METHOD);	1✔
48
49	if (!GeneratedParserUtilBase.consumeToken(b, COMMA)) {	1✔
50	break;	1✔
51	}
UNCOV 52	}	×
53	}
54	}
55	if (r = MasonParserUtil.endOrRecover(b, MASON_BLOCK_CLOSER)) {	1✔
56	statementMarker.done(STATEMENT);	1✔
57	}
58	}
59	if (tokenType == MASON_CALL_OPENER) {	1✔
60	PsiBuilder.Marker statementMarker = b.mark();	1✔
61	b.advanceLexer();	1✔
62	PerlParserProxy.expr(b, l, -1);	1✔
63	if (r = MasonParserUtil.endOrRecover(b, MASON_CALL_CLOSER)) {	1✔
64	statementMarker.done(MASON_CALL_STATEMENT);	1✔
65	}
66	}	1✔
67	else if (tokenType == MASON_CLASS_OPENER) {	1✔
68	r = parsePerlBlock(b, l, MASON_CLASS_CLOSER);	1✔
69	}
70	else if (tokenType == MASON_INIT_OPENER) {	1✔
71	r = parsePerlBlock(b, l, MASON_INIT_CLOSER);	1✔
72	}
73	else if (tokenType == MASON_PERL_OPENER) {	1✔
74	r = parsePerlBlock(b, l, MASON_PERL_CLOSER);	1✔
75	}
76	else if (tokenType == MASON_FLAGS_OPENER) {	1✔
77	b.advanceLexer();	1✔
78	PsiBuilder.Marker statementMarker = b.mark();	1✔
79
80	while (!b.eof() && b.getTokenType() != MASON_FLAGS_CLOSER) {	1✔
81	if (!PerlParserProxy.expr(b, l, -1)) {	1✔
82	break;	1✔
83	}
84	}
85	statementMarker.done(MASON_FLAGS_STATEMENT);	1✔
86
87	r = MasonParserUtil.endOrRecover(b, MASON_FLAGS_CLOSER);	1✔
88	}	1✔
89	else if (tokenType == MASON_DOC_OPENER) {	1✔
90	b.advanceLexer();	1✔
91	GeneratedParserUtilBase.consumeToken(b, COMMENT_BLOCK);	1✔
92	r = MasonParserUtil.endOrRecover(b, MASON_DOC_CLOSER);	1✔
93	}
94	else if (tokenType == MASON_TEXT_OPENER) {	1✔
95	b.advanceLexer();	1✔
96	PsiBuilder.Marker stringMarker = b.mark();	1✔
97	if (GeneratedParserUtilBase.consumeToken(b, STRING_CONTENT)) {	1✔
98	stringMarker.done(MASON_TEXT_BLOCK);	1✔
99	}
100	else {
101	stringMarker.drop();	1✔
102	}
103	r = MasonParserUtil.endOrRecover(b, MASON_TEXT_CLOSER);	1✔
104	}	1✔
105	else if (tokenType == MASON_METHOD_OPENER) {	1✔
106	r = parseMasonMethod(b, l, MASON_METHOD_CLOSER, MASON_METHOD_DEFINITION);	1✔
107	}
108	else if (tokenType == MASON_FILTER_OPENER) {	1✔
109	r = parseMasonMethod(b, l, MASON_FILTER_CLOSER, MASON_FILTER_DEFINITION);	1✔
110	}
111	else if (tokenType == MASON_OVERRIDE_OPENER) {	1✔
112	r = parseMasonMethod(b, l, MASON_OVERRIDE_CLOSER, MASON_OVERRIDE_DEFINITION);	1✔
113	}
114	else if (SIMPLE_MASON_NAMED_BLOCKS.contains(tokenType)) // simple named blocks	1✔
115	{
116	PsiBuilder.Marker statementMarker = b.mark();	1✔
117	b.advanceLexer();	1✔
118	IElementType closeToken = RESERVED_OPENER_TO_CLOSER_MAP.get(tokenType);	1✔
119
120	if (GeneratedParserUtilBase.consumeToken(b, SUB_NAME) && GeneratedParserUtilBase.consumeToken(b, MASON_TAG_CLOSER)) {	1✔
121	PsiBuilder.Marker blockMarker = b.mark();	1✔
122	PerlParserProxy.block_content(b, l);	1✔
123	blockMarker.done(BLOCK_BRACELESS);	1✔
124	blockMarker.setCustomEdgeTokenBinders(WhitespacesBinders.GREEDY_LEFT_BINDER, WhitespacesBinders.GREEDY_RIGHT_BINDER);	1✔
125
126	if (r = GeneratedParserUtilBase.consumeToken(b, closeToken)) {	1✔
127	statementMarker.done(RESERVED_TO_STATEMENT_MAP.get(tokenType));	1✔
128	statementMarker = null;	1✔
129	}
130	}
131
132	if (statementMarker != null) {	1✔
UNCOV 133	statementMarker.drop();	×
134	}
135
136	r = r \|\| MasonParserUtil.recoverToGreedy(b, closeToken, Mason2Bundle.message("parsing.error.error"));	1✔
137	}
138
139	if (r) {	1✔
140	m.drop();	1✔
141	}
142	else {
143	m.rollbackTo();	1✔
144	}
145
146	return r \|\| super.parseStatement(b, l);	1✔
147	}
148
149	@Override
150	public boolean parseStatementModifier(PsiBuilder b, int l) {
151	if (b.getTokenType() == MASON_FILTERED_BLOCK_OPENER) {	1✔
152	return MasonParserUtil.parsePerlBlock(b, l, MASON_FILTERED_BLOCK_CLOSER, MASON_FILTERED_BLOCK);	1✔
153	}
154	return super.parseStatementModifier(b, l);	1✔
155	}
156
157	@Override
158	public boolean parseTerm(PsiBuilder b, int l) {
159	if (b.getTokenType() == MASON_SELF_POINTER) {	1✔
160	PsiBuilder.Marker m = b.mark();	1✔
161	b.advanceLexer();	1✔
162	if (regular_nested_call(b, l)) {	1✔
163	m.done(MASON_SIMPLE_DEREF_EXPR);	1✔
164	}
165	else {
UNCOV 166	m.error(Mason2Bundle.message("parsing.error.error.parsing.filter.expression"));	×
167	}
168	return true;	1✔
169	}
170	return super.parseTerm(b, l);	1✔
171	}
172
173	public static boolean parseMasonMethod(PsiBuilder b, int l, IElementType closeToken, IElementType statementTokenType) {
174	boolean r = false;	1✔
175
176	PsiBuilder.Marker methodMarker = b.mark();	1✔
177	b.advanceLexer();	1✔
178	PsiBuilder.Marker subMarker = b.mark();	1✔
179	if (GeneratedParserUtilBase.consumeToken(b, SUB_NAME)) {	1✔
180	subMarker.collapse(SUB_NAME);	1✔
181	PerlParserProxy.method_signature(b, l);	1✔
182	if (GeneratedParserUtilBase.consumeToken(b, MASON_TAG_CLOSER)) {	1✔
183	PsiBuilder.Marker blockMarker = b.mark();	1✔
184	PerlParserProxy.block_content(b, l);	1✔
185
186	if (b.getTokenType() == closeToken) {	1✔
187	blockMarker.done(BLOCK_BRACELESS);	1✔
188	blockMarker.setCustomEdgeTokenBinders(WhitespacesBinders.GREEDY_LEFT_BINDER, WhitespacesBinders.GREEDY_RIGHT_BINDER);	1✔
189	b.advanceLexer();	1✔
190	methodMarker.done(statementTokenType);	1✔
191	r = true;	1✔
192	}
193	}
194	}
195
196	if (!r) {	1✔
197	methodMarker.rollbackTo();	1✔
198	}
199
200	return r \|\| MasonParserUtil.recoverToGreedy(b, closeToken, Mason2Bundle.message("parsing.error.error"));	1✔
201	}
202
203	protected static boolean parsePerlBlock(PsiBuilder b, int l, IElementType closeToken) {
204	return MasonParserUtil.parsePerlBlock(b, l, closeToken, MASON_ABSTRACT_BLOCK);	1✔
205	}
206	}

Camelcade / Perl5-IDEA / #525521567

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