/** * Tries to calculate given line's indent column assuming that there might be a comment at the * given indent offset (see {@link #getCommentPrefix(IElementType)}). * * @param line target line * @param indentOffset start indent offset to use for the given line * @param lineEndOffset given line's end offset * @param fallbackColumn column to return if it's not possible to apply comment-specific indent * calculation rules * @return given line's indent column to use */ private int calcIndent(int line, int indentOffset, int lineEndOffset, int fallbackColumn) { final HighlighterIterator it = myEditor.getHighlighter().createIterator(indentOffset); IElementType tokenType = it.getTokenType(); Language language = tokenType.getLanguage(); TokenSet comments = myComments.get(language); if (comments == null) { ParserDefinition definition = LanguageParserDefinitions.INSTANCE.forLanguage(language); if (definition != null) { comments = definition.getCommentTokens(); } if (comments == null) { return fallbackColumn; } else { myComments.put(language, comments); } } if (comments.contains(tokenType) && indentOffset == it.getStart()) { String prefix = COMMENT_PREFIXES.get(tokenType); if (prefix == null) { prefix = getCommentPrefix(tokenType); } if (!NO_COMMENT_INFO_MARKER.equals(prefix)) { final int indentInsideCommentOffset = CharArrayUtil.shiftForward( myChars, indentOffset + prefix.length(), lineEndOffset, " \t"); if (indentInsideCommentOffset < lineEndOffset) { int indent = myEditor.calcColumnNumber(indentInsideCommentOffset, line); indentAfterUncomment.put(line, indent - prefix.length()); return indent; } } } return fallbackColumn; }
/* * SimpleName{,} */ private void parseFunctionLiteralShorthandParameterList() { PsiBuilder.Marker parameterList = mark(); while (!eof()) { PsiBuilder.Marker parameter = mark(); // int parameterNamePos = matchTokenStreamPredicate(new LastBefore(new // At(IDENTIFIER), new AtOffset(doubleArrowPos))); // createTruncatedBuilder(parameterNamePos).parseModifierList(MODIFIER_LIST, // false); if (at(COLON)) { error("Expecting parameter name"); } else { expect(IDENTIFIER, "Expecting parameter name", TokenSet.create(ARROW)); } if (at(COLON)) { advance(); // COLON myJetParsing.parseTypeRef(TokenSet.create(ARROW, COMMA)); } parameter.done(VALUE_PARAMETER); if (at(ARROW)) { break; } else if (at(COMMA)) { advance(); // COMMA } else { error("Expecting '->' or ','"); break; } } parameterList.done(VALUE_PARAMETER_LIST); }
/* * typeConstraint * : attributes SimpleName ":" type * : attributes "class" "object" SimpleName ":" type * ; */ private void parseTypeConstraint() { PsiBuilder.Marker constraint = mark(); parseAnnotations(false); if (at(CLASS_KEYWORD)) { advance(); // CLASS_KEYWORD expect(OBJECT_KEYWORD, "Expecting 'object'", TYPE_REF_FIRST); } PsiBuilder.Marker reference = mark(); if (expect( IDENTIFIER, "Expecting type parameter name", TokenSet.orSet(TokenSet.create(COLON, COMMA), TYPE_REF_FIRST))) { reference.done(REFERENCE_EXPRESSION); } else { reference.drop(); } expect(COLON, "Expecting ':' before the upper bound", TYPE_REF_FIRST); parseTypeRef(); constraint.done(TYPE_CONSTRAINT); }
/* * object * : "object" SimpleName? ":" delegationSpecifier{","}? classBody? * ; */ void parseObject(boolean named, boolean optionalBody) { assert _at(OBJECT_KEYWORD); advance(); // OBJECT_KEYWORD if (named) { PsiBuilder.Marker propertyDeclaration = mark(); if (!parseIdeTemplate()) { expect(IDENTIFIER, "Expecting object name", TokenSet.create(LBRACE)); } propertyDeclaration.done(OBJECT_DECLARATION_NAME); } else { if (at(IDENTIFIER)) { error("An object expression cannot bind a name"); } } if (optionalBody) { if (at(COLON)) { advance(); // COLON parseDelegationSpecifierList(); } if (at(LBRACE)) { parseClassBody(); } } else { if (at(LBRACE)) { parseClassBody(); } else { expect(COLON, "Expecting ':'", TokenSet.create(IDENTIFIER, PACKAGE_KEYWORD)); parseDelegationSpecifierList(); parseClassBody(); } } }
/** Created by IntelliJ IDEA. User: Jon S Akhtar Date: 4/3/11 Time: 12:27 AM */ public class MoonParsingLexerMergingAdapter extends MergingLexerAdapterBase implements MoonTokenTypes { static final TokenSet tokensToMerge = TokenSet.create(LONGSTRING_BEGIN, LONGSTRING, LONGSTRING_END, NL_BEFORE_LONGSTRING); static final TokenSet tokensToMerge2 = TokenSet.create(LONGCOMMENT_BEGIN, LONGCOMMENT, LONGCOMMENT_END, NL_BEFORE_LONGSTRING); static final TokenSet allMergables = TokenSet.orSet(tokensToMerge, tokensToMerge2); public MoonParsingLexerMergingAdapter(Lexer original) { super( original, new MergeFunction() { @Override public IElementType merge(IElementType type, Lexer originalLexer) { if (!allMergables.contains(type)) { return type; } TokenSet merging = tokensToMerge.contains(type) ? tokensToMerge : tokensToMerge2; while (true) { final IElementType tokenType = originalLexer.getTokenType(); if (!merging.contains(tokenType)) break; originalLexer.advance(); } return merging == tokensToMerge ? LONGSTRING : LONGCOMMENT; } }); } }
@Inject public XtendTokenSetProvider(final TokenTypeProvider tokenTypeProvider) { IElementType _iElementType = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_SL_COMMENT); TokenSet _create = TokenSet.create(_iElementType); this.slCommentTokens = _create; IElementType _iElementType_1 = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_RICH_TEXT); IElementType _iElementType_2 = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_RICH_TEXT_START); IElementType _iElementType_3 = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_RICH_TEXT_END); IElementType _iElementType_4 = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_RICH_TEXT_INBETWEEN); IElementType _iElementType_5 = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_COMMENT_RICH_TEXT_END); IElementType _iElementType_6 = tokenTypeProvider.getIElementType(PsiInternalXtendParser.RULE_COMMENT_RICH_TEXT_INBETWEEN); TokenSet _create_1 = TokenSet.create( _iElementType_1, _iElementType_2, _iElementType_3, _iElementType_4, _iElementType_5, _iElementType_6); this.richStringLiteralTokens = _create_1; }
/** Created by Michal on 18.11.2015. */ public class VaadinDesignParserDefinition implements ParserDefinition { public static final TokenSet WHITE_SPACES = TokenSet.create(TokenType.WHITE_SPACE); public static final TokenSet STRING_LITERALS = TokenSet.create(VDTypes.ATTR_VALUE); // public static final TokenSet COMMENTS = TokenSet.create(SimpleTypes.COMMENT); public static final IFileElementType FILE = new IFileElementType( Language.<VaadinDeclarativeLanguage>findInstance(VaadinDeclarativeLanguage.class)); @NotNull @Override public Lexer createLexer(Project project) { return new FlexAdapter(new VaadinDesignLexer(null)); } @Override public PsiParser createParser(Project project) { return new VaadinDesignParser(); } @Override public IFileElementType getFileNodeType() { return FILE; } @NotNull @Override public TokenSet getWhitespaceTokens() { return WHITE_SPACES; } @NotNull @Override public TokenSet getCommentTokens() { return TokenSet.EMPTY; } @NotNull @Override public TokenSet getStringLiteralElements() { return STRING_LITERALS; } @NotNull @Override public PsiElement createElement(ASTNode node) { return VDTypes.Factory.createElement(node); } @Override public PsiFile createFile(FileViewProvider viewProvider) { return new VaadinDesignFile(viewProvider); } @Override public SpaceRequirements spaceExistanceTypeBetweenTokens(ASTNode left, ASTNode right) { return SpaceRequirements.MAY; } }
/** * Statement recovery function. Should not consume token, only check; * * @param b PerlBuilder * @param l parsing level * @return parsing result */ public static boolean recoverStatement(PsiBuilder b, int l) { assert b instanceof PerlBuilder; if (!((PerlBuilder) b).isRecoveringStatement()) ((PerlBuilder) b).startRecovery(); IElementType currentTokenType = b.getTokenType(); // System.err.println("Checking " + b.getTokenText() + currentTokenType); if (currentTokenType == null // got end of file || ((PerlBuilder) b).getBracesLevel() == 0 && ( // we are not in braced statement UNCONDITIONAL_STATEMENT_RECOVERY_TOKENS.contains( currentTokenType) // got semi, package, end of regex, use, compound or suffix || currentTokenType == RESERVED_SUB && STATEMENT_RECOVERY_SUB_SUFFIX.contains(b.lookAhead(1)) // got sub definition )) { ((PerlBuilder) b).stopRecovery(); return false; } if (currentTokenType == LEFT_BRACE) ((PerlBuilder) b).openBrace(); else if (currentTokenType == RIGHT_BRACE) ((PerlBuilder) b).closeBrace(); return true; }
/** * Named list operators * * @param b PerlBuilder * @param l Parsing level * @return parsing result */ public static boolean isListOperator(PsiBuilder b, int l) { PerlTokenData prevTokenData = ((PerlBuilder) b).lookupToken(-1); if (prevTokenData != null && prevTokenData.getTokenType() == OPERATOR_DEREFERENCE) return false; IElementType tokenType = b.getTokenType(); IElementType nextTokenType = b.lookAhead(1); if (CONVERTABLE_TOKENS.contains(tokenType) && nextTokenType != LEFT_PAREN // not function call && !PACKAGE_TOKENS.contains(nextTokenType) // not method Package:: && !(nextTokenType == IDENTIFIER && ((PerlBuilder) b) .isKnownPackage( ((PerlBuilder) b).lookupToken(1).getTokenText())) // not Method Package ) // todo we should check current namespace here return !PerlSubUtil.BUILT_IN_UNARY.contains(b.getTokenText()); else if (PACKAGE_TOKENS.contains(tokenType) && CONVERTABLE_TOKENS.contains(nextTokenType) && b.lookAhead(2) != LEFT_PAREN) return !PerlSubUtil.isUnary( b.getTokenText(), ((PerlBuilder) b).lookupToken(1).getTokenText()); return false; }
public void parseSliceEnd(PsiBuilder.Marker exprStart, PsiBuilder.Marker sliceItemStart) { myBuilder.advanceLexer(); if (atToken(PyTokenTypes.RBRACKET)) { PsiBuilder.Marker sliceMarker = myBuilder.mark(); sliceMarker.done(PyElementTypes.EMPTY_EXPRESSION); sliceItemStart.done(PyElementTypes.SLICE_ITEM); nextToken(); exprStart.done(PyElementTypes.SLICE_EXPRESSION); return; } else { if (atToken(PyTokenTypes.COLON)) { PsiBuilder.Marker sliceMarker = myBuilder.mark(); sliceMarker.done(PyElementTypes.EMPTY_EXPRESSION); } else { parseSingleExpression(false); } if (!BRACKET_COLON_COMMA.contains(myBuilder.getTokenType())) { myBuilder.error(message("PARSE.expected.colon.or.rbracket")); } if (matchToken(PyTokenTypes.COLON)) { parseSingleExpression(false); } sliceItemStart.done(PyElementTypes.SLICE_ITEM); if (!BRACKET_OR_COMMA.contains(myBuilder.getTokenType())) { myBuilder.error("']' or ',' expected"); } } parseSliceListTail(exprStart, null); }
boolean typeExtends(IElementType child, IElementType parent) { if (child == parent) return true; if (extendsSets != null) { for (TokenSet set : extendsSets) { if (set.contains(child) && set.contains(parent)) return true; } } return altExtendsChecker != null && altExtendsChecker.process(child, parent); }
@Nullable private PsiBuilder.Marker parseUnary(final PsiBuilder builder) { final IElementType tokenType = builder.getTokenType(); if (PREFIX_OPS.contains(tokenType)) { final PsiBuilder.Marker unary = builder.mark(); builder.advanceLexer(); final PsiBuilder.Marker operand = parseUnary(builder); if (operand == null) { error(builder, JavaErrorMessages.message("expected.expression")); } unary.done(JavaElementType.PREFIX_EXPRESSION); return unary; } else if (tokenType == JavaTokenType.LPARENTH) { final PsiBuilder.Marker typeCast = builder.mark(); builder.advanceLexer(); ReferenceParser.TypeInfo typeInfo = myParser .getReferenceParser() .parseTypeInfo( builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.WILDCARD | ReferenceParser.CONJUNCTIONS | ReferenceParser.INCOMPLETE_ANNO); if (typeInfo == null || !expect(builder, JavaTokenType.RPARENTH)) { typeCast.rollbackTo(); return parsePostfix(builder); } if (PREF_ARITHMETIC_OPS.contains(builder.getTokenType()) && !typeInfo.isPrimitive) { typeCast.rollbackTo(); return parsePostfix(builder); } final PsiBuilder.Marker expr = parseUnary(builder); if (expr == null) { if (!typeInfo .isParameterized) { // cannot parse correct parenthesized expression after correct // parameterized type typeCast.rollbackTo(); return parsePostfix(builder); } else { error(builder, JavaErrorMessages.message("expected.expression")); } } typeCast.done(JavaElementType.TYPE_CAST_EXPRESSION); return typeCast; } else { return parsePostfix(builder); } }
static { keys1 = new HashMap<IElementType, TextAttributesKey>(); keys2 = new HashMap<IElementType, TextAttributesKey>(); fillMap(keys1, JetTokens.KEYWORDS, JetHighlightingColors.KEYWORD); keys1.put(JetTokens.AS_SAFE, JetHighlightingColors.KEYWORD); keys1.put(JetTokens.LABEL_IDENTIFIER, JetHighlightingColors.LABEL); keys1.put(JetTokens.INTEGER_LITERAL, JetHighlightingColors.NUMBER); keys1.put(JetTokens.FLOAT_LITERAL, JetHighlightingColors.NUMBER); fillMap( keys1, TokenSet.andNot( JetTokens.OPERATIONS, TokenSet.orSet( TokenSet.create(JetTokens.IDENTIFIER, JetTokens.LABEL_IDENTIFIER), JetTokens.KEYWORDS)), JetHighlightingColors.OPERATOR_SIGN); keys1.put(JetTokens.LPAR, JetHighlightingColors.PARENTHESIS); keys1.put(JetTokens.RPAR, JetHighlightingColors.PARENTHESIS); keys1.put(JetTokens.LBRACE, JetHighlightingColors.BRACES); keys1.put(JetTokens.RBRACE, JetHighlightingColors.BRACES); keys1.put(JetTokens.LBRACKET, JetHighlightingColors.BRACKETS); keys1.put(JetTokens.RBRACKET, JetHighlightingColors.BRACKETS); keys1.put(JetTokens.COMMA, JetHighlightingColors.COMMA); keys1.put(JetTokens.SEMICOLON, JetHighlightingColors.SEMICOLON); keys1.put(JetTokens.DOT, JetHighlightingColors.DOT); keys1.put(JetTokens.ARROW, JetHighlightingColors.ARROW); keys1.put(JetTokens.OPEN_QUOTE, JetHighlightingColors.STRING); keys1.put(JetTokens.CLOSING_QUOTE, JetHighlightingColors.STRING); keys1.put(JetTokens.REGULAR_STRING_PART, JetHighlightingColors.STRING); keys1.put(JetTokens.LONG_TEMPLATE_ENTRY_END, JetHighlightingColors.STRING_ESCAPE); keys1.put(JetTokens.LONG_TEMPLATE_ENTRY_START, JetHighlightingColors.STRING_ESCAPE); keys1.put(JetTokens.SHORT_TEMPLATE_ENTRY_START, JetHighlightingColors.STRING_ESCAPE); keys1.put(JetTokens.ESCAPE_SEQUENCE, JetHighlightingColors.STRING_ESCAPE); keys1.put(JetTokens.CHARACTER_LITERAL, JetHighlightingColors.STRING); keys1.put(JetTokens.EOL_COMMENT, JetHighlightingColors.LINE_COMMENT); keys1.put(JetTokens.SHEBANG_COMMENT, JetHighlightingColors.LINE_COMMENT); keys1.put(JetTokens.BLOCK_COMMENT, JetHighlightingColors.BLOCK_COMMENT); keys1.put(JetTokens.DOC_COMMENT, JetHighlightingColors.DOC_COMMENT); fillMap(keys1, KDocTokens.KDOC_HIGHLIGHT_TOKENS, JetHighlightingColors.DOC_COMMENT); keys1.put(KDocTokens.TAG_NAME, JetHighlightingColors.KDOC_TAG); keys2.put(KDocTokens.TAG_NAME, JetHighlightingColors.DOC_COMMENT); keys1.put(TokenType.BAD_CHARACTER, JetHighlightingColors.BAD_CHARACTER); }
public class PerlParserDefinition implements ParserDefinition { public static final TokenSet WHITE_SPACES = TokenSet.create(TokenType.WHITE_SPACE); public static final TokenSet COMMENT = TokenSet.create(PerlTypes.COMMENT); public static final TokenSet LITERAL = TokenSet.create(PerlTypes.LITERAL); public static final IFileElementType FILE = new IFileElementType(Language.<PerlLanguage>findInstance(PerlLanguage.class)); @NotNull @Override public Lexer createLexer(Project project) { return new FlexAdapter(new PerlLexer((Reader) null)); } @NotNull public TokenSet getWhitespaceTokens() { return WHITE_SPACES; } @NotNull public TokenSet getCommentTokens() { return COMMENT; } @NotNull public TokenSet getStringLiteralElements() { return LITERAL; } @NotNull public PsiParser createParser(final Project project) { return new PerlParser(); } @Override public IFileElementType getFileNodeType() { return FILE; } public PsiFile createFile(FileViewProvider viewProvider) { return new PerlFile(viewProvider); } public SpaceRequirements spaceExistanceTypeBetweenTokens(ASTNode left, ASTNode right) { return SpaceRequirements.MAY; } @NotNull public PsiElement createElement(ASTNode node) { return PerlTypes.Factory.createElement(node); } }
/** @author Stepan Koltsov */ public class RustTokenTypes { static IElementType WHITE_SPACE = TokenType.WHITE_SPACE; static IElementType BAD_CHARACTER = TokenType.BAD_CHARACTER; static IElementType NUMBER = new RustElementType("number"); static IElementType END_OF_LINE_COMMENT = new RustElementType("END_OF_LINE_COMMENT"); static IElementType KEY_CHARACTERS = new RustElementType("KEY_CHARACTERS"); static IElementType VALUE_CHARACTERS = new RustElementType("VALUE_CHARACTERS"); static IElementType KEY_VALUE_SEPARATOR = new RustElementType("KEY_VALUE_SEPARATOR"); static TokenSet COMMENTS = TokenSet.create(END_OF_LINE_COMMENT); static TokenSet WHITESPACES = TokenSet.create(WHITE_SPACE); }
/** * There is a possible case that given base node doesn't have {@link * AlignmentInColumnsConfig#getTargetDeclarationTypes() target type} but its first child node or * first child node of the first child node etc does. * * <p>This method tries to derive node of the target type from the given node. * * @param baseNode base node to process * @param targetTypes target node types * @return base node or its first descendant child that has {@link * AlignmentInColumnsConfig#getTargetDeclarationTypes() target type} target type if the one if * found; <code>null</code> otherwise */ @Nullable private static ASTNode deriveNodeOfTargetType(ASTNode baseNode, TokenSet targetTypes) { if (targetTypes.contains(baseNode.getElementType())) { return baseNode; } for (ASTNode node = baseNode; node != null; node = node.getFirstChildNode()) { IElementType nodeType = node.getElementType(); if (targetTypes.contains(nodeType)) { return node; } } return null; }
/* * for * : "for" "(" annotations ("val" | "var")? (multipleVariableDeclarations | variableDeclarationEntry) "in" expression ")" expression * ; * * TODO: empty loop body (at the end of the block)? */ private void parseFor() { assert _at(FOR_KEYWORD); PsiBuilder.Marker loop = mark(); advance(); // FOR_KEYWORD if (expect(LPAR, "Expecting '(' to open a loop range", EXPRESSION_FIRST)) { myBuilder.disableNewlines(); if (!at(RPAR)) { PsiBuilder.Marker parameter = mark(); if (!at(IN_KEYWORD)) { myJetParsing.parseModifierList(DEFAULT, TokenSet.create(IN_KEYWORD, RPAR, COLON)); } if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) advance(); // VAL_KEYWORD or VAR_KEYWORD if (at(LPAR)) { myJetParsing.parseMultiDeclarationName(TokenSet.create(IN_KEYWORD, LBRACE)); parameter.done(DESTRUCTURING_DECLARATION); } else { expect(IDENTIFIER, "Expecting a variable name", TokenSet.create(COLON, IN_KEYWORD)); if (at(COLON)) { advance(); // COLON myJetParsing.parseTypeRef(TokenSet.create(IN_KEYWORD)); } parameter.done(VALUE_PARAMETER); } if (expect(IN_KEYWORD, "Expecting 'in'", TokenSet.create(LPAR, LBRACE, RPAR))) { PsiBuilder.Marker range = mark(); parseExpression(); range.done(LOOP_RANGE); } } else { error("Expecting a variable name"); } expectNoAdvance(RPAR, "Expecting ')'"); myBuilder.restoreNewlinesState(); } parseControlStructureBody(); loop.done(FOR); }
private static boolean isLiteral(PsiElement element) { if (element == null) return false; final ASTNode astNode = element.getNode(); if (astNode == null) { return false; } final IElementType elementType = astNode.getElementType(); final ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(element.getLanguage()); if (parserDefinition != null) { final TokenSet literals = parserDefinition.getStringLiteralElements(); return literals.contains(elementType); } return false; }
/** @author ilyas */ public interface LuaDocTokenTypes { IElementType LDOC_TAG_NAME = new LuaDocElementTypeImpl("LDOC_TAG_NAME"); IElementType LDOC_TAG_PLAIN_VALUE_TOKEN = new LuaDocElementTypeImpl("LDOC_TAG_VALUE_TOKEN"); IElementType LDOC_TAG_VALUE = new LuaDocTagValueTokenType(); IElementType LDOC_COMMENT_START = new LuaDocElementTypeImpl("LDOC_COMMENT_START"); IElementType LDOC_COMMENT_DATA = new LuaDocElementTypeImpl("LDOC_COMMENT_DATA"); IElementType LDOC_WHITESPACE = new LuaDocElementTypeImpl("LDOC_WHITESPACE"); IElementType LDOC_DASHES = new LuaDocElementTypeImpl("LDOC_DASHES"); IElementType LDOC_COMMENT_BAD_CHARACTER = TokenType.BAD_CHARACTER; TokenSet LUA_DOC_TOKENS = TokenSet.create( LDOC_COMMENT_START, LDOC_COMMENT_DATA, LDOC_WHITESPACE, LDOC_DASHES, LDOC_TAG_NAME, LDOC_TAG_VALUE, LDOC_TAG_PLAIN_VALUE_TOKEN, LDOC_COMMENT_BAD_CHARACTER); }
@Nullable private static PsiBuilder.Marker parseBinary( final PsiBuilder builder, final ExprType type, final TokenSet ops) { PsiBuilder.Marker left = parseExpression(builder, type); if (left == null) return null; while (true) { final IElementType tokenType = getGtTokenType(builder); if (tokenType == null || !ops.contains(tokenType)) break; final PsiBuilder.Marker binary = left.precede(); advanceGtToken(builder, tokenType); final PsiBuilder.Marker right = parseExpression(builder, type); if (right == null) { error(builder, JavaErrorMessages.message("expected.expression")); binary.done(JavaElementType.BINARY_EXPRESSION); return binary; } binary.done(JavaElementType.BINARY_EXPRESSION); left = binary; } return left; }
static { // in regular case, these tokens should be created in extension class TOKENS_MAP.put("inner", RESERVED_INNER); TOKENS_MAP.put("with", RESERVED_WITH); TOKENS_MAP.put("extends", RESERVED_EXTENDS); TOKENS_MAP.put("meta", RESERVED_META); TOKENS_MAP.put("override", RESERVED_OVERRIDE); TOKENS_MAP.put("around", RESERVED_AROUND); TOKENS_MAP.put("super", RESERVED_SUPER); TOKENS_MAP.put("augment", RESERVED_AUGMENT); TOKENS_MAP.put("after", RESERVED_AFTER); TOKENS_MAP.put("before", RESERVED_BEFORE); TOKENS_MAP.put("has", RESERVED_HAS); RESERVED_TO_STATEMENT_MAP.put(RESERVED_INNER, MOOSE_STATEMENT_INNER); RESERVED_TO_STATEMENT_MAP.put(RESERVED_WITH, MOOSE_STATEMENT_WITH); RESERVED_TO_STATEMENT_MAP.put(RESERVED_EXTENDS, MOOSE_STATEMENT_EXTENDS); RESERVED_TO_STATEMENT_MAP.put(RESERVED_META, MOOSE_STATEMENT_META); RESERVED_TO_STATEMENT_MAP.put(RESERVED_OVERRIDE, MOOSE_STATEMENT_OVERRIDE); RESERVED_TO_STATEMENT_MAP.put(RESERVED_AROUND, MOOSE_STATEMENT_AROUND); RESERVED_TO_STATEMENT_MAP.put(RESERVED_SUPER, MOOSE_STATEMENT_SUPER); RESERVED_TO_STATEMENT_MAP.put(RESERVED_AUGMENT, MOOSE_STATEMENT_AUGMENT); RESERVED_TO_STATEMENT_MAP.put(RESERVED_AFTER, MOOSE_STATEMENT_AFTER); RESERVED_TO_STATEMENT_MAP.put(RESERVED_BEFORE, MOOSE_STATEMENT_BEFORE); RESERVED_TO_STATEMENT_MAP.put(RESERVED_HAS, MOOSE_STATEMENT_HAS); MOOSE_TOKEN_SET = TokenSet.create(TOKENS_MAP.values().toArray(new IElementType[TOKENS_MAP.values().size()])); }
@NotNull public Count getCount() { final ASTNode[] nodes = getNode().getChildren(RegExpTokens.QUANTIFIERS); assert nodes.length > 0; final IElementType type = nodes[0].getElementType(); if (type == RegExpTokens.QUEST) { return SimpleCount.ONE_OR_ZERO; } else if (type == RegExpTokens.STAR) { return SimpleCount.ZERO_OR_MORE; } else if (type == RegExpTokens.PLUS) { return SimpleCount.ONE_OR_MORE; } else if (type == RegExpTokens.LBRACE) { final ASTNode[] numbers = getNode().getChildren(TokenSet.create(RegExpTokens.NUMBER)); if (numbers.length >= 1) { final String min = numbers[0].getText(); final String max; if (numbers.length == 2) { max = numbers[1].getText(); } else if (getNode().findChildByType(RegExpTokens.COMMA) != null) { max = ""; } else { max = min; } return new RepeatedCount(min, max); } // syntactically incorrect return new RepeatedCount("", ""); } assert false; return null; }
class GoBinaryExpressionBlock extends GoBlock { public enum Mode { Normal, Compact } private static final TokenSet EMPTY_SPACE_TOKENS = TokenSet.create(oMUL, oQUOTIENT, oREMAINDER, oSHIFT_LEFT, oSHIFT_RIGHT); private final Spacing spacing; public GoBinaryExpressionBlock( ASTNode node, Alignment alignment, Wrap wrap, CommonCodeStyleSettings settings) { super(node, alignment, Indent.getNormalIndent(), wrap, settings); GoBinaryExpression psi = node.getPsi(GoBinaryExpression.class); if (psi != null && EMPTY_SPACE_TOKENS.contains(psi.getOperator())) { spacing = EMPTY_SPACING_KEEP_LINE_BREAKS; } else { spacing = BASIC_SPACING_KEEP_LINE_BREAKS; } } @Override protected Spacing getGoBlockSpacing(GoBlock child1, GoBlock child2) { return isCommentBlock(child1) || isCommentBlock(child2) ? BASIC_SPACING_KEEP_LINE_BREAKS : spacing; } @Override protected Indent getChildIndent(@Nullable PsiElement child) { return null; } }
/* * initializer * : attributes "this" valueArguments * : attributes constructorInvocation // type parameters may (must?) be omitted * ; */ private void parseInitializer() { PsiBuilder.Marker initializer = mark(); parseAnnotations(false); IElementType type; if (at(THIS_KEYWORD)) { PsiBuilder.Marker mark = mark(); advance(); // THIS_KEYWORD mark.done(THIS_CONSTRUCTOR_REFERENCE); type = THIS_CALL; } else if (atSet(TYPE_REF_FIRST)) { PsiBuilder.Marker reference = mark(); parseTypeRef(); reference.done(CONSTRUCTOR_CALLEE); type = DELEGATOR_SUPER_CALL; } else { errorWithRecovery( "Expecting constructor call (this(...)) or supertype initializer", TokenSet.create(LBRACE, COMMA)); initializer.drop(); return; } myExpressionParsing.parseValueArgumentList(); initializer.done(type); }
/* * whenEntry * // TODO : consider empty after -> * : whenCondition{","} "->" element SEMI * : "else" "->" element SEMI * ; */ private void parseWhenEntry() { PsiBuilder.Marker entry = mark(); if (at(ELSE_KEYWORD)) { advance(); // ELSE_KEYWORD if (!at(ARROW)) { errorUntil("Expecting '->'", TokenSet.create(ARROW, RBRACE, EOL_OR_SEMICOLON)); } if (at(ARROW)) { advance(); // ARROW if (atSet(WHEN_CONDITION_RECOVERY_SET)) { error("Expecting an element"); } else { parseExpressionPreferringBlocks(); } } else if (!atSet(WHEN_CONDITION_RECOVERY_SET)) { errorAndAdvance("Expecting '->'"); } } else { parseWhenEntryNotElse(); } entry.done(WHEN_ENTRY); consumeIf(SEMICOLON); }
private static ImmutableMap<String, JetToken> tokenSetToMap(TokenSet tokens) { ImmutableMap.Builder<String, JetToken> builder = ImmutableMap.builder(); for (IElementType token : tokens.getTypes()) { builder.put(token.toString(), (JetToken) token); } return builder.build(); }
/* * expressions * : SEMI* statement{SEMI+} SEMI* */ public void parseStatements() { while (at(SEMICOLON)) advance(); // SEMICOLON while (!eof() && !at(RBRACE)) { if (!atSet(STATEMENT_FIRST)) { errorAndAdvance("Expecting an element"); } if (atSet(STATEMENT_FIRST)) { parseStatement(); } if (at(SEMICOLON)) { while (at(SEMICOLON)) advance(); // SEMICOLON } else if (at(RBRACE)) { break; } else if (!myBuilder.newlineBeforeCurrentToken()) { String severalStatementsError = "Unexpected tokens (use ';' to separate expressions on the same line)"; if (atSet(STATEMENT_NEW_LINE_QUICK_RECOVERY_SET)) { error(severalStatementsError); } else { errorUntil(severalStatementsError, TokenSet.create(EOL_OR_SEMICOLON, LBRACE, RBRACE)); } } } }
/* * (SimpleName (":" type)){","} */ public void parseMultiDeclarationName(TokenSet follow) { // Parsing multi-name, e.g. // val (a, b) = foo() myBuilder.disableNewlines(); advance(); // LPAR TokenSet recoverySet = TokenSet.orSet(PARAMETER_NAME_RECOVERY_SET, follow); if (!atSet(follow)) { while (true) { if (at(COMMA)) { errorAndAdvance("Expecting a name"); } else if (at(RPAR)) { error("Expecting a name"); break; } PsiBuilder.Marker property = mark(); expect(IDENTIFIER, "Expecting a name", recoverySet); if (at(COLON)) { advance(); // COLON parseTypeRef(follow); } property.done(MULTI_VARIABLE_DECLARATION_ENTRY); if (!at(COMMA)) break; advance(); // COMMA } } expect(RPAR, "Expecting ')'", follow); myBuilder.restoreNewlinesState(); }
/** User: jansorg Date: 21.05.2009 Time: 10:36:06 */ public class BashWordImpl extends BashPsiElementImpl implements BashWord { private static final TokenSet nonWrappableChilds = TokenSet.create(BashElementTypes.STRING_ELEMENT, BashTokenTypes.STRING2, BashTokenTypes.WORD); public BashWordImpl(final ASTNode astNode) { super(astNode, "bash combined word"); } @Override public void accept(@NotNull PsiElementVisitor visitor) { if (visitor instanceof BashVisitor) { ((BashVisitor) visitor).visitCombinedWord(this); } else { visitor.visitElement(this); } } public boolean isWrappable() { return findChildByType(nonWrappableChilds) == null; } public String getUnwrappedCharSequence() { return getText(); } public boolean isStatic() { return BashPsiUtils.isStaticWordExpr(getFirstChild()); } }
private boolean parseSliceListTail( PsiBuilder.Marker exprStart, @Nullable PsiBuilder.Marker sliceOrTupleStart) { boolean inSlice = sliceOrTupleStart == null; while (atToken(PyTokenTypes.COMMA)) { nextToken(); PsiBuilder.Marker sliceItemStart = myBuilder.mark(); parseTestExpression(false, false); if (matchToken(PyTokenTypes.COLON)) { inSlice = true; parseTestExpression(false, false); if (matchToken(PyTokenTypes.COLON)) { parseTestExpression(false, false); } } sliceItemStart.done(PyElementTypes.SLICE_ITEM); if (!BRACKET_OR_COMMA.contains(myBuilder.getTokenType())) { myBuilder.error("']' or ',' expected"); break; } } checkMatches(PyTokenTypes.RBRACKET, message("PARSE.expected.rbracket")); if (inSlice) { if (sliceOrTupleStart != null) { sliceOrTupleStart.drop(); } exprStart.done(PyElementTypes.SLICE_EXPRESSION); } return inSlice; }