/* * propertyDelegate * : "by" expression * ; */ private void parsePropertyDelegate() { assert _at(BY_KEYWORD); PsiBuilder.Marker delegate = mark(); advance(); // BY_KEYWORD myExpressionParsing.parseExpression(); delegate.done(PROPERTY_DELEGATE); }
/* * 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); }
/* * functionParameterRest * : parameter ("=" element)? * ; */ private boolean parseFunctionParameterRest() { boolean noErrors = true; // Recovery for the case 'fun foo(Array<String>) {}' if (at(IDENTIFIER) && lookahead(1) == LT) { error("Parameter name expected"); parseTypeRef(); noErrors = false; } else { expect(IDENTIFIER, "Parameter name expected", PARAMETER_NAME_RECOVERY_SET); if (at(COLON)) { advance(); // COLON parseTypeRef(); } else { errorWithRecovery("Parameters must have type annotation", PARAMETER_NAME_RECOVERY_SET); noErrors = false; } } if (at(EQ)) { advance(); // EQ myExpressionParsing.parseExpression(); } return noErrors; }
void parseExpressionCodeFragment() { PsiBuilder.Marker marker = mark(); myExpressionParsing.parseExpression(); while (!eof()) { error("unexpected symbol"); advance(); } marker.done(EXPRESSION_CODE_FRAGMENT); }
/* * functionBody * : block * : "=" element * ; */ private void parseFunctionBody() { if (at(LBRACE)) { parseBlock(); } else if (at(EQ)) { advance(); // EQ myExpressionParsing.parseExpression(); consumeIf(SEMICOLON); } else { errorAndAdvance("Expecting function body"); } }
/* * block * : "{" (expressions)* "}" * ; */ void parseBlock() { PsiBuilder.Marker block = mark(); myBuilder.enableNewlines(); expect(LBRACE, "Expecting '{' to open a block"); myExpressionParsing.parseStatements(); expect(RBRACE, "Expecting '}"); myBuilder.restoreNewlinesState(); block.done(BLOCK); }
void parseScript() { PsiBuilder.Marker fileMarker = mark(); parsePreamble(false); PsiBuilder.Marker scriptMarker = mark(); parseImportDirectives(); PsiBuilder.Marker blockMarker = mark(); myExpressionParsing.parseStatements(); blockMarker.done(BLOCK); scriptMarker.done(SCRIPT); fileMarker.done(JET_FILE); }
/* * annotationEntry * : SimpleName{"."} typeArguments? valueArguments? * ; */ private void parseAnnotationEntry() { assert _at(IDENTIFIER); PsiBuilder.Marker attribute = mark(); PsiBuilder.Marker reference = mark(); PsiBuilder.Marker typeReference = mark(); parseUserType(); typeReference.done(TYPE_REFERENCE); reference.done(CONSTRUCTOR_CALLEE); parseTypeArgumentList(); if (at(LPAR)) { myExpressionParsing.parseValueArgumentList(); } attribute.done(ANNOTATION_ENTRY); }
/* * attributes delegationSpecifier * * delegationSpecifier * : constructorInvocation // type and constructor arguments * : userType * : explicitDelegation * ; * * explicitDelegation * : userType "by" element * ; */ private void parseDelegationSpecifier() { PsiBuilder.Marker delegator = mark(); parseAnnotations(false); PsiBuilder.Marker reference = mark(); parseTypeRef(); if (at(BY_KEYWORD)) { reference.drop(); advance(); // BY_KEYWORD createForByClause(myBuilder).myExpressionParsing.parseExpression(); delegator.done(DELEGATOR_BY); } else if (at(LPAR)) { reference.done(CONSTRUCTOR_CALLEE); myExpressionParsing.parseValueArgumentList(); delegator.done(DELEGATOR_SUPER_CALL); } else { reference.drop(); delegator.done(DELEGATOR_SUPER_CLASS); } }
public IElementType parseProperty(boolean local) { if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) { advance(); // VAL_KEYWORD or VAR_KEYWORD } else { errorAndAdvance("Expecting 'val' or 'var'"); } boolean typeParametersDeclared = at(LT) && parseTypeParameterList(TokenSet.create(IDENTIFIER, EQ, COLON, SEMICOLON)); TokenSet propertyNameFollow = TokenSet.create( COLON, EQ, LBRACE, RBRACE, SEMICOLON, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, CLASS_KEYWORD); myBuilder.disableJoiningComplexTokens(); // TODO: extract constant int lastDot = matchTokenStreamPredicate( new LastBefore( new AtSet(DOT, SAFE_ACCESS), new AbstractTokenStreamPredicate() { @Override public boolean matching(boolean topLevel) { if (topLevel && (at(EQ) || at(COLON))) return true; if (topLevel && at(IDENTIFIER)) { IElementType lookahead = lookahead(1); return lookahead != LT && lookahead != DOT && lookahead != SAFE_ACCESS && lookahead != QUEST; } return false; } })); PsiBuilder.Marker receiver = mark(); parseReceiverType("property", propertyNameFollow, lastDot); boolean multiDeclaration = at(LPAR); boolean receiverTypeDeclared = lastDot != -1; errorIf( receiver, multiDeclaration && receiverTypeDeclared, "Receiver type is not allowed on a multi-declaration"); if (multiDeclaration) { PsiBuilder.Marker multiDecl = mark(); parseMultiDeclarationName(propertyNameFollow); errorIf(multiDecl, !local, "Multi-declarations are only allowed for local variables/values"); } else { parseFunctionOrPropertyName(receiverTypeDeclared, "property", propertyNameFollow); } myBuilder.restoreJoiningComplexTokensState(); if (at(COLON)) { PsiBuilder.Marker type = mark(); advance(); // COLON if (!parseIdeTemplate()) { parseTypeRef(); } errorIf(type, multiDeclaration, "Type annotations are not allowed on multi-declarations"); } parseTypeConstraintsGuarded(typeParametersDeclared); if (local) { if (at(BY_KEYWORD)) { parsePropertyDelegate(); } else if (at(EQ)) { advance(); // EQ myExpressionParsing.parseExpression(); // "val a = 1; b" must not be an infix call of b on "val ...;" } } else { if (at(BY_KEYWORD)) { parsePropertyDelegate(); consumeIf(SEMICOLON); } else if (at(EQ)) { advance(); // EQ myExpressionParsing.parseExpression(); consumeIf(SEMICOLON); } if (parsePropertyGetterOrSetter()) { parsePropertyGetterOrSetter(); } if (!atSet(EOL_OR_SEMICOLON, RBRACE)) { if (getLastToken() != SEMICOLON) { errorUntil("Property getter or setter expected", TokenSet.create(EOL_OR_SEMICOLON)); } } else { consumeIf(SEMICOLON); } } return multiDeclaration ? MULTI_VARIABLE_DECLARATION : PROPERTY; }