001 /*
002 * Copyright 2010-2016 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.kotlin.parsing;
018
019 import com.intellij.lang.PsiBuilder;
020 import com.intellij.lang.WhitespacesBinders;
021 import com.intellij.openapi.diagnostic.Logger;
022 import com.intellij.psi.tree.IElementType;
023 import com.intellij.psi.tree.TokenSet;
024 import org.jetbrains.annotations.NotNull;
025 import org.jetbrains.annotations.Nullable;
026 import org.jetbrains.kotlin.lexer.KtKeywordToken;
027 import org.jetbrains.kotlin.lexer.KtTokens;
028
029 import java.util.HashMap;
030 import java.util.Map;
031
032 import static org.jetbrains.kotlin.KtNodeTypes.*;
033 import static org.jetbrains.kotlin.lexer.KtTokens.*;
034 import static org.jetbrains.kotlin.parsing.KotlinParsing.AnnotationParsingMode.*;
035
036 public class KotlinParsing extends AbstractKotlinParsing {
037 private static final Logger LOG = Logger.getInstance(KotlinParsing.class);
038
039 // TODO: token sets to constants, including derived methods
040 public static final Map<String, IElementType> MODIFIER_KEYWORD_MAP = new HashMap<String, IElementType>();
041 static {
042 for (IElementType softKeyword : MODIFIER_KEYWORDS.getTypes()) {
043 MODIFIER_KEYWORD_MAP.put(((KtKeywordToken) softKeyword).getValue(), softKeyword);
044 }
045 }
046
047 private static final TokenSet TOP_LEVEL_DECLARATION_FIRST = TokenSet.create(
048 TYPE_ALIAS_KEYWORD, INTERFACE_KEYWORD, CLASS_KEYWORD, OBJECT_KEYWORD,
049 FUN_KEYWORD, VAL_KEYWORD, PACKAGE_KEYWORD);
050 private static final TokenSet DECLARATION_FIRST = TokenSet.orSet(TOP_LEVEL_DECLARATION_FIRST,
051 TokenSet.create(INIT_KEYWORD, GET_KEYWORD, SET_KEYWORD, CONSTRUCTOR_KEYWORD));
052
053 private static final TokenSet CLASS_NAME_RECOVERY_SET = TokenSet.orSet(TokenSet.create(LT, LPAR, COLON, LBRACE),
054 TOP_LEVEL_DECLARATION_FIRST);
055 private static final TokenSet TYPE_PARAMETER_GT_RECOVERY_SET = TokenSet.create(WHERE_KEYWORD, LPAR, COLON, LBRACE, GT);
056 private static final TokenSet PARAMETER_NAME_RECOVERY_SET = TokenSet.create(COLON, EQ, COMMA, RPAR);
057 private static final TokenSet PACKAGE_NAME_RECOVERY_SET = TokenSet.create(DOT, EOL_OR_SEMICOLON);
058 private static final TokenSet IMPORT_RECOVERY_SET = TokenSet.create(AS_KEYWORD, DOT, EOL_OR_SEMICOLON);
059 /*package*/ static final TokenSet TYPE_REF_FIRST = TokenSet.create(LBRACKET, IDENTIFIER, LPAR, HASH, DYNAMIC_KEYWORD);
060 private static final TokenSet RECEIVER_TYPE_TERMINATORS = TokenSet.create(DOT, SAFE_ACCESS);
061 private static final TokenSet VALUE_PARAMETER_FIRST =
062 TokenSet.orSet(TokenSet.create(IDENTIFIER, LBRACKET, VAL_KEYWORD, VAR_KEYWORD), MODIFIER_KEYWORDS);
063 private static final TokenSet LAMBDA_VALUE_PARAMETER_FIRST =
064 TokenSet.orSet(TokenSet.create(IDENTIFIER, LBRACKET), MODIFIER_KEYWORDS);
065 private static final TokenSet SOFT_KEYWORDS_AT_MEMBER_START = TokenSet.create(CONSTRUCTOR_KEYWORD, INIT_KEYWORD);
066 private static final TokenSet ANNOTATION_TARGETS = TokenSet.create(
067 FILE_KEYWORD, FIELD_KEYWORD, GET_KEYWORD, SET_KEYWORD, PROPERTY_KEYWORD,
068 RECEIVER_KEYWORD, PARAM_KEYWORD, SETPARAM_KEYWORD, DELEGATE_KEYWORD);
069
070 static KotlinParsing createForTopLevel(SemanticWhitespaceAwarePsiBuilder builder) {
071 KotlinParsing jetParsing = new KotlinParsing(builder);
072 jetParsing.myExpressionParsing = new KotlinExpressionParsing(builder, jetParsing);
073 return jetParsing;
074 }
075
076 private static KotlinParsing createForByClause(SemanticWhitespaceAwarePsiBuilder builder) {
077 final SemanticWhitespaceAwarePsiBuilderForByClause builderForByClause = new SemanticWhitespaceAwarePsiBuilderForByClause(builder);
078 KotlinParsing jetParsing = new KotlinParsing(builderForByClause);
079 jetParsing.myExpressionParsing = new KotlinExpressionParsing(builderForByClause, jetParsing) {
080 @Override
081 protected boolean parseCallWithClosure() {
082 if (builderForByClause.getStackSize() > 0) {
083 return super.parseCallWithClosure();
084 }
085 return false;
086 }
087
088 @Override
089 protected KotlinParsing create(SemanticWhitespaceAwarePsiBuilder builder) {
090 return createForByClause(builder);
091 }
092 };
093 return jetParsing;
094 }
095
096 private KotlinExpressionParsing myExpressionParsing;
097
098 private KotlinParsing(SemanticWhitespaceAwarePsiBuilder builder) {
099 super(builder);
100 }
101
102 /*
103 * [start] jetlFile
104 * : preamble toplevelObject* [eof]
105 * ;
106 */
107 void parseFile() {
108 PsiBuilder.Marker fileMarker = mark();
109
110 parsePreamble();
111
112 while (!eof()) {
113 parseTopLevelDeclaration();
114 }
115
116 checkUnclosedBlockComment();
117 fileMarker.done(KT_FILE);
118 }
119
120 private void checkUnclosedBlockComment() {
121 if (TokenSet.create(BLOCK_COMMENT, DOC_COMMENT).contains(myBuilder.rawLookup(-1))) {
122 int startOffset = myBuilder.rawTokenTypeStart(-1);
123 int endOffset = myBuilder.rawTokenTypeStart(0);
124 CharSequence tokenChars = myBuilder.getOriginalText().subSequence(startOffset, endOffset);
125 if (!(tokenChars.length() > 2 && tokenChars.subSequence(tokenChars.length() - 2, tokenChars.length()).toString().equals("*/"))) {
126 PsiBuilder.Marker marker = myBuilder.mark();
127 marker.error("Unclosed comment");
128 marker.setCustomEdgeTokenBinders(WhitespacesBinders.GREEDY_RIGHT_BINDER, null);
129 }
130 }
131 }
132
133 void parseTypeCodeFragment() {
134 PsiBuilder.Marker marker = mark();
135 parseTypeRef();
136
137 checkForUnexpectedSymbols();
138
139 marker.done(TYPE_CODE_FRAGMENT);
140 }
141
142 void parseExpressionCodeFragment() {
143 PsiBuilder.Marker marker = mark();
144 myExpressionParsing.parseExpression();
145
146 checkForUnexpectedSymbols();
147
148 marker.done(EXPRESSION_CODE_FRAGMENT);
149 }
150
151 void parseBlockCodeFragment() {
152 PsiBuilder.Marker marker = mark();
153 PsiBuilder.Marker blockMarker = mark();
154
155 if (at(PACKAGE_KEYWORD) || at(IMPORT_KEYWORD)) {
156 PsiBuilder.Marker err = mark();
157 parsePreamble();
158 err.error("Package directive and imports are forbidden in code fragments");
159 }
160
161 myExpressionParsing.parseStatements();
162
163 checkForUnexpectedSymbols();
164
165 blockMarker.done(BLOCK);
166 marker.done(BLOCK_CODE_FRAGMENT);
167 }
168
169 void parseScript() {
170 PsiBuilder.Marker fileMarker = mark();
171
172 parsePreamble();
173
174 PsiBuilder.Marker scriptMarker = mark();
175
176 PsiBuilder.Marker blockMarker = mark();
177
178 myExpressionParsing.parseStatements(/*isScriptTopLevel = */true);
179
180 checkForUnexpectedSymbols();
181
182 blockMarker.done(BLOCK);
183 scriptMarker.done(SCRIPT);
184 fileMarker.done(KT_FILE);
185 }
186
187 private void checkForUnexpectedSymbols() {
188 while (!eof()) {
189 errorAndAdvance("Unexpected symbol");
190 }
191 }
192
193 /*
194 *preamble
195 * : fileAnnotationList? packageDirective? import*
196 * ;
197 */
198 private void parsePreamble() {
199 PsiBuilder.Marker firstEntry = mark();
200
201 /*
202 * fileAnnotationList
203 * : fileAnnotations*
204 */
205 parseFileAnnotationList(FILE_ANNOTATIONS_BEFORE_PACKAGE);
206
207 /*
208 * packageDirective
209 * : modifiers "package" SimpleName{"."} SEMI?
210 * ;
211 */
212 PsiBuilder.Marker packageDirective = mark();
213 parseModifierList(DEFAULT, TokenSet.EMPTY);
214
215 if (at(PACKAGE_KEYWORD)) {
216 advance(); // PACKAGE_KEYWORD
217
218 parsePackageName();
219
220 firstEntry.drop();
221
222 consumeIf(SEMICOLON);
223
224 packageDirective.done(PACKAGE_DIRECTIVE);
225 }
226 else {
227 // When package directive is omitted we should not report error on non-file annotations at the beginning of the file.
228 // So, we rollback the parsing position and reparse file annotation list without report error on non-file annotations.
229 firstEntry.rollbackTo();
230
231 parseFileAnnotationList(FILE_ANNOTATIONS_WHEN_PACKAGE_OMITTED);
232 packageDirective = mark();
233 packageDirective.done(PACKAGE_DIRECTIVE);
234 // this is necessary to allow comments at the start of the file to be bound to the first declaration
235 packageDirective.setCustomEdgeTokenBinders(DoNotBindAnything.INSTANCE, null);
236 }
237
238 parseImportDirectives();
239 }
240
241 /* SimpleName{"."} */
242 private void parsePackageName() {
243 PsiBuilder.Marker qualifiedExpression = mark();
244 boolean simpleName = true;
245 while (true) {
246 if (myBuilder.newlineBeforeCurrentToken()) {
247 errorWithRecovery("Package name must be a '.'-separated identifier list placed on a single line", PACKAGE_NAME_RECOVERY_SET);
248 break;
249 }
250
251 if (at(DOT)) {
252 advance(); // DOT
253 qualifiedExpression.error("Package name must be a '.'-separated identifier list");
254 qualifiedExpression = mark();
255 continue;
256 }
257
258 PsiBuilder.Marker nsName = mark();
259 boolean simpleNameFound = expect(IDENTIFIER, "Package name must be a '.'-separated identifier list", PACKAGE_NAME_RECOVERY_SET);
260 if (simpleNameFound) {
261 nsName.done(REFERENCE_EXPRESSION);
262 }
263 else {
264 nsName.drop();
265 }
266
267 if (!simpleName) {
268 PsiBuilder.Marker precedingMarker = qualifiedExpression.precede();
269 qualifiedExpression.done(DOT_QUALIFIED_EXPRESSION);
270 qualifiedExpression = precedingMarker;
271 }
272
273 if (at(DOT)) {
274 advance(); // DOT
275
276 if (simpleName && !simpleNameFound) {
277 qualifiedExpression.drop();
278 qualifiedExpression = mark();
279 }
280 else {
281 simpleName = false;
282 }
283 }
284 else {
285 break;
286 }
287 }
288 qualifiedExpression.drop();
289 }
290
291 /*
292 * import
293 * : "import" SimpleName{"."} ("." "*" | "as" SimpleName)? SEMI?
294 * ;
295 */
296 private void parseImportDirective() {
297 assert _at(IMPORT_KEYWORD);
298 PsiBuilder.Marker importDirective = mark();
299 advance(); // IMPORT_KEYWORD
300
301 if (closeImportWithErrorIfNewline(importDirective, "Expecting qualified name")) {
302 return;
303 }
304
305 if (!at(IDENTIFIER)) {
306 PsiBuilder.Marker error = mark();
307 skipUntil(TokenSet.create(EOL_OR_SEMICOLON));
308 error.error("Expecting qualified name");
309 importDirective.done(IMPORT_DIRECTIVE);
310 consumeIf(SEMICOLON);
311 return;
312 }
313
314 PsiBuilder.Marker qualifiedName = mark();
315 PsiBuilder.Marker reference = mark();
316 advance(); // IDENTIFIER
317 reference.done(REFERENCE_EXPRESSION);
318
319 while (at(DOT) && lookahead(1) != MUL) {
320 advance(); // DOT
321
322 if (closeImportWithErrorIfNewline(importDirective, "Import must be placed on a single line")) {
323 qualifiedName.drop();
324 return;
325 }
326
327 reference = mark();
328 if (expect(IDENTIFIER, "Qualified name must be a '.'-separated identifier list", IMPORT_RECOVERY_SET)) {
329 reference.done(REFERENCE_EXPRESSION);
330 }
331 else {
332 reference.drop();
333 }
334
335 PsiBuilder.Marker precede = qualifiedName.precede();
336 qualifiedName.done(DOT_QUALIFIED_EXPRESSION);
337 qualifiedName = precede;
338 }
339 qualifiedName.drop();
340
341 if (at(DOT)) {
342 advance(); // DOT
343 assert _at(MUL);
344 advance(); // MUL
345 if (at(AS_KEYWORD)) {
346 PsiBuilder.Marker as = mark();
347 advance(); // AS_KEYWORD
348 if (closeImportWithErrorIfNewline(importDirective, "Expecting identifier")) {
349 as.drop();
350 return;
351 }
352 consumeIf(IDENTIFIER);
353 as.error("Cannot rename all imported items to one identifier");
354 }
355 }
356 if (at(AS_KEYWORD)) {
357 advance(); // AS_KEYWORD
358 if (closeImportWithErrorIfNewline(importDirective, "Expecting identifier")) {
359 return;
360 }
361 expect(IDENTIFIER, "Expecting identifier", TokenSet.create(SEMICOLON));
362 }
363 consumeIf(SEMICOLON);
364 importDirective.done(IMPORT_DIRECTIVE);
365 importDirective.setCustomEdgeTokenBinders(null, TrailingCommentsBinder.INSTANCE);
366 }
367
368 private boolean closeImportWithErrorIfNewline(PsiBuilder.Marker importDirective, String errorMessage) {
369 if (myBuilder.newlineBeforeCurrentToken()) {
370 error(errorMessage);
371 importDirective.done(IMPORT_DIRECTIVE);
372 return true;
373 }
374 return false;
375 }
376
377 private void parseImportDirectives() {
378 PsiBuilder.Marker importList = mark();
379 if (!at(IMPORT_KEYWORD)) {
380 // this is necessary to allow comments at the start of the file to be bound to the first declaration
381 importList.setCustomEdgeTokenBinders(DoNotBindAnything.INSTANCE, null);
382 }
383 while (at(IMPORT_KEYWORD)) {
384 parseImportDirective();
385 }
386 importList.done(IMPORT_LIST);
387 }
388
389 /*
390 * toplevelObject
391 * : package
392 * : class
393 * : extension
394 * : function
395 * : property
396 * : typeAlias
397 * : object
398 * ;
399 */
400 private void parseTopLevelDeclaration() {
401 if (at(SEMICOLON)) {
402 advance(); // SEMICOLON
403 return;
404 }
405 PsiBuilder.Marker decl = mark();
406
407 ModifierDetector detector = new ModifierDetector();
408 parseModifierList(detector, DEFAULT, TokenSet.EMPTY);
409
410 IElementType keywordToken = tt();
411 IElementType declType = null;
412 // if (keywordToken == PACKAGE_KEYWORD) {
413 // declType = parsePackageBlock();
414 // }
415 // else
416 if (keywordToken == CLASS_KEYWORD || keywordToken == INTERFACE_KEYWORD) {
417 declType = parseClass(detector.isEnumDetected());
418 }
419 else if (keywordToken == FUN_KEYWORD) {
420 declType = parseFunction();
421 }
422 else if (keywordToken == VAL_KEYWORD || keywordToken == VAR_KEYWORD) {
423 declType = parseProperty();
424 }
425 /*
426 else if (keywordToken == TYPE_ALIAS_KEYWORD) {
427 declType = parseTypeAlias();
428 }
429 */
430 else if (keywordToken == OBJECT_KEYWORD) {
431 parseObject(NameParsingMode.REQUIRED, true);
432 declType = OBJECT_DECLARATION;
433 }
434 else if (at(LBRACE)) {
435 error("Expecting a top level declaration");
436 parseBlock();
437 declType = FUN;
438 }
439
440 if (declType == null) {
441 errorAndAdvance("Expecting a top level declaration");
442 decl.drop();
443 }
444 else {
445 closeDeclarationWithCommentBinders(decl, declType, true);
446 }
447 }
448
449 /*
450 * (modifier | annotation)*
451 */
452 boolean parseModifierList(
453 @NotNull AnnotationParsingMode annotationParsingMode,
454 @NotNull TokenSet noModifiersBefore
455 ) {
456 return parseModifierList(null, annotationParsingMode, noModifiersBefore);
457 }
458
459 /**
460 * (modifier | annotation)*
461 *
462 * Feeds modifiers (not annotations) into the passed consumer, if it is not null
463 */
464 boolean parseModifierList(
465 @Nullable Consumer<IElementType> tokenConsumer,
466 @NotNull AnnotationParsingMode annotationParsingMode,
467 @NotNull TokenSet noModifiersBefore
468 ) {
469 PsiBuilder.Marker list = mark();
470 boolean empty = true;
471 while (!eof()) {
472 if (at(AT) && annotationParsingMode.allowAnnotations) {
473 parseAnnotationOrList(annotationParsingMode);
474 }
475 else if (tryParseModifier(tokenConsumer, noModifiersBefore)) {
476 // modifier advanced
477 }
478 else if (annotationParsingMode.allowShortAnnotations && at(IDENTIFIER)) {
479 error("Use '@' symbol before annotations");
480 parseAnnotation(annotationParsingMode);
481 }
482 else {
483 break;
484 }
485 empty = false;
486 }
487 if (empty) {
488 list.drop();
489 }
490 else {
491 list.done(MODIFIER_LIST);
492 }
493 return !empty;
494 }
495
496 private boolean tryParseModifier(@Nullable Consumer<IElementType> tokenConsumer, @NotNull TokenSet noModifiersBefore) {
497 PsiBuilder.Marker marker = mark();
498
499 if (atSet(MODIFIER_KEYWORDS)) {
500 IElementType lookahead = lookahead(1);
501 if (lookahead != null && !noModifiersBefore.contains(lookahead)) {
502 IElementType tt = tt();
503 if (tokenConsumer != null) {
504 tokenConsumer.consume(tt);
505 }
506 advance(); // MODIFIER
507 marker.collapse(tt);
508 return true;
509 }
510 }
511
512 marker.rollbackTo();
513 return false;
514 }
515
516 /*
517 * fileAnnotationList
518 * : ("[" "file:" annotationEntry+ "]")*
519 * ;
520 */
521 private void parseFileAnnotationList(AnnotationParsingMode mode) {
522 if (!mode.isFileAnnotationParsingMode) {
523 LOG.error("expected file annotation parsing mode, but:" + mode);
524 }
525
526 PsiBuilder.Marker fileAnnotationsList = mark();
527
528 if (parseAnnotations(mode)) {
529 fileAnnotationsList.done(FILE_ANNOTATION_LIST);
530 }
531 else {
532 fileAnnotationsList.drop();
533 }
534 }
535
536 /*
537 * annotations
538 * : (annotation | annotationList)*
539 * ;
540 */
541 boolean parseAnnotations(AnnotationParsingMode mode) {
542 if (!parseAnnotationOrList(mode)) return false;
543
544 while (parseAnnotationOrList(mode)) {
545 // do nothing
546 }
547
548 return true;
549 }
550
551 /*
552 * annotation
553 * : "@" (annotationUseSiteTarget ":")? unescapedAnnotation
554 * ;
555 *
556 * annotationList
557 * : "@" (annotationUseSiteTarget ":")? "[" unescapedAnnotation+ "]"
558 * ;
559 *
560 * annotationUseSiteTarget
561 * : "file"
562 * : "field"
563 * : "property"
564 * : "get"
565 * : "set"
566 * : "param"
567 * : "setparam"
568 * ;
569 */
570 private boolean parseAnnotationOrList(AnnotationParsingMode mode) {
571 if (at(AT)) {
572 IElementType nextRawToken = myBuilder.rawLookup(1);
573 IElementType tokenToMatch = nextRawToken;
574 boolean isTargetedAnnotation = false;
575
576 if ((nextRawToken == IDENTIFIER || ANNOTATION_TARGETS.contains(nextRawToken)) && lookahead(2) == COLON) {
577 tokenToMatch = lookahead(3);
578 isTargetedAnnotation = true;
579 }
580 else if (lookahead(1) == COLON) {
581 // recovery for "@:ann"
582 isTargetedAnnotation = true;
583 tokenToMatch = lookahead(2);
584 }
585
586 if (tokenToMatch == IDENTIFIER) {
587 return parseAnnotation(mode);
588 }
589 else if (tokenToMatch == LBRACKET) {
590 return parseAnnotationList(mode);
591 }
592 else {
593 if (isTargetedAnnotation) {
594 if (lookahead(1) == COLON) {
595 errorAndAdvance("Expected annotation identifier after ':'", 2); // AT, COLON
596 }
597 else {
598 errorAndAdvance("Expected annotation identifier after ':'", 3); // AT, (ANNOTATION TARGET KEYWORD), COLON
599 }
600 }
601 else {
602 errorAndAdvance("Expected annotation identifier after '@'", 1); // AT
603 }
604 }
605 return true;
606 }
607
608 return false;
609 }
610
611 private boolean parseAnnotationList(AnnotationParsingMode mode) {
612 assert _at(AT);
613 PsiBuilder.Marker annotation = mark();
614
615 myBuilder.disableNewlines();
616
617 advance(); // AT
618
619 if (!parseAnnotationTargetIfNeeded(mode)) {
620 annotation.rollbackTo();
621 myBuilder.restoreNewlinesState();
622 return false;
623 }
624
625 assert _at(LBRACKET);
626 advance(); // LBRACKET
627
628 if (!at(IDENTIFIER) && !at(AT)) {
629 error("Expecting a list of annotations");
630 }
631 else {
632 while (at(IDENTIFIER) || at(AT)) {
633 if (at(AT)) {
634 errorAndAdvance("No '@' needed in annotation list"); // AT
635 continue;
636 }
637
638 parseAnnotation(IN_ANNOTATION_LIST);
639 while (at(COMMA)) {
640 errorAndAdvance("No commas needed to separate annotations");
641 }
642 }
643 }
644
645 expect(RBRACKET, "Expecting ']' to close the annotation list");
646 myBuilder.restoreNewlinesState();
647
648 annotation.done(ANNOTATION);
649 return true;
650 }
651
652 // Returns true if we should continue parse annotation
653 private boolean parseAnnotationTargetIfNeeded(AnnotationParsingMode mode) {
654 String expectedAnnotationTargetBeforeColon = "Expected annotation target before ':'";
655
656 if (at(COLON)) {
657 // recovery for "@:ann"
658 errorAndAdvance(expectedAnnotationTargetBeforeColon); // COLON
659 return true;
660 }
661
662 KtKeywordToken targetKeyword = atTargetKeyword();
663 if (mode == FILE_ANNOTATIONS_WHEN_PACKAGE_OMITTED && !(targetKeyword == FILE_KEYWORD && lookahead(1) == COLON)) {
664 return false;
665 }
666
667 if (lookahead(1) == COLON && targetKeyword == null && at(IDENTIFIER)) {
668 // recovery for "@fil:ann"
669 errorAndAdvance(expectedAnnotationTargetBeforeColon); // IDENTIFIER
670 advance(); // COLON
671 return true;
672 }
673
674 if (targetKeyword == null && mode.isFileAnnotationParsingMode) {
675 parseAnnotationTarget(mode, FILE_KEYWORD);
676 }
677 else if (targetKeyword != null) {
678 parseAnnotationTarget(mode, targetKeyword);
679 }
680
681 return true;
682 }
683
684 private void parseAnnotationTarget(AnnotationParsingMode mode, KtKeywordToken keyword) {
685 if (keyword == FILE_KEYWORD && !mode.isFileAnnotationParsingMode && at(keyword) && lookahead(1) == COLON) {
686 errorAndAdvance(AT.getValue() + keyword.getValue() + " annotations are only allowed before package declaration", 2);
687 return;
688 }
689
690 String message = "Expecting \"" + keyword.getValue() + COLON.getValue() + "\" prefix for " + keyword.getValue() + " annotations";
691
692 PsiBuilder.Marker marker = mark();
693
694 if (!expect(keyword, message)) {
695 marker.drop();
696 }
697 else {
698 marker.done(ANNOTATION_TARGET);
699 }
700
701 expect(COLON, message, TokenSet.create(IDENTIFIER, RBRACKET, LBRACKET));
702 }
703
704 @Nullable
705 private KtKeywordToken atTargetKeyword() {
706 for (IElementType target : ANNOTATION_TARGETS.getTypes()) {
707 if (at(target)) return (KtKeywordToken) target;
708 }
709 return null;
710 }
711
712 /*
713 * annotation
714 * : "@" (annotationUseSiteTarget ":")? unescapedAnnotation
715 * ;
716 *
717 * unescapedAnnotation
718 * : SimpleName{"."} typeArguments? valueArguments?
719 * ;
720 */
721 private boolean parseAnnotation(AnnotationParsingMode mode) {
722 assert _at(IDENTIFIER) ||
723 (_at(AT) && !WHITE_SPACE_OR_COMMENT_BIT_SET.contains(myBuilder.rawLookup(1)));
724
725 PsiBuilder.Marker annotation = mark();
726
727 boolean atAt = at(AT);
728 if (atAt) {
729 advance(); // AT
730 }
731
732 if (atAt && !parseAnnotationTargetIfNeeded(mode)) {
733 annotation.rollbackTo();
734 return false;
735 }
736
737 PsiBuilder.Marker reference = mark();
738 PsiBuilder.Marker typeReference = mark();
739 parseUserType();
740 typeReference.done(TYPE_REFERENCE);
741 reference.done(CONSTRUCTOR_CALLEE);
742
743 parseTypeArgumentList();
744
745 if (at(LPAR)) {
746 myExpressionParsing.parseValueArgumentList();
747 }
748 annotation.done(ANNOTATION_ENTRY);
749
750 return true;
751 }
752
753 public enum NameParsingMode {
754 REQUIRED,
755 ALLOWED,
756 PROHIBITED
757 }
758
759 public enum DeclarationParsingMode {
760 TOP_LEVEL,
761 CLASS_MEMBER,
762 LOCAL
763 }
764
765 /*
766 * class
767 * : modifiers ("class" | "interface") SimpleName
768 * typeParameters?
769 * primaryConstructor?
770 * (":" annotations delegationSpecifier{","})?
771 * typeConstraints
772 * (classBody? | enumClassBody)
773 * ;
774 *
775 * primaryConstructor
776 * : (modifiers "constructor")? ("(" functionParameter{","} ")")
777 * ;
778 *
779 * object
780 * : "object" SimpleName? primaryConstructor? ":" delegationSpecifier{","}? classBody?
781 * ;
782 */
783 IElementType parseClassOrObject(
784 boolean object,
785 NameParsingMode nameParsingMode,
786 boolean optionalBody,
787 boolean enumClass
788 ) {
789 if (object) {
790 assert _at(OBJECT_KEYWORD);
791 }
792 else {
793 assert _atSet(CLASS_KEYWORD, INTERFACE_KEYWORD);
794 }
795 advance(); // CLASS_KEYWORD, INTERFACE_KEYWORD or OBJECT_KEYWORD
796
797 if (nameParsingMode == NameParsingMode.REQUIRED) {
798 expect(IDENTIFIER, "Name expected", CLASS_NAME_RECOVERY_SET);
799 }
800 else {
801 assert object : "Must be an object to be nameless";
802 if (at(IDENTIFIER)) {
803 if (nameParsingMode == NameParsingMode.PROHIBITED) {
804 errorAndAdvance("An object expression cannot bind a name");
805 }
806 else {
807 assert nameParsingMode == NameParsingMode.ALLOWED;
808 advance();
809 }
810 }
811 }
812
813 OptionalMarker typeParamsMarker = new OptionalMarker(object);
814 boolean typeParametersDeclared = parseTypeParameterList(TYPE_PARAMETER_GT_RECOVERY_SET);
815 typeParamsMarker.error("Type parameters are not allowed for objects");
816
817 PsiBuilder.Marker beforeConstructorModifiers = mark();
818 PsiBuilder.Marker primaryConstructorMarker = mark();
819 boolean hasConstructorModifiers = parseModifierList(DEFAULT, TokenSet.EMPTY);
820
821 // Some modifiers found, but no parentheses following: class has already ended, and we are looking at something else
822 if (hasConstructorModifiers && !atSet(LPAR, LBRACE, COLON, CONSTRUCTOR_KEYWORD)) {
823 beforeConstructorModifiers.rollbackTo();
824 return object ? OBJECT_DECLARATION : CLASS;
825 }
826
827 // We are still inside a class declaration
828 beforeConstructorModifiers.drop();
829
830 boolean hasConstructorKeyword = at(CONSTRUCTOR_KEYWORD);
831 if (hasConstructorKeyword) {
832 advance(); // CONSTRUCTOR_KEYWORD
833 }
834
835 if (at(LPAR)) {
836 parseValueParameterList(false, /* typeRequired = */ true, TokenSet.create(LBRACE, RBRACE));
837 primaryConstructorMarker.done(PRIMARY_CONSTRUCTOR);
838 }
839 else if (hasConstructorModifiers || hasConstructorKeyword) {
840 // A comprehensive error message for cases like:
841 // class A private : Foo
842 // or
843 // class A private {
844 primaryConstructorMarker.done(PRIMARY_CONSTRUCTOR);
845 if (hasConstructorKeyword) {
846 error("Expecting primary constructor parameter list");
847 }
848 else {
849 error("Expecting 'constructor' keyword");
850 }
851 }
852 else {
853 primaryConstructorMarker.drop();
854 }
855
856 if (at(COLON)) {
857 advance(); // COLON
858 parseDelegationSpecifierList();
859 }
860
861 OptionalMarker whereMarker = new OptionalMarker(object);
862 parseTypeConstraintsGuarded(typeParametersDeclared);
863 whereMarker.error("Where clause is not allowed for objects");
864
865 if (at(LBRACE)) {
866 if (enumClass) {
867 parseEnumClassBody();
868 }
869 else {
870 parseClassBody();
871 }
872 }
873 else if (!optionalBody) {
874 PsiBuilder.Marker fakeBody = mark();
875 error("Expecting a class body");
876 fakeBody.done(CLASS_BODY);
877 }
878
879 return object ? OBJECT_DECLARATION : CLASS;
880 }
881
882 IElementType parseClass(boolean enumClass) {
883 return parseClassOrObject(false, NameParsingMode.REQUIRED, true, enumClass);
884 }
885
886 void parseObject(NameParsingMode nameParsingMode, boolean optionalBody) {
887 parseClassOrObject(true, nameParsingMode, optionalBody, false);
888 }
889
890 /*
891 * enumClassBody
892 * : "{" enumEntries (";" members)? "}"
893 * ;
894 */
895 private void parseEnumClassBody() {
896 if (!at(LBRACE)) return;
897
898 PsiBuilder.Marker body = mark();
899 myBuilder.enableNewlines();
900
901 advance(); // LBRACE
902
903 if (!parseEnumEntries() && !at(RBRACE)) {
904 error("Expecting ';' after the last enum entry or '}' to close enum class body");
905 }
906 parseMembers();
907 expect(RBRACE, "Expecting '}' to close enum class body");
908
909 myBuilder.restoreNewlinesState();
910 body.done(CLASS_BODY);
911 }
912
913 /**
914 * enumEntries
915 * : enumEntry{","}?
916 * ;
917 *
918 * @return true if enum regular members can follow, false otherwise
919 */
920 private boolean parseEnumEntries() {
921 while (!eof() && !at(RBRACE)) {
922 switch (parseEnumEntry()) {
923 case FAILED:
924 // Special case without any enum entries but with possible members after semicolon
925 if (at(SEMICOLON)) {
926 advance();
927 return true;
928 }
929 else {
930 return false;
931 }
932 case NO_DELIMITER:
933 return false;
934 case COMMA_DELIMITER:
935 break;
936 case SEMICOLON_DELIMITER:
937 return true;
938 }
939 }
940 return false;
941 }
942
943 private enum ParseEnumEntryResult {
944 FAILED,
945 NO_DELIMITER,
946 COMMA_DELIMITER,
947 SEMICOLON_DELIMITER
948 }
949
950 /*
951 * enumEntry
952 * : modifiers SimpleName ("(" arguments ")")? classBody?
953 * ;
954 */
955 private ParseEnumEntryResult parseEnumEntry() {
956 PsiBuilder.Marker entry = mark();
957
958 parseModifierList(DEFAULT, TokenSet.create(COMMA, SEMICOLON, RBRACE));
959
960 if (!atSet(SOFT_KEYWORDS_AT_MEMBER_START) && at(IDENTIFIER)) {
961 advance(); // IDENTIFIER
962
963 if (at(LPAR)) {
964 // Arguments should be parsed here
965 // Also, "fake" constructor call tree is created,
966 // with empty type name inside
967 PsiBuilder.Marker initializerList = mark();
968 PsiBuilder.Marker delegatorSuperCall = mark();
969
970 PsiBuilder.Marker callee = mark();
971 PsiBuilder.Marker typeReference = mark();
972 PsiBuilder.Marker type = mark();
973 PsiBuilder.Marker referenceExpr = mark();
974 referenceExpr.done(ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION);
975 type.done(USER_TYPE);
976 typeReference.done(TYPE_REFERENCE);
977 callee.done(CONSTRUCTOR_CALLEE);
978
979 myExpressionParsing.parseValueArgumentList();
980 delegatorSuperCall.done(SUPER_TYPE_CALL_ENTRY);
981 initializerList.done(INITIALIZER_LIST);
982 }
983 if (at(LBRACE)) {
984 parseClassBody();
985 }
986 boolean commaFound = at(COMMA);
987 if (commaFound) {
988 advance();
989 }
990 boolean semicolonFound = at(SEMICOLON);
991 if (semicolonFound) {
992 advance();
993 }
994
995 // Probably some helper function
996 closeDeclarationWithCommentBinders(entry, ENUM_ENTRY, true);
997 return semicolonFound
998 ? ParseEnumEntryResult.SEMICOLON_DELIMITER
999 : (commaFound ? ParseEnumEntryResult.COMMA_DELIMITER : ParseEnumEntryResult.NO_DELIMITER);
1000 }
1001 else {
1002 entry.rollbackTo();
1003 return ParseEnumEntryResult.FAILED;
1004 }
1005 }
1006
1007 /*
1008 * classBody
1009 * : ("{" members "}")?
1010 * ;
1011 */
1012 private void parseClassBody() {
1013 PsiBuilder.Marker body = mark();
1014
1015 myBuilder.enableNewlines();
1016
1017 if (expect(LBRACE, "Expecting a class body")) {
1018 parseMembers();
1019 expect(RBRACE, "Missing '}");
1020 }
1021
1022 myBuilder.restoreNewlinesState();
1023
1024 body.done(CLASS_BODY);
1025 }
1026
1027 /**
1028 * members
1029 * : memberDeclaration*
1030 * ;
1031 */
1032 private void parseMembers() {
1033 while (!eof() && !at(RBRACE)) {
1034 parseMemberDeclaration();
1035 }
1036 }
1037
1038 /*
1039 * memberDeclaration
1040 * : modifiers memberDeclaration'
1041 * ;
1042 *
1043 * memberDeclaration'
1044 * : companionObject
1045 * : secondaryConstructor
1046 * : function
1047 * : property
1048 * : class
1049 * : extension
1050 * : typeAlias
1051 * : anonymousInitializer
1052 * : object
1053 * ;
1054 */
1055 private void parseMemberDeclaration() {
1056 if (at(SEMICOLON)) {
1057 advance(); // SEMICOLON
1058 return;
1059 }
1060 PsiBuilder.Marker decl = mark();
1061
1062 ModifierDetector detector = new ModifierDetector();
1063 parseModifierList(detector, DEFAULT, TokenSet.EMPTY);
1064
1065 IElementType declType = parseMemberDeclarationRest(detector.isEnumDetected(), detector.isDefaultDetected());
1066
1067 if (declType == null) {
1068 errorWithRecovery("Expecting member declaration", TokenSet.EMPTY);
1069 decl.drop();
1070 }
1071 else {
1072 closeDeclarationWithCommentBinders(decl, declType, true);
1073 }
1074 }
1075
1076 private IElementType parseMemberDeclarationRest(boolean isEnum, boolean isDefault) {
1077 IElementType keywordToken = tt();
1078 IElementType declType = null;
1079 if (keywordToken == CLASS_KEYWORD || keywordToken == INTERFACE_KEYWORD) {
1080 declType = parseClass(isEnum);
1081 }
1082 else if (keywordToken == FUN_KEYWORD) {
1083 declType = parseFunction();
1084 }
1085 else if (keywordToken == VAL_KEYWORD || keywordToken == VAR_KEYWORD) {
1086 declType = parseProperty();
1087 }
1088 /*
1089 else if (keywordToken == TYPE_ALIAS_KEYWORD) {
1090 declType = parseTypeAlias();
1091 }
1092 */
1093 else if (keywordToken == OBJECT_KEYWORD) {
1094 parseObject(isDefault ? NameParsingMode.ALLOWED : NameParsingMode.REQUIRED, true);
1095 declType = OBJECT_DECLARATION;
1096 }
1097 else if (at(INIT_KEYWORD)) {
1098 advance(); // init
1099 if (at(LBRACE)) {
1100 parseBlock();
1101 }
1102 else {
1103 mark().error("Expecting '{' after 'init'");
1104 }
1105 declType = CLASS_INITIALIZER;
1106 }
1107 else if (at(CONSTRUCTOR_KEYWORD)) {
1108 parseSecondaryConstructor();
1109 declType = SECONDARY_CONSTRUCTOR;
1110 }
1111 else if (at(LBRACE)) {
1112 error("Expecting member declaration");
1113 parseBlock();
1114 declType = FUN;
1115 }
1116 return declType;
1117 }
1118
1119 /*
1120 * secondaryConstructor
1121 * : modifiers "constructor" valueParameters (":" constructorDelegationCall)? block
1122 * constructorDelegationCall
1123 * : "this" valueArguments
1124 * : "super" valueArguments
1125 */
1126 private void parseSecondaryConstructor() {
1127 assert _at(CONSTRUCTOR_KEYWORD);
1128
1129 advance(); // CONSTRUCTOR_KEYWORD
1130
1131 TokenSet valueArgsRecoverySet = TokenSet.create(LBRACE, SEMICOLON, RPAR, EOL_OR_SEMICOLON, RBRACE);
1132 if (at(LPAR)) {
1133 parseValueParameterList(false, /*typeRequired = */ true, valueArgsRecoverySet);
1134 }
1135 else {
1136 errorWithRecovery("Expecting '('", TokenSet.orSet(valueArgsRecoverySet, TokenSet.create(COLON)));
1137 }
1138
1139 if (at(COLON)) {
1140 advance(); // COLON
1141
1142 PsiBuilder.Marker delegationCall = mark();
1143
1144 if (at(THIS_KEYWORD) || at(SUPER_KEYWORD)) {
1145 parseThisOrSuper();
1146 myExpressionParsing.parseValueArgumentList();
1147 }
1148 else {
1149 error("Expecting a 'this' or 'super' constructor call");
1150 PsiBuilder.Marker beforeWrongDelegationCallee = null;
1151 if (!at(LPAR)) {
1152 beforeWrongDelegationCallee = mark();
1153 advance(); // wrong delegation callee
1154 }
1155 myExpressionParsing.parseValueArgumentList();
1156
1157 if (beforeWrongDelegationCallee != null) {
1158 if (at(LBRACE)) {
1159 beforeWrongDelegationCallee.drop();
1160 }
1161 else {
1162 beforeWrongDelegationCallee.rollbackTo();
1163 }
1164 }
1165 }
1166
1167 delegationCall.done(CONSTRUCTOR_DELEGATION_CALL);
1168 }
1169 else {
1170 // empty constructor delegation call
1171 PsiBuilder.Marker emptyDelegationCall = mark();
1172 mark().done(CONSTRUCTOR_DELEGATION_REFERENCE);
1173 emptyDelegationCall.done(CONSTRUCTOR_DELEGATION_CALL);
1174 }
1175
1176 if (at(LBRACE)) {
1177 parseBlock();
1178 }
1179 }
1180
1181 private void parseThisOrSuper() {
1182 assert _at(THIS_KEYWORD) || _at(SUPER_KEYWORD);
1183 PsiBuilder.Marker mark = mark();
1184
1185 advance(); // THIS_KEYWORD | SUPER_KEYWORD
1186
1187 mark.done(CONSTRUCTOR_DELEGATION_REFERENCE);
1188 }
1189
1190 /*
1191 * typeAlias
1192 * : modifiers "typealias" SimpleName (typeParameters typeConstraints)? "=" type
1193 * ;
1194 */
1195 /*
1196 KtNodeType parseTypeAlias() {
1197 assert _at(TYPE_ALIAS_KEYWORD);
1198
1199 advance(); // TYPE_ALIAS_KEYWORD
1200
1201 expect(IDENTIFIER, "Type name expected", TokenSet.orSet(TokenSet.create(LT, EQ, SEMICOLON), TOP_LEVEL_DECLARATION_FIRST));
1202
1203 if (parseTypeParameterList(TYPE_PARAMETER_GT_RECOVERY_SET)) {
1204 parseTypeConstraints();
1205 }
1206
1207 expect(EQ, "Expecting '='", TokenSet.orSet(TOP_LEVEL_DECLARATION_FIRST, TokenSet.create(SEMICOLON)));
1208
1209 parseTypeRef();
1210
1211 consumeIf(SEMICOLON);
1212
1213 return TYPEDEF;
1214 }
1215 */
1216
1217 /*
1218 * variableDeclarationEntry
1219 * : SimpleName (":" type)?
1220 * ;
1221 *
1222 * property
1223 * : modifiers ("val" | "var")
1224 * typeParameters? (type "." | annotations)?
1225 * ("(" variableDeclarationEntry{","} ")" | variableDeclarationEntry)
1226 * typeConstraints
1227 * ("by" | "=" expression SEMI?)?
1228 * (getter? setter? | setter? getter?) SEMI?
1229 * ;
1230 */
1231 private IElementType parseProperty() {
1232 return parseProperty(false);
1233 }
1234
1235 public IElementType parseProperty(boolean local) {
1236 assert (at(VAL_KEYWORD) || at(VAR_KEYWORD));
1237 advance();
1238
1239 boolean typeParametersDeclared = at(LT) && parseTypeParameterList(TokenSet.create(IDENTIFIER, EQ, COLON, SEMICOLON));
1240
1241 TokenSet propertyNameFollow = TokenSet.create(COLON, EQ, LBRACE, RBRACE, SEMICOLON, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, CLASS_KEYWORD);
1242
1243 myBuilder.disableJoiningComplexTokens();
1244
1245 PsiBuilder.Marker receiver = mark();
1246 boolean receiverTypeDeclared = parseReceiverType("property", propertyNameFollow);
1247
1248 boolean multiDeclaration = at(LPAR);
1249
1250 errorIf(receiver, multiDeclaration && receiverTypeDeclared, "Receiver type is not allowed on a destructuring declaration");
1251
1252 if (multiDeclaration) {
1253 PsiBuilder.Marker multiDecl = mark();
1254 parseMultiDeclarationName(propertyNameFollow);
1255 errorIf(multiDecl, !local, "Destructuring declarations are only allowed for local variables/values");
1256 }
1257 else {
1258 parseFunctionOrPropertyName(receiverTypeDeclared, "property", propertyNameFollow, /*nameRequired = */ false);
1259 }
1260
1261 myBuilder.restoreJoiningComplexTokensState();
1262
1263 if (at(COLON)) {
1264 PsiBuilder.Marker type = mark();
1265 advance(); // COLON
1266 parseTypeRef();
1267 errorIf(type, multiDeclaration, "Type annotations are not allowed on destructuring declarations");
1268 }
1269
1270 parseTypeConstraintsGuarded(typeParametersDeclared);
1271
1272 if (local) {
1273 if (at(BY_KEYWORD)) {
1274 parsePropertyDelegate();
1275 }
1276 else if (at(EQ)) {
1277 advance(); // EQ
1278 myExpressionParsing.parseExpression();
1279 // "val a = 1; b" must not be an infix call of b on "val ...;"
1280 }
1281 }
1282 else {
1283 if (at(BY_KEYWORD)) {
1284 parsePropertyDelegate();
1285 consumeIf(SEMICOLON);
1286 }
1287 else if (at(EQ)) {
1288 advance(); // EQ
1289 myExpressionParsing.parseExpression();
1290 consumeIf(SEMICOLON);
1291 }
1292
1293 AccessorKind accessorKind = parsePropertyGetterOrSetter(null);
1294 if (accessorKind != null) {
1295 parsePropertyGetterOrSetter(accessorKind);
1296 }
1297
1298 if (!atSet(EOL_OR_SEMICOLON, RBRACE)) {
1299 if (getLastToken() != SEMICOLON) {
1300 errorUntil("Property getter or setter expected", TokenSet.create(EOL_OR_SEMICOLON, LBRACE, RBRACE));
1301 }
1302 }
1303 else {
1304 consumeIf(SEMICOLON);
1305 }
1306 }
1307
1308 return multiDeclaration ? DESTRUCTURING_DECLARATION : PROPERTY;
1309 }
1310
1311 /*
1312 * propertyDelegate
1313 * : "by" expression
1314 * ;
1315 */
1316 private void parsePropertyDelegate() {
1317 assert _at(BY_KEYWORD);
1318 PsiBuilder.Marker delegate = mark();
1319 advance(); // BY_KEYWORD
1320 myExpressionParsing.parseExpression();
1321 delegate.done(PROPERTY_DELEGATE);
1322 }
1323
1324 /*
1325 * (SimpleName (":" type)){","}
1326 */
1327 public void parseMultiDeclarationName(TokenSet follow) {
1328 // Parsing multi-name, e.g.
1329 // val (a, b) = foo()
1330 myBuilder.disableNewlines();
1331 advance(); // LPAR
1332
1333 TokenSet recoverySet = TokenSet.orSet(PARAMETER_NAME_RECOVERY_SET, follow);
1334 if (!atSet(follow)) {
1335 while (true) {
1336 if (at(COMMA)) {
1337 errorAndAdvance("Expecting a name");
1338 }
1339 else if (at(RPAR)) {
1340 error("Expecting a name");
1341 break;
1342 }
1343 PsiBuilder.Marker property = mark();
1344
1345 parseModifierList(DEFAULT, TokenSet.create(COMMA, RPAR, COLON, EQ));
1346
1347 expect(IDENTIFIER, "Expecting a name", recoverySet);
1348
1349 if (at(COLON)) {
1350 advance(); // COLON
1351 parseTypeRef(follow);
1352 }
1353 property.done(DESTRUCTURING_DECLARATION_ENTRY);
1354
1355 if (!at(COMMA)) break;
1356 advance(); // COMMA
1357 }
1358 }
1359
1360 expect(RPAR, "Expecting ')'", follow);
1361 myBuilder.restoreNewlinesState();
1362 }
1363
1364 private enum AccessorKind { GET, SET}
1365
1366 /*
1367 * getterOrSetter
1368 * : modifiers ("get" | "set")
1369 * :
1370 * ( "get" "(" ")"
1371 * |
1372 * "set" "(" modifiers parameter ")"
1373 * ) functionBody
1374 * ;
1375 */
1376 @Nullable
1377 private AccessorKind parsePropertyGetterOrSetter(@Nullable AccessorKind notAllowedKind) {
1378 PsiBuilder.Marker getterOrSetter = mark();
1379
1380 parseModifierList(DEFAULT, TokenSet.EMPTY);
1381
1382 AccessorKind accessorKind;
1383 if (at(GET_KEYWORD)) {
1384 accessorKind = AccessorKind.GET;
1385 }
1386 else if (at(SET_KEYWORD)) {
1387 accessorKind = AccessorKind.SET;
1388 }
1389 else {
1390 getterOrSetter.rollbackTo();
1391 return null;
1392 }
1393
1394 if (accessorKind == notAllowedKind) {
1395 getterOrSetter.rollbackTo();
1396 return null;
1397 }
1398
1399 advance(); // GET_KEYWORD or SET_KEYWORD
1400
1401 if (!at(LPAR)) {
1402 // Account for Jet-114 (val a : int get {...})
1403 TokenSet ACCESSOR_FIRST_OR_PROPERTY_END = TokenSet.orSet(MODIFIER_KEYWORDS, TokenSet.create(AT, GET_KEYWORD, SET_KEYWORD, EOL_OR_SEMICOLON, RBRACE));
1404 if (!atSet(ACCESSOR_FIRST_OR_PROPERTY_END)) {
1405 errorUntil("Accessor body expected", TokenSet.orSet(ACCESSOR_FIRST_OR_PROPERTY_END, TokenSet.create(LBRACE, LPAR, EQ)));
1406 }
1407 else {
1408 closeDeclarationWithCommentBinders(getterOrSetter, PROPERTY_ACCESSOR, false);
1409 return accessorKind;
1410 }
1411 }
1412
1413 myBuilder.disableNewlines();
1414 expect(LPAR, "Expecting '('", TokenSet.create(RPAR, IDENTIFIER, COLON, LBRACE, EQ));
1415 if (accessorKind == AccessorKind.SET) {
1416 PsiBuilder.Marker parameterList = mark();
1417 PsiBuilder.Marker setterParameter = mark();
1418 parseModifierList(DEFAULT, TokenSet.create(COMMA, COLON, RPAR));
1419 expect(IDENTIFIER, "Expecting parameter name", TokenSet.create(RPAR, COLON, LBRACE, EQ));
1420
1421 if (at(COLON)) {
1422 advance(); // COLON
1423 parseTypeRef();
1424 }
1425 setterParameter.done(VALUE_PARAMETER);
1426 parameterList.done(VALUE_PARAMETER_LIST);
1427 }
1428 if (!at(RPAR)) {
1429 errorUntil("Expecting ')'", TokenSet.create(RPAR, COLON, LBRACE, RBRACE, EQ, EOL_OR_SEMICOLON));
1430 }
1431 if (at(RPAR)) {
1432 advance();
1433 }
1434 myBuilder.restoreNewlinesState();
1435
1436 if (at(COLON)) {
1437 advance();
1438
1439 parseTypeRef();
1440 }
1441
1442 parseFunctionBody();
1443
1444 closeDeclarationWithCommentBinders(getterOrSetter, PROPERTY_ACCESSOR, false);
1445
1446 return accessorKind;
1447 }
1448
1449 /*
1450 * function
1451 * : modifiers "fun" typeParameters?
1452 * (type "." | annotations)?
1453 * SimpleName
1454 * typeParameters? functionParameters (":" type)?
1455 * typeConstraints
1456 * functionBody?
1457 * ;
1458 */
1459 IElementType parseFunction() {
1460 assert _at(FUN_KEYWORD);
1461
1462 advance(); // FUN_KEYWORD
1463
1464 // Recovery for the case of class A { fun| }
1465 if (at(RBRACE)) {
1466 error("Function body expected");
1467 return FUN;
1468 }
1469
1470 boolean typeParameterListOccurred = false;
1471 if (at(LT)) {
1472 parseTypeParameterList(TokenSet.create(LBRACKET, LBRACE, RBRACE, LPAR));
1473 typeParameterListOccurred = true;
1474 }
1475
1476 myBuilder.disableJoiningComplexTokens();
1477
1478 TokenSet functionNameFollow = TokenSet.create(LT, LPAR, RPAR, COLON, EQ);
1479 boolean receiverFound = parseReceiverType("function", functionNameFollow);
1480
1481 // function as expression has no name
1482 parseFunctionOrPropertyName(receiverFound, "function", functionNameFollow, /*nameRequired = */ true);
1483
1484 myBuilder.restoreJoiningComplexTokensState();
1485
1486 TokenSet valueParametersFollow = TokenSet.create(EQ, LBRACE, RBRACE, SEMICOLON, RPAR);
1487
1488 if (at(LT)) {
1489 PsiBuilder.Marker error = mark();
1490 parseTypeParameterList(TokenSet.orSet(TokenSet.create(LPAR), valueParametersFollow));
1491 if (typeParameterListOccurred) {
1492 int offset = myBuilder.getCurrentOffset();
1493 error.rollbackTo();
1494 error = mark();
1495 advance(offset - myBuilder.getCurrentOffset());
1496 error.error("Only one type parameter list is allowed for a function");
1497 }
1498 else {
1499 error.drop();
1500 }
1501 typeParameterListOccurred = true;
1502 }
1503
1504 if (at(LPAR)) {
1505 parseValueParameterList(false, /* typeRequired = */ false, valueParametersFollow);
1506 }
1507 else {
1508 error("Expecting '('");
1509 }
1510
1511 if (at(COLON)) {
1512 advance(); // COLON
1513
1514 parseTypeRef();
1515 }
1516
1517 parseTypeConstraintsGuarded(typeParameterListOccurred);
1518
1519 if (at(SEMICOLON)) {
1520 advance(); // SEMICOLON
1521 }
1522 else if (at(EQ) || at(LBRACE)) {
1523 parseFunctionBody();
1524 }
1525
1526 return FUN;
1527 }
1528
1529 /*
1530 * (type "." | annotations)?
1531 */
1532 private boolean parseReceiverType(String title, TokenSet nameFollow) {
1533 PsiBuilder.Marker annotations = mark();
1534 boolean annotationsPresent = parseAnnotations(DEFAULT);
1535 int lastDot = lastDotAfterReceiver();
1536 boolean receiverPresent = lastDot != -1;
1537 if (annotationsPresent) {
1538 if (receiverPresent) {
1539 annotations.rollbackTo();
1540 }
1541 else {
1542 annotations.error("Annotations are not allowed in this position");
1543 }
1544 }
1545 else {
1546 annotations.drop();
1547 }
1548
1549 if (!receiverPresent) return false;
1550
1551 createTruncatedBuilder(lastDot).parseTypeRef();
1552
1553 if (atSet(RECEIVER_TYPE_TERMINATORS)) {
1554 advance(); // expectation
1555 }
1556 else {
1557 errorWithRecovery("Expecting '.' before a " + title + " name", nameFollow);
1558 }
1559 return true;
1560 }
1561
1562 private int lastDotAfterReceiver() {
1563 if (at(LPAR)) {
1564 return matchTokenStreamPredicate(
1565 new FirstBefore(
1566 new AtSet(RECEIVER_TYPE_TERMINATORS),
1567 new AbstractTokenStreamPredicate() {
1568 @Override
1569 public boolean matching(boolean topLevel) {
1570 if (topLevel && definitelyOutOfReceiver()) {
1571 return true;
1572 }
1573 return topLevel && !at(QUEST) && !at(LPAR) && !at(RPAR);
1574 }
1575 }
1576 ));
1577 }
1578 else {
1579 return matchTokenStreamPredicate(
1580 new LastBefore(
1581 new AtSet(RECEIVER_TYPE_TERMINATORS),
1582 new AbstractTokenStreamPredicate() {
1583 @Override
1584 public boolean matching(boolean topLevel) {
1585 if (topLevel && (definitelyOutOfReceiver() || at(LPAR))) return true;
1586 if (topLevel && at(IDENTIFIER)) {
1587 IElementType lookahead = lookahead(1);
1588 return lookahead != LT && lookahead != DOT && lookahead != SAFE_ACCESS && lookahead != QUEST;
1589 }
1590 return false;
1591 }
1592 }));
1593 }
1594 }
1595
1596 private boolean definitelyOutOfReceiver() {
1597 return atSet(EQ, COLON, LBRACE, RBRACE, BY_KEYWORD) || atSet(TOP_LEVEL_DECLARATION_FIRST);
1598 }
1599
1600 /*
1601 * IDENTIFIER
1602 */
1603 private void parseFunctionOrPropertyName(boolean receiverFound, String title, TokenSet nameFollow, boolean nameRequired) {
1604 if (nameRequired && atSet(nameFollow)) return; // no name
1605
1606 TokenSet recoverySet = TokenSet.orSet(nameFollow, TokenSet.create(LBRACE, RBRACE), TOP_LEVEL_DECLARATION_FIRST);
1607 if (!receiverFound) {
1608 expect(IDENTIFIER, "Expecting " + title + " name or receiver type", recoverySet);
1609 }
1610 else {
1611 expect(IDENTIFIER, "Expecting " + title + " name", recoverySet);
1612 }
1613 }
1614
1615 /*
1616 * functionBody
1617 * : block
1618 * : "=" element
1619 * ;
1620 */
1621 private void parseFunctionBody() {
1622 if (at(LBRACE)) {
1623 parseBlock();
1624 }
1625 else if (at(EQ)) {
1626 advance(); // EQ
1627 myExpressionParsing.parseExpression();
1628 consumeIf(SEMICOLON);
1629 }
1630 else {
1631 error("Expecting function body");
1632 }
1633 }
1634
1635 /*
1636 * block
1637 * : "{" (expressions)* "}"
1638 * ;
1639 */
1640 void parseBlock() {
1641 PsiBuilder.Marker block = mark();
1642
1643 myBuilder.enableNewlines();
1644 expect(LBRACE, "Expecting '{' to open a block");
1645
1646 myExpressionParsing.parseStatements();
1647
1648 expect(RBRACE, "Expecting '}'");
1649 myBuilder.restoreNewlinesState();
1650
1651 block.done(BLOCK);
1652 }
1653
1654 /*
1655 * delegationSpecifier{","}
1656 */
1657 /*package*/ void parseDelegationSpecifierList() {
1658 PsiBuilder.Marker list = mark();
1659
1660 while (true) {
1661 if (at(COMMA)) {
1662 errorAndAdvance("Expecting a delegation specifier");
1663 continue;
1664 }
1665 parseDelegationSpecifier();
1666 if (!at(COMMA)) break;
1667 advance(); // COMMA
1668 }
1669
1670 list.done(SUPER_TYPE_LIST);
1671 }
1672
1673 /*
1674 * delegationSpecifier
1675 * : constructorInvocation // type and constructor arguments
1676 * : userType
1677 * : explicitDelegation
1678 * ;
1679 *
1680 * explicitDelegation
1681 * : userType "by" element
1682 * ;
1683 */
1684 private void parseDelegationSpecifier() {
1685 PsiBuilder.Marker delegator = mark();
1686 PsiBuilder.Marker reference = mark();
1687 parseTypeRef();
1688
1689 if (at(BY_KEYWORD)) {
1690 reference.drop();
1691 advance(); // BY_KEYWORD
1692 createForByClause(myBuilder).myExpressionParsing.parseExpression();
1693 delegator.done(DELEGATED_SUPER_TYPE_ENTRY);
1694 }
1695 else if (at(LPAR)) {
1696 reference.done(CONSTRUCTOR_CALLEE);
1697 myExpressionParsing.parseValueArgumentList();
1698 delegator.done(SUPER_TYPE_CALL_ENTRY);
1699 }
1700 else {
1701 reference.drop();
1702 delegator.done(SUPER_TYPE_ENTRY);
1703 }
1704 }
1705
1706 /*
1707 * typeParameters
1708 * : ("<" typeParameter{","} ">"
1709 * ;
1710 */
1711 private boolean parseTypeParameterList(TokenSet recoverySet) {
1712 boolean result = false;
1713 if (at(LT)) {
1714 PsiBuilder.Marker list = mark();
1715
1716 myBuilder.disableNewlines();
1717 advance(); // LT
1718
1719 while (true) {
1720 if (at(COMMA)) errorAndAdvance("Expecting type parameter declaration");
1721 parseTypeParameter();
1722
1723 if (!at(COMMA)) break;
1724 advance(); // COMMA
1725 }
1726
1727 expect(GT, "Missing '>'", recoverySet);
1728 myBuilder.restoreNewlinesState();
1729 result = true;
1730
1731 list.done(TYPE_PARAMETER_LIST);
1732 }
1733 return result;
1734 }
1735
1736 /*
1737 * typeConstraints
1738 * : ("where" typeConstraint{","})?
1739 * ;
1740 */
1741 private void parseTypeConstraintsGuarded(boolean typeParameterListOccurred) {
1742 PsiBuilder.Marker error = mark();
1743 boolean constraints = parseTypeConstraints();
1744 errorIf(error, constraints && !typeParameterListOccurred, "Type constraints are not allowed when no type parameters declared");
1745 }
1746
1747 private boolean parseTypeConstraints() {
1748 if (at(WHERE_KEYWORD)) {
1749 parseTypeConstraintList();
1750 return true;
1751 }
1752 return false;
1753 }
1754
1755 /*
1756 * typeConstraint{","}
1757 */
1758 private void parseTypeConstraintList() {
1759 assert _at(WHERE_KEYWORD);
1760
1761 advance(); // WHERE_KEYWORD
1762
1763 PsiBuilder.Marker list = mark();
1764
1765 while (true) {
1766 if (at(COMMA)) errorAndAdvance("Type constraint expected");
1767 parseTypeConstraint();
1768 if (!at(COMMA)) break;
1769 advance(); // COMMA
1770 }
1771
1772 list.done(TYPE_CONSTRAINT_LIST);
1773 }
1774
1775 /*
1776 * typeConstraint
1777 * : annotations SimpleName ":" type
1778 * ;
1779 */
1780 private void parseTypeConstraint() {
1781 PsiBuilder.Marker constraint = mark();
1782
1783 parseAnnotations(DEFAULT);
1784
1785 PsiBuilder.Marker reference = mark();
1786 if (expect(IDENTIFIER, "Expecting type parameter name", TokenSet.orSet(TokenSet.create(COLON, COMMA, LBRACE, RBRACE), TYPE_REF_FIRST))) {
1787 reference.done(REFERENCE_EXPRESSION);
1788 }
1789 else {
1790 reference.drop();
1791 }
1792
1793 expect(COLON, "Expecting ':' before the upper bound", TokenSet.orSet(TokenSet.create(LBRACE, RBRACE), TYPE_REF_FIRST));
1794
1795 parseTypeRef();
1796
1797 constraint.done(TYPE_CONSTRAINT);
1798 }
1799
1800 /*
1801 * typeParameter
1802 * : modifiers SimpleName (":" userType)?
1803 * ;
1804 */
1805 private void parseTypeParameter() {
1806 if (atSet(TYPE_PARAMETER_GT_RECOVERY_SET)) {
1807 error("Type parameter declaration expected");
1808 return;
1809 }
1810
1811 PsiBuilder.Marker mark = mark();
1812
1813 parseModifierList(DEFAULT, TokenSet.create(GT, COMMA, COLON));
1814
1815 expect(IDENTIFIER, "Type parameter name expected", TokenSet.EMPTY);
1816
1817 if (at(COLON)) {
1818 advance(); // COLON
1819 parseTypeRef();
1820 }
1821
1822 mark.done(TYPE_PARAMETER);
1823
1824 }
1825
1826 /*
1827 * type
1828 * : annotations typeDescriptor
1829 *
1830 * typeDescriptor
1831 * : selfType
1832 * : functionType
1833 * : userType
1834 * : nullableType
1835 * : "dynamic"
1836 * ;
1837 *
1838 * nullableType
1839 * : typeDescriptor "?"
1840 */
1841 void parseTypeRef() {
1842 parseTypeRef(TokenSet.EMPTY);
1843 }
1844
1845 void parseTypeRef(TokenSet extraRecoverySet) {
1846 PsiBuilder.Marker typeRefMarker = parseTypeRefContents(extraRecoverySet);
1847 typeRefMarker.done(TYPE_REFERENCE);
1848 }
1849
1850 // The extraRecoverySet is needed for the foo(bar<x, 1, y>(z)) case, to tell whether we should stop
1851 // on expression-indicating symbols or not
1852 private PsiBuilder.Marker parseTypeRefContents(TokenSet extraRecoverySet) {
1853 PsiBuilder.Marker typeRefMarker = mark();
1854 parseAnnotations(DEFAULT);
1855
1856 PsiBuilder.Marker typeElementMarker = mark();
1857
1858 IElementType lookahead = lookahead(1);
1859 IElementType lookahead2 = lookahead(2);
1860 boolean typeBeforeDot = true;
1861 if (at(IDENTIFIER) && !(lookahead == DOT && lookahead2 == IDENTIFIER) && lookahead != LT && at(DYNAMIC_KEYWORD)) {
1862 PsiBuilder.Marker dynamicType = mark();
1863 advance(); // DYNAMIC_KEYWORD
1864 dynamicType.done(DYNAMIC_TYPE);
1865 }
1866 else if (at(IDENTIFIER) || at(PACKAGE_KEYWORD) || atParenthesizedMutableForPlatformTypes(0)) {
1867 parseUserType();
1868 }
1869 else if (at(LPAR)) {
1870 PsiBuilder.Marker functionOrParenthesizedType = mark();
1871
1872 // This may be a function parameter list or just a prenthesized type
1873 advance(); // LPAR
1874 parseTypeRefContents(TokenSet.EMPTY).drop(); // parenthesized types, no reference element around it is needed
1875
1876 if (at(RPAR)) {
1877 advance(); // RPAR
1878 if (at(ARROW)) {
1879 // It's a function type with one parameter specified
1880 // (A) -> B
1881 functionOrParenthesizedType.rollbackTo();
1882 parseFunctionType();
1883 }
1884 else {
1885 // It's a parenthesized type
1886 // (A)
1887 functionOrParenthesizedType.drop();
1888 }
1889 }
1890 else {
1891 // This must be a function type
1892 // (A, B) -> C
1893 // or
1894 // (a : A) -> C
1895 functionOrParenthesizedType.rollbackTo();
1896 parseFunctionType();
1897 }
1898
1899 }
1900 else {
1901 errorWithRecovery("Type expected",
1902 TokenSet.orSet(TOP_LEVEL_DECLARATION_FIRST,
1903 TokenSet.create(EQ, COMMA, GT, RBRACKET, DOT, RPAR, RBRACE, LBRACE, SEMICOLON),
1904 extraRecoverySet));
1905 typeBeforeDot = false;
1906 }
1907
1908 // Disabling token merge is required for cases like
1909 // Int?.(Foo) -> Bar
1910 myBuilder.disableJoiningComplexTokens();
1911 typeElementMarker = parseNullableTypeSuffix(typeElementMarker);
1912 myBuilder.restoreJoiningComplexTokensState();
1913
1914 if (typeBeforeDot && at(DOT)) {
1915 // This is a receiver for a function type
1916 // A.(B) -> C
1917 // ^
1918
1919 PsiBuilder.Marker functionType = typeRefMarker.precede();
1920 PsiBuilder.Marker receiverType = typeRefMarker.precede();
1921 typeRefMarker.done(TYPE_REFERENCE);
1922 receiverType.done(FUNCTION_TYPE_RECEIVER);
1923
1924 advance(); // DOT
1925
1926 if (at(LPAR)) {
1927 parseFunctionTypeContents().drop();
1928 }
1929 else {
1930 error("Expecting function type");
1931 }
1932 typeRefMarker = functionType.precede();
1933
1934 functionType.done(FUNCTION_TYPE);
1935 }
1936
1937 typeElementMarker.drop();
1938 return typeRefMarker;
1939 }
1940
1941 @NotNull
1942 PsiBuilder.Marker parseNullableTypeSuffix(@NotNull PsiBuilder.Marker typeElementMarker) {
1943 // ?: is joined regardless of joining state
1944 while (at(QUEST) && myBuilder.rawLookup(1) != COLON) {
1945 PsiBuilder.Marker precede = typeElementMarker.precede();
1946 advance(); // QUEST
1947 typeElementMarker.done(NULLABLE_TYPE);
1948 typeElementMarker = precede;
1949 }
1950 return typeElementMarker;
1951 }
1952
1953 /*
1954 * userType
1955 * : simpleUserType{"."}
1956 * ;
1957 *
1958 * recovers on platform types:
1959 * - Foo!
1960 * - (Mutable)List<Foo>!
1961 * - Array<(out) Foo>!
1962 */
1963 void parseUserType() {
1964 PsiBuilder.Marker userType = mark();
1965
1966 if (at(PACKAGE_KEYWORD)) {
1967 PsiBuilder.Marker keyword = mark();
1968 advance(); // PACKAGE_KEYWORD
1969 keyword.error("Expecting an element");
1970 expect(DOT, "Expecting '.'", TokenSet.create(IDENTIFIER, LBRACE, RBRACE));
1971 }
1972
1973 PsiBuilder.Marker reference = mark();
1974 while (true) {
1975 recoverOnParenthesizedWordForPlatformTypes(0, "Mutable", true);
1976
1977 if (expect(IDENTIFIER, "Expecting type name",
1978 TokenSet.orSet(KotlinExpressionParsing.EXPRESSION_FIRST, KotlinExpressionParsing.EXPRESSION_FOLLOW, DECLARATION_FIRST))) {
1979 reference.done(REFERENCE_EXPRESSION);
1980 }
1981 else {
1982 reference.drop();
1983 break;
1984 }
1985
1986 parseTypeArgumentList();
1987
1988 recoverOnPlatformTypeSuffix();
1989
1990 if (!at(DOT)) {
1991 break;
1992 }
1993 if (lookahead(1) == LPAR && !atParenthesizedMutableForPlatformTypes(1)) {
1994 // This may be a receiver for a function type
1995 // Int.(Int) -> Int
1996 break;
1997 }
1998
1999 PsiBuilder.Marker precede = userType.precede();
2000 userType.done(USER_TYPE);
2001 userType = precede;
2002
2003 advance(); // DOT
2004 reference = mark();
2005 }
2006
2007 userType.done(USER_TYPE);
2008 }
2009
2010 private boolean atParenthesizedMutableForPlatformTypes(int offset) {
2011 return recoverOnParenthesizedWordForPlatformTypes(offset, "Mutable", false);
2012 }
2013
2014 private boolean recoverOnParenthesizedWordForPlatformTypes(int offset, String word, boolean consume) {
2015 // Array<(out) Foo>! or (Mutable)List<Bar>!
2016 if (lookahead(offset) == LPAR && lookahead(offset + 1) == IDENTIFIER && lookahead(offset + 2) == RPAR && lookahead(offset + 3) == IDENTIFIER) {
2017 PsiBuilder.Marker error = mark();
2018
2019 advance(offset);
2020
2021 advance(); // LPAR
2022 if (!word.equals(myBuilder.getTokenText())) {
2023 // something other than "out" / "Mutable"
2024 error.rollbackTo();
2025 return false;
2026 }
2027 else {
2028 advance(); // IDENTIFIER('out')
2029 advance(); // RPAR
2030
2031 if (consume) {
2032 error.error("Unexpected tokens");
2033 }
2034 else {
2035 error.rollbackTo();
2036 }
2037
2038 return true;
2039 }
2040 }
2041 return false;
2042 }
2043
2044 private void recoverOnPlatformTypeSuffix() {
2045 // Recovery for platform types
2046 if (at(EXCL)) {
2047 PsiBuilder.Marker error = mark();
2048 advance(); // EXCL
2049 error.error("Unexpected token");
2050 }
2051 }
2052
2053 /*
2054 * (optionalProjection type){","}
2055 */
2056 private PsiBuilder.Marker parseTypeArgumentList() {
2057 if (!at(LT)) return null;
2058
2059 PsiBuilder.Marker list = mark();
2060
2061 tryParseTypeArgumentList(TokenSet.EMPTY);
2062
2063 list.done(TYPE_ARGUMENT_LIST);
2064 return list;
2065 }
2066
2067 boolean tryParseTypeArgumentList(TokenSet extraRecoverySet) {
2068 myBuilder.disableNewlines();
2069 advance(); // LT
2070
2071 while (true) {
2072 PsiBuilder.Marker projection = mark();
2073
2074 recoverOnParenthesizedWordForPlatformTypes(0, "out", true);
2075
2076 // TokenSet lookFor = TokenSet.create(IDENTIFIER);
2077 // TokenSet stopAt = TokenSet.create(COMMA, COLON, GT);
2078 // parseModifierListWithUnescapedAnnotations(MODIFIER_LIST, lookFor, stopAt);
2079 // Currently we do not allow annotations
2080 parseModifierList(NO_ANNOTATIONS, TokenSet.create(COMMA, COLON, GT));
2081
2082 if (at(MUL)) {
2083 advance(); // MUL
2084 }
2085 else {
2086 parseTypeRef(extraRecoverySet);
2087 }
2088 projection.done(TYPE_PROJECTION);
2089 if (!at(COMMA)) break;
2090 advance(); // COMMA
2091 }
2092
2093 boolean atGT = at(GT);
2094 if (!atGT) {
2095 error("Expecting a '>'");
2096 }
2097 else {
2098 advance(); // GT
2099 }
2100 myBuilder.restoreNewlinesState();
2101 return atGT;
2102 }
2103
2104 /*
2105 * functionType
2106 * : "(" (parameter | modifiers type){","}? ")" "->" type?
2107 * ;
2108 */
2109 private void parseFunctionType() {
2110 parseFunctionTypeContents().done(FUNCTION_TYPE);
2111 }
2112
2113 private PsiBuilder.Marker parseFunctionTypeContents() {
2114 assert _at(LPAR) : tt();
2115 PsiBuilder.Marker functionType = mark();
2116
2117 parseValueParameterList(true, /* typeRequired = */ true, TokenSet.EMPTY);
2118
2119 expect(ARROW, "Expecting '->' to specify return type of a function type", TYPE_REF_FIRST);
2120 parseTypeRef();
2121
2122 return functionType;
2123 }
2124
2125 private static final TokenSet NO_MODIFIER_BEFORE_FOR_VALUE_PARAMETER = TokenSet.create(COMMA, COLON, EQ, RPAR);
2126
2127 /*
2128 * functionParameters
2129 * : "(" functionParameter{","}? ")" // default values
2130 * ;
2131 *
2132 * functionParameter
2133 * : modifiers functionParameterRest
2134 * ;
2135 *
2136 * functionParameterRest
2137 * : parameter ("=" element)?
2138 * ;
2139 */
2140 void parseValueParameterList(boolean isFunctionTypeContents, boolean typeRequired, TokenSet recoverySet) {
2141 assert _at(LPAR);
2142 PsiBuilder.Marker parameters = mark();
2143
2144 myBuilder.disableNewlines();
2145 advance(); // LPAR
2146
2147 if (!at(RPAR) && !atSet(recoverySet)) {
2148 while (true) {
2149 if (at(COMMA)) {
2150 errorAndAdvance("Expecting a parameter declaration");
2151 }
2152 else if (at(RPAR)) {
2153 error("Expecting a parameter declaration");
2154 break;
2155 }
2156
2157 if (isFunctionTypeContents) {
2158 if (!tryParseValueParameter(typeRequired)) {
2159 PsiBuilder.Marker valueParameter = mark();
2160 parseModifierList(DEFAULT, NO_MODIFIER_BEFORE_FOR_VALUE_PARAMETER); // lazy, out, ref
2161 parseTypeRef();
2162 closeDeclarationWithCommentBinders(valueParameter, VALUE_PARAMETER, false);
2163 }
2164 }
2165 else {
2166 parseValueParameter(typeRequired);
2167 }
2168
2169 if (at(COMMA)) {
2170 advance(); // COMMA
2171 }
2172 else {
2173 if (!at(RPAR)) error("Expecting comma or ')'");
2174 if (!atSet(isFunctionTypeContents ? LAMBDA_VALUE_PARAMETER_FIRST : VALUE_PARAMETER_FIRST)) break;
2175 }
2176 }
2177 }
2178
2179 expect(RPAR, "Expecting ')'", recoverySet);
2180 myBuilder.restoreNewlinesState();
2181
2182 parameters.done(VALUE_PARAMETER_LIST);
2183 }
2184
2185 /*
2186 * functionParameter
2187 * : modifiers ("val" | "var")? parameter ("=" element)?
2188 * ;
2189 */
2190 private boolean tryParseValueParameter(boolean typeRequired) {
2191 return parseValueParameter(true, typeRequired);
2192 }
2193
2194 public void parseValueParameter(boolean typeRequired) {
2195 parseValueParameter(false, typeRequired);
2196 }
2197
2198 private boolean parseValueParameter(boolean rollbackOnFailure, boolean typeRequired) {
2199 PsiBuilder.Marker parameter = mark();
2200
2201 parseModifierList(DEFAULT, NO_MODIFIER_BEFORE_FOR_VALUE_PARAMETER);
2202
2203 if (at(VAR_KEYWORD) || at(VAL_KEYWORD)) {
2204 advance(); // VAR_KEYWORD | VAL_KEYWORD
2205 }
2206
2207 if (!parseFunctionParameterRest(typeRequired) && rollbackOnFailure) {
2208 parameter.rollbackTo();
2209 return false;
2210 }
2211
2212 closeDeclarationWithCommentBinders(parameter, VALUE_PARAMETER, false);
2213 return true;
2214 }
2215
2216 /*
2217 * functionParameterRest
2218 * : parameter ("=" element)?
2219 * ;
2220 */
2221 private boolean parseFunctionParameterRest(boolean typeRequired) {
2222 boolean noErrors = true;
2223
2224 // Recovery for the case 'fun foo(Array<String>) {}'
2225 // Recovery for the case 'fun foo(: Int) {}'
2226 if ((at(IDENTIFIER) && lookahead(1) == LT) || at(COLON)) {
2227 error("Parameter name expected");
2228 if (at(COLON)) {
2229 // We keep noErrors == true so that unnamed parameters starting with ":" are not rolled back during parsing of functional types
2230 advance(); // COLON
2231 }
2232 else {
2233 noErrors = false;
2234 }
2235 parseTypeRef();
2236 }
2237 else {
2238 expect(IDENTIFIER, "Parameter name expected", PARAMETER_NAME_RECOVERY_SET);
2239
2240 if (at(COLON)) {
2241 advance(); // COLON
2242 parseTypeRef();
2243 }
2244 else if (typeRequired) {
2245 errorWithRecovery("Parameters must have type annotation", PARAMETER_NAME_RECOVERY_SET);
2246 noErrors = false;
2247 }
2248 }
2249
2250 if (at(EQ)) {
2251 advance(); // EQ
2252 myExpressionParsing.parseExpression();
2253 }
2254
2255 return noErrors;
2256 }
2257
2258 @Override
2259 protected KotlinParsing create(SemanticWhitespaceAwarePsiBuilder builder) {
2260 return createForTopLevel(builder);
2261 }
2262
2263 /*package*/ static class ModifierDetector implements Consumer<IElementType> {
2264 private boolean enumDetected = false;
2265 private boolean defaultDetected = false;
2266
2267 @Override
2268 public void consume(IElementType item) {
2269 if (item == KtTokens.ENUM_KEYWORD) {
2270 enumDetected = true;
2271 }
2272 else if (item == KtTokens.COMPANION_KEYWORD) {
2273 defaultDetected = true;
2274 }
2275 }
2276
2277 public boolean isEnumDetected() {
2278 return enumDetected;
2279 }
2280
2281 public boolean isDefaultDetected() {
2282 return defaultDetected;
2283 }
2284 }
2285
2286 enum AnnotationParsingMode {
2287 DEFAULT(false, false, true),
2288 FILE_ANNOTATIONS_BEFORE_PACKAGE(false, true, true),
2289 FILE_ANNOTATIONS_WHEN_PACKAGE_OMITTED(false, true, true),
2290 IN_ANNOTATION_LIST(true, false, true),
2291 NO_ANNOTATIONS(false, false, false);
2292
2293 boolean allowShortAnnotations;
2294 boolean isFileAnnotationParsingMode;
2295 boolean allowAnnotations;
2296
2297 AnnotationParsingMode(
2298 boolean allowShortAnnotations,
2299 boolean isFileAnnotationParsingMode,
2300 boolean allowAnnotations
2301 ) {
2302 this.allowShortAnnotations = allowShortAnnotations;
2303 this.isFileAnnotationParsingMode = isFileAnnotationParsingMode;
2304 this.allowAnnotations = allowAnnotations;
2305 }
2306 }
2307 }