#525521660

Committed 24 Aug 2025 01:28PM UTC coverage: 75.89% (-6.3%) from 82.227%

Build # #525521660

Build Type

push

github

Committed by

hurricup

Commit Message

Migrated coverage reporting to https://github.com/nbaztec/coveralls-jacoco-gradle-plugin

See: https://github.com/kt3k/coveralls-gradle-plugin/issues/119

Run Details

14751 of 22639 branches covered (65.16%)

Branch coverage included in aggregate %.

31091 of 37767 relevant lines covered (82.32%)

0.82 hits per line

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

91.01

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

Camelcade / Perl5-IDEA / #525521660

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