diff --git a/compiler/frontend/buildLexer.xml b/compiler/frontend/buildLexer.xml index f39f99d46cd..b7539670c0d 100644 --- a/compiler/frontend/buildLexer.xml +++ b/compiler/frontend/buildLexer.xml @@ -46,6 +46,8 @@ + destdir="${home}/src/org/jetbrains/jet/lexer/"/> + diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex new file mode 100644 index 00000000000..ff96ccf0bec --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex @@ -0,0 +1,75 @@ +package org.jetbrains.jet.kdoc.lexer; + +import com.intellij.lexer.FlexLexer; +import com.intellij.psi.TokenType; +import com.intellij.psi.tree.IElementType; +import com.intellij.util.text.CharArrayUtil; + +%% + +%unicode +%class _KDocLexer +%implements FlexLexer + +%{ + public _KDocLexer() { + this((java.io.Reader)null); + } + + private final boolean isLastToken() { + return zzMarkedPos == zzBuffer.length(); + } + + private final Boolean yytextContainLineBreaks() { + return CharArrayUtil.containLineBreaks(zzBuffer, zzStartRead, zzMarkedPos); + } + + private final void pushbackEnd() { + if (isLastToken() && CharArrayUtil.regionMatches(zzBuffer, zzMarkedPos - 2, zzMarkedPos, "*/")) { + yypushback(2); + } + } + + private final void pushbackText() { + int i = zzStartRead; + while (zzBuffer.charAt(i) == '*') i++; + yypushback(zzMarkedPos - i); + } +%} + +%function advance +%type IElementType +%eof{ + return; +%eof} + +%state CONTENTS +%state LINE_BEGINNING + +WHITE_SPACE_CHAR =[\ \t\f\n\r] +NOT_WHITE_SPACE_CHAR=[^\ \t\f\n\r] + +%% + + + "/**" { yybegin(CONTENTS); + return KDocTokens.START; } +"*"+ "/" { if (isLastToken()) + return KDocTokens.END; } + +// hack: make longest match + "*"+ {NOT_WHITE_SPACE_CHAR}* { pushbackText(); + yybegin(CONTENTS); + return KDocTokens.LEADING_ASTERISK; } + + { + // todo: put markdown and @tags token patterns here + + {NOT_WHITE_SPACE_CHAR}+ { pushbackEnd(); + return KDocTokens.TEXT; } + {WHITE_SPACE_CHAR}+ { if (yytextContainLineBreaks()) + yybegin(LINE_BEGINNING); + return TokenType.WHITE_SPACE; } +} + +. { return TokenType.BAD_CHARACTER; } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocLexer.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocLexer.java new file mode 100644 index 00000000000..dd9be21a218 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocLexer.java @@ -0,0 +1,27 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.lexer; + +import com.intellij.lexer.FlexAdapter; + +import java.io.Reader; + +public class KDocLexer extends FlexAdapter { + public KDocLexer() { + super(new _KDocLexer((Reader) null)); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocToken.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocToken.java new file mode 100644 index 00000000000..3d321b008f7 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocToken.java @@ -0,0 +1,27 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.lexer; + +import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lexer.JetToken; + +public class KDocToken extends JetToken { + public KDocToken(@NotNull @NonNls String debugName) { + super(debugName); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java new file mode 100644 index 00000000000..217eb51c14d --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java @@ -0,0 +1,56 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.lexer; + +import com.intellij.lang.ASTNode; +import com.intellij.lang.PsiBuilder; +import com.intellij.lang.PsiBuilderFactory; +import com.intellij.lang.PsiParser; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiElement; +import com.intellij.psi.tree.ILazyParseableElementType; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.kdoc.parser.KDocParser; +import org.jetbrains.jet.kdoc.psi.impl.KDocImpl; +import org.jetbrains.jet.plugin.JetLanguage; + +public interface KDocTokens { + ILazyParseableElementType KDOC = new ILazyParseableElementType("KDoc", JetLanguage.INSTANCE) { + @Override + public ASTNode parseContents(ASTNode chameleon) { + PsiElement parentElement = chameleon.getTreeParent().getPsi(); + Project project = parentElement.getProject(); + PsiBuilder builder = PsiBuilderFactory.getInstance().createBuilder(project, chameleon, new KDocLexer(), getLanguage(), + chameleon.getText()); + PsiParser parser = new KDocParser(); + + return parser.parse(this, builder).getFirstChildNode(); + } + + @Nullable + @Override + public ASTNode createNode(CharSequence text) { + return new KDocImpl(text); + } + }; + + KDocToken START = new KDocToken("KDOC_START"); + KDocToken END = new KDocToken("KDOC_END"); + KDocToken LEADING_ASTERISK = new KDocToken("KDOC_LEADING_ASTERISK"); + + KDocToken TEXT = new KDocToken("KDOC_TEXT"); +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java new file mode 100644 index 00000000000..c2007811156 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java @@ -0,0 +1,539 @@ +/* The following code was generated by JFlex 1.4.3 on 23.05.13 19:26 */ + +package org.jetbrains.jet.kdoc.lexer; + +import com.intellij.lexer.FlexLexer; +import com.intellij.psi.TokenType; +import com.intellij.psi.tree.IElementType; +import com.intellij.util.text.CharArrayUtil; + + +/** + * This class is a scanner generated by + * JFlex 1.4.3 + * on 23.05.13 19:26 from the specification file + * /Users/factitious/Documents/kotlin/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex + */ +class _KDocLexer implements FlexLexer { + /** initial size of the lookahead buffer */ + private static final int ZZ_BUFFERSIZE = 16384; + + /** lexical states */ + public static final int LINE_BEGINNING = 4; + public static final int CONTENTS = 2; + public static final int YYINITIAL = 0; + + /** + * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l + * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l + * at the beginning of a line + * l is of the form l = 2*k, k a non negative integer + */ + private static final int ZZ_LEXSTATE[] = { + 0, 0, 1, 1, 2, 2 + }; + + /** + * Translates characters to character classes + */ + private static final String ZZ_CMAP_PACKED = + "\11\0\1\1\1\4\1\0\2\1\22\0\1\1\11\0\1\3\4\0"+ + "\1\2\uffd0\0"; + + /** + * Translates characters to character classes + */ + private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED); + + /** + * Translates DFA states to action switch labels. + */ + private static final int [] ZZ_ACTION = zzUnpackAction(); + + private static final String ZZ_ACTION_PACKED_0 = + "\3\0\3\1\1\2\1\3\1\2\1\4\1\0\1\5"+ + "\1\0\1\5\1\4\1\5\1\6"; + + private static int [] zzUnpackAction() { + int [] result = new int[17]; + int offset = 0; + offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackAction(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + do result[j++] = value; while (--count > 0); + } + return j; + } + + + /** + * Translates a state to a row index in the transition table + */ + private static final int [] ZZ_ROWMAP = zzUnpackRowMap(); + + private static final String ZZ_ROWMAP_PACKED_0 = + "\0\0\0\5\0\12\0\17\0\24\0\31\0\36\0\43"+ + "\0\50\0\55\0\62\0\17\0\31\0\36\0\67\0\67"+ + "\0\17"; + + private static int [] zzUnpackRowMap() { + int [] result = new int[17]; + int offset = 0; + offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackRowMap(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int high = packed.charAt(i++) << 16; + result[j++] = high | packed.charAt(i++); + } + return j; + } + + /** + * The transition table of the DFA + */ + private static final int [] ZZ_TRANS = zzUnpackTrans(); + + private static final String ZZ_TRANS_PACKED_0 = + "\2\4\1\5\1\6\1\0\1\7\1\10\1\7\1\11"+ + "\1\10\1\7\1\10\1\7\1\12\1\10\10\0\1\13"+ + "\3\0\1\14\1\15\1\0\1\7\1\0\2\7\2\0"+ + "\1\10\2\0\1\10\1\7\1\0\1\16\1\11\1\0"+ + "\1\17\1\0\1\20\1\12\4\0\1\21\1\0\1\17"+ + "\1\0\2\17\1\0"; + + private static int [] zzUnpackTrans() { + int [] result = new int[60]; + int offset = 0; + offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackTrans(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + value--; + do result[j++] = value; while (--count > 0); + } + return j; + } + + + /* error codes */ + private static final int ZZ_UNKNOWN_ERROR = 0; + private static final int ZZ_NO_MATCH = 1; + private static final int ZZ_PUSHBACK_2BIG = 2; + private static final char[] EMPTY_BUFFER = new char[0]; + private static final int YYEOF = -1; + private static java.io.Reader zzReader = null; // Fake + + /* error messages for the codes above */ + private static final String ZZ_ERROR_MSG[] = { + "Unkown internal scanner error", + "Error: could not match input", + "Error: pushback value was too large" + }; + + /** + * ZZ_ATTRIBUTE[aState] contains the attributes of state aState + */ + private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute(); + + private static final String ZZ_ATTRIBUTE_PACKED_0 = + "\3\0\1\11\6\1\1\0\1\11\1\0\3\1\1\11"; + + private static int [] zzUnpackAttribute() { + int [] result = new int[17]; + int offset = 0; + offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackAttribute(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + do result[j++] = value; while (--count > 0); + } + return j; + } + + /** the current state of the DFA */ + private int zzState; + + /** the current lexical state */ + private int zzLexicalState = YYINITIAL; + + /** this buffer contains the current text to be matched and is + the source of the yytext() string */ + private CharSequence zzBuffer = ""; + + /** this buffer may contains the current text array to be matched when it is cheap to acquire it */ + private char[] zzBufferArray; + + /** the textposition at the last accepting state */ + private int zzMarkedPos; + + /** the textposition at the last state to be included in yytext */ + private int zzPushbackPos; + + /** the current text position in the buffer */ + private int zzCurrentPos; + + /** startRead marks the beginning of the yytext() string in the buffer */ + private int zzStartRead; + + /** endRead marks the last character in the buffer, that has been read + from input */ + private int zzEndRead; + + /** + * zzAtBOL == true <=> the scanner is currently at the beginning of a line + */ + private boolean zzAtBOL = true; + + /** zzAtEOF == true <=> the scanner is at the EOF */ + private boolean zzAtEOF; + + /** denotes if the user-EOF-code has already been executed */ + private boolean zzEOFDone; + + /* user code: */ + public _KDocLexer() { + this((java.io.Reader)null); + } + + private final boolean isLastToken() { + return zzMarkedPos == zzBuffer.length(); + } + + private final Boolean yytextContainLineBreaks() { + return CharArrayUtil.containLineBreaks(zzBuffer, zzStartRead, zzMarkedPos); + } + + private final void pushbackEnd() { + if (isLastToken() && CharArrayUtil.regionMatches(zzBuffer, zzMarkedPos - 2, zzMarkedPos, "*/")) { + yypushback(2); + } + } + + private final void pushbackText() { + int i = zzStartRead; + while (zzBuffer.charAt(i) == '*') i++; + yypushback(zzMarkedPos - i); + } + + + _KDocLexer(java.io.Reader in) { + this.zzReader = in; + } + + /** + * Creates a new scanner. + * There is also java.io.Reader version of this constructor. + * + * @param in the java.io.Inputstream to read input from. + */ + _KDocLexer(java.io.InputStream in) { + this(new java.io.InputStreamReader(in)); + } + + /** + * Unpacks the compressed character translation table. + * + * @param packed the packed character translation table + * @return the unpacked character translation table + */ + private static char [] zzUnpackCMap(String packed) { + char [] map = new char[0x10000]; + int i = 0; /* index in packed string */ + int j = 0; /* index in unpacked array */ + while (i < 24) { + int count = packed.charAt(i++); + char value = packed.charAt(i++); + do map[j++] = value; while (--count > 0); + } + return map; + } + + public final int getTokenStart(){ + return zzStartRead; + } + + public final int getTokenEnd(){ + return getTokenStart() + yylength(); + } + + public void reset(CharSequence buffer, int start, int end,int initialState){ + zzBuffer = buffer; + zzBufferArray = com.intellij.util.text.CharArrayUtil.fromSequenceWithoutCopying(buffer); + zzCurrentPos = zzMarkedPos = zzStartRead = start; + zzPushbackPos = 0; + zzAtEOF = false; + zzAtBOL = true; + zzEndRead = end; + yybegin(initialState); + } + + /** + * Refills the input buffer. + * + * @return false, iff there was new input. + * + * @exception java.io.IOException if any I/O-Error occurs + */ + private boolean zzRefill() throws java.io.IOException { + return true; + } + + + /** + * Returns the current lexical state. + */ + public final int yystate() { + return zzLexicalState; + } + + + /** + * Enters a new lexical state + * + * @param newState the new lexical state + */ + public final void yybegin(int newState) { + zzLexicalState = newState; + } + + + /** + * Returns the text matched by the current regular expression. + */ + public final CharSequence yytext() { + return zzBuffer.subSequence(zzStartRead, zzMarkedPos); + } + + + /** + * Returns the character at position pos from the + * matched text. + * + * It is equivalent to yytext().charAt(pos), but faster + * + * @param pos the position of the character to fetch. + * A value from 0 to yylength()-1. + * + * @return the character at position pos + */ + public final char yycharat(int pos) { + return zzBufferArray != null ? zzBufferArray[zzStartRead+pos]:zzBuffer.charAt(zzStartRead+pos); + } + + + /** + * Returns the length of the matched text region. + */ + public final int yylength() { + return zzMarkedPos-zzStartRead; + } + + + /** + * Reports an error that occured while scanning. + * + * In a wellformed scanner (no or only correct usage of + * yypushback(int) and a match-all fallback rule) this method + * will only be called with things that "Can't Possibly Happen". + * If this method is called, something is seriously wrong + * (e.g. a JFlex bug producing a faulty scanner etc.). + * + * Usual syntax/scanner level error handling should be done + * in error fallback rules. + * + * @param errorCode the code of the errormessage to display + */ + private void zzScanError(int errorCode) { + String message; + try { + message = ZZ_ERROR_MSG[errorCode]; + } + catch (ArrayIndexOutOfBoundsException e) { + message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR]; + } + + throw new Error(message); + } + + + /** + * Pushes the specified amount of characters back into the input stream. + * + * They will be read again by then next call of the scanning method + * + * @param number the number of characters to be read again. + * This number must not be greater than yylength()! + */ + public void yypushback(int number) { + if ( number > yylength() ) + zzScanError(ZZ_PUSHBACK_2BIG); + + zzMarkedPos -= number; + } + + + /** + * Contains user EOF-code, which will be executed exactly once, + * when the end of file is reached + */ + private void zzDoEOF() { + if (!zzEOFDone) { + zzEOFDone = true; + return; + + } + } + + + /** + * Resumes scanning until the next regular expression is matched, + * the end of input is encountered or an I/O-Error occurs. + * + * @return the next token + * @exception java.io.IOException if any I/O-Error occurs + */ + public IElementType advance() throws java.io.IOException { + int zzInput; + int zzAction; + + // cached fields: + int zzCurrentPosL; + int zzMarkedPosL; + int zzEndReadL = zzEndRead; + CharSequence zzBufferL = zzBuffer; + char[] zzBufferArrayL = zzBufferArray; + char [] zzCMapL = ZZ_CMAP; + + int [] zzTransL = ZZ_TRANS; + int [] zzRowMapL = ZZ_ROWMAP; + int [] zzAttrL = ZZ_ATTRIBUTE; + + while (true) { + zzMarkedPosL = zzMarkedPos; + + zzAction = -1; + + zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL; + + zzState = ZZ_LEXSTATE[zzLexicalState]; + + + zzForAction: { + while (true) { + + if (zzCurrentPosL < zzEndReadL) + zzInput = (zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++] : zzBufferL.charAt(zzCurrentPosL++)); + else if (zzAtEOF) { + zzInput = YYEOF; + break zzForAction; + } + else { + // store back cached positions + zzCurrentPos = zzCurrentPosL; + zzMarkedPos = zzMarkedPosL; + boolean eof = zzRefill(); + // get translated positions and possibly new buffer + zzCurrentPosL = zzCurrentPos; + zzMarkedPosL = zzMarkedPos; + zzBufferL = zzBuffer; + zzEndReadL = zzEndRead; + if (eof) { + zzInput = YYEOF; + break zzForAction; + } + else { + zzInput = (zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++] : zzBufferL.charAt(zzCurrentPosL++)); + } + } + int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ]; + if (zzNext == -1) break zzForAction; + zzState = zzNext; + + int zzAttributes = zzAttrL[zzState]; + if ( (zzAttributes & 1) == 1 ) { + zzAction = zzState; + zzMarkedPosL = zzCurrentPosL; + if ( (zzAttributes & 8) == 8 ) break zzForAction; + } + + } + } + + // store back cached position + zzMarkedPos = zzMarkedPosL; + + switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) { + case 6: + { yybegin(CONTENTS); + return KDocTokens.START; + } + case 7: break; + case 5: + { if (isLastToken()) + return KDocTokens.END; + } + case 8: break; + case 1: + { return TokenType.BAD_CHARACTER; + } + case 9: break; + case 2: + { pushbackEnd(); + return KDocTokens.TEXT; + } + case 10: break; + case 4: + { pushbackText(); + yybegin(CONTENTS); + return KDocTokens.LEADING_ASTERISK; + } + case 11: break; + case 3: + { if (yytextContainLineBreaks()) + yybegin(LINE_BEGINNING); + return TokenType.WHITE_SPACE; + } + case 12: break; + default: + if (zzInput == YYEOF && zzStartRead == zzCurrentPos) { + zzAtEOF = true; + zzDoEOF(); + return null; + } + else { + zzScanError(ZZ_NO_MATCH); + } + } + } + } + + +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/parser/KDocParser.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/parser/KDocParser.java new file mode 100644 index 00000000000..dd2e07e168c --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/parser/KDocParser.java @@ -0,0 +1,39 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.parser; + +import com.intellij.lang.ASTNode; +import com.intellij.lang.PsiBuilder; +import com.intellij.lang.PsiParser; +import com.intellij.psi.tree.IElementType; +import org.jetbrains.annotations.NotNull; + +public class KDocParser implements PsiParser { + @Override + @NotNull + public ASTNode parse(IElementType root, PsiBuilder builder) { + PsiBuilder.Marker rootMarker = builder.mark(); + + // todo: parse KDoc tags, markdown, etc... + while (!builder.eof()) { + builder.advanceLexer(); + } + + rootMarker.done(root); + return builder.getTreeBuilt(); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDoc.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDoc.java new file mode 100644 index 00000000000..5c5c40daef1 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDoc.java @@ -0,0 +1,23 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.psi.api; + +import com.intellij.psi.PsiComment; + +// Don't implement JetElement (or it will be treated as statement) +public interface KDoc extends PsiComment { +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDocElement.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDocElement.java new file mode 100644 index 00000000000..32119bebdd9 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDocElement.java @@ -0,0 +1,22 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.psi.api; + +import org.jetbrains.jet.lang.psi.JetElement; + +public interface KDocElement extends JetElement { +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocElementImpl.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocElementImpl.java new file mode 100644 index 00000000000..39716bac4b7 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocElementImpl.java @@ -0,0 +1,40 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.psi.impl; + +import com.intellij.extapi.psi.ASTWrapperPsiElement; +import com.intellij.lang.ASTNode; +import com.intellij.lang.Language; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.plugin.JetLanguage; + +public abstract class KDocElementImpl extends ASTWrapperPsiElement { + @NotNull + @Override + public Language getLanguage() { + return JetLanguage.INSTANCE; + } + + @Override + public String toString() { + return getNode().getElementType().toString(); + } + + public KDocElementImpl(@NotNull ASTNode node) { + super(node); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocImpl.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocImpl.java new file mode 100644 index 00000000000..5cb4db81a40 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocImpl.java @@ -0,0 +1,48 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.psi.impl; + +import com.intellij.lang.Language; +import com.intellij.psi.impl.source.tree.LazyParseablePsiElement; +import com.intellij.psi.tree.IElementType; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.kdoc.lexer.KDocTokens; +import org.jetbrains.jet.kdoc.psi.api.KDoc; +import org.jetbrains.jet.lexer.JetTokens; +import org.jetbrains.jet.plugin.JetLanguage; + +public class KDocImpl extends LazyParseablePsiElement implements KDoc { + public KDocImpl(CharSequence buffer) { + super(KDocTokens.KDOC, buffer); + } + + @NotNull + @Override + public Language getLanguage() { + return JetLanguage.INSTANCE; + } + + @Override + public String toString() { + return getNode().getElementType().toString(); + } + + @Override + public IElementType getTokenType() { + return JetTokens.DOC_COMMENT; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java index 082ad68d492..7c6058ef924 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java @@ -408,5 +408,4 @@ public class JetVisitor extends PsiElementVisitor { public R visitEscapeStringTemplateEntry(JetEscapeStringTemplateEntry entry, D data) { return visitStringTemplateEntry(entry, data); } - } diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java index 8bd4eb4594d..0c0124566b7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java +++ b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java @@ -19,14 +19,17 @@ package org.jetbrains.jet.lexer; import com.intellij.psi.TokenType; import com.intellij.psi.tree.IElementType; import com.intellij.psi.tree.TokenSet; +import org.jetbrains.jet.kdoc.lexer.KDocTokens; public interface JetTokens { JetToken EOF = new JetToken("EOF"); - JetToken BLOCK_COMMENT = new JetToken("BLOCK_COMMENT"); - JetToken DOC_COMMENT = new JetToken("DOC_COMMENT"); - JetToken EOL_COMMENT = new JetToken("EOL_COMMENT"); - JetToken SHEBANG_COMMENT = new JetToken("SHEBANG_COMMENT"); + JetToken BLOCK_COMMENT = new JetToken("BLOCK_COMMENT"); + JetToken EOL_COMMENT = new JetToken("EOL_COMMENT"); + JetToken SHEBANG_COMMENT = new JetToken("SHEBANG_COMMENT"); + + //JetToken DOC_COMMENT = new JetToken("DOC_COMMENT"); + IElementType DOC_COMMENT = KDocTokens.KDOC; IElementType WHITE_SPACE = TokenType.WHITE_SPACE; diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java b/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java index d7cf8fbff21..f56cf18375f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java @@ -1,21 +1,18 @@ -/* The following code was generated by JFlex 1.4.3 on 3/12/13 8:22 PM */ +/* The following code was generated by JFlex 1.4.3 on 23.05.13 19:26 */ package org.jetbrains.jet.lexer; -import java.util.*; -import com.intellij.lexer.*; -import com.intellij.psi.*; +import com.intellij.lexer.FlexLexer; +import com.intellij.psi.TokenType; import com.intellij.psi.tree.IElementType; import com.intellij.util.containers.Stack; -import org.jetbrains.jet.lexer.JetTokens; - /** * This class is a scanner generated by * JFlex 1.4.3 - * on 3/12/13 8:22 PM from the specification file - * C:/1/kotlin/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex + * on 23.05.13 19:26 from the specification file + * /Users/factitious/Documents/kotlin/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex */ class _JetLexer implements FlexLexer { /** initial size of the lookahead buffer */ @@ -843,7 +840,7 @@ class _JetLexer implements FlexLexer { while (true) { if (zzCurrentPosL < zzEndReadL) - zzInput = zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++]:zzBufferL.charAt(zzCurrentPosL++); + zzInput = (zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++] : zzBufferL.charAt(zzCurrentPosL++)); else if (zzAtEOF) { zzInput = YYEOF; break zzForAction; @@ -863,7 +860,7 @@ class _JetLexer implements FlexLexer { break zzForAction; } else { - zzInput = zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++]:zzBufferL.charAt(zzCurrentPosL++); + zzInput = (zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++] : zzBufferL.charAt(zzCurrentPosL++)); } } int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ]; @@ -904,193 +901,202 @@ class _JetLexer implements FlexLexer { { return JetTokens.NULL_KEYWORD ; } case 110: break; + case 35: + { if (lBraceCount == 0) { + popState(); + return JetTokens.LONG_TEMPLATE_ENTRY_END; + } + lBraceCount--; + return JetTokens.RBRACE; + } + case 111: break; case 16: { return JetTokens.LT ; } - case 111: break; + case 112: break; case 54: { return JetTokens.DO_KEYWORD ; } - case 112: break; + case 113: break; case 20: { return JetTokens.PLUS ; } - case 113: break; + case 114: break; case 59: { return JetTokens.PLUSEQ ; } - case 114: break; + case 115: break; case 94: { popState(); return JetTokens.THIS_KEYWORD; } - case 115: break; + case 116: break; case 28: { return JetTokens.COMMA ; } - case 116: break; + case 117: break; case 17: { return JetTokens.GT ; } - case 117: break; + case 118: break; case 4: { return JetTokens.WHITE_SPACE; } - case 118: break; + case 119: break; case 26: { return JetTokens.RPAR ; } - case 119: break; + case 120: break; case 57: { return JetTokens.DOUBLE_ARROW; } - case 120: break; + case 121: break; case 88: { return JetTokens.TRUE_KEYWORD ; } - case 121: break; + case 122: break; case 82: { return JetTokens.IDE_TEMPLATE_START ; } - case 122: break; + case 123: break; case 37: { return JetTokens.FIELD_IDENTIFIER; } - case 123: break; + case 124: break; case 61: { return JetTokens.ANDAND ; } - case 124: break; + case 125: break; case 66: { pushState(LONG_TEMPLATE_ENTRY); return JetTokens.LONG_TEMPLATE_ENTRY_START; } - case 125: break; + case 126: break; case 36: { return JetTokens.FLOAT_LITERAL; } - case 126: break; + case 127: break; case 40: { return JetTokens.EOL_COMMENT; } - case 127: break; + case 128: break; case 92: { return JetTokens.WHEN_KEYWORD ; } - case 128: break; + case 129: break; case 75: { pushState(RAW_STRING); return JetTokens.OPEN_QUOTE; } - case 129: break; + case 130: break; case 22: { return JetTokens.COLON ; } - case 130: break; + case 131: break; case 55: { return JetTokens.LTEQ ; } - case 131: break; + case 132: break; case 47: { return JetTokens.ARROW ; } - case 132: break; + case 133: break; case 32: { popState(); return JetTokens.IDENTIFIER; } - case 133: break; + case 134: break; case 23: { return JetTokens.LBRACKET ; } - case 134: break; + case 135: break; case 70: { yypushback(2); return JetTokens.INTEGER_LITERAL; } - case 135: break; + case 136: break; case 11: { return JetTokens.CHARACTER_LITERAL; } - case 136: break; + case 137: break; case 80: { return JetTokens.VAR_KEYWORD ; } - case 137: break; + case 138: break; case 56: { return JetTokens.GTEQ ; } - case 138: break; + case 139: break; case 2: { return JetTokens.INTEGER_LITERAL; } - case 139: break; + case 140: break; case 14: { return JetTokens.RBRACE ; } - case 140: break; + case 141: break; case 98: { return JetTokens.CLASS_KEYWORD ; } - case 141: break; + case 142: break; case 76: { return JetTokens.TRY_KEYWORD ; } - case 142: break; + case 143: break; case 8: { return JetTokens.EXCL ; } - case 143: break; + case 144: break; case 44: { return JetTokens.EXCLEQ ; } - case 144: break; + case 145: break; case 48: { return JetTokens.MINUSEQ ; } - case 145: break; + case 146: break; case 104: { return JetTokens.PACKAGE_KEYWORD ; } - case 146: break; + case 147: break; case 95: { return JetTokens.THROW_KEYWORD ; } - case 147: break; + case 148: break; case 97: { return JetTokens.SUPER_KEYWORD ; } - case 148: break; + case 149: break; + case 69: + { if (commentDepth > 0) { + commentDepth--; + } + else { + int state = yystate(); + popState(); + zzStartRead = commentStart; + return commentStateToTokenType(state); + } + } + case 150: break; case 100: { return JetTokens.WHILE_KEYWORD ; } - case 149: break; + case 151: break; case 46: { return JetTokens.MINUSMINUS; } - case 150: break; + case 152: break; case 105: { return JetTokens.CONTINUE_KEYWORD ; } - case 151: break; + case 153: break; case 73: { return JetTokens.NOT_IN; } - case 152: break; + case 154: break; case 39: { return JetTokens.ATAT ; } - case 153: break; - case 71: - { pushState(DOC_COMMENT); - commentDepth = 0; - commentStart = getTokenStart(); - } - case 154: break; + case 155: break; case 6: { return JetTokens.DIV ; } - case 155: break; - case 65: - { pushState(SHORT_TEMPLATE_ENTRY); - yypushback(yylength() - 1); - return JetTokens.SHORT_TEMPLATE_ENTRY_START; - } case 156: break; case 83: { return JetTokens.IDE_TEMPLATE_END ; @@ -1108,14 +1114,10 @@ class _JetLexer implements FlexLexer { { return JetTokens.QUEST ; } case 160: break; - case 43: - { if (zzCurrentPos == 0) { - return JetTokens.SHEBANG_COMMENT; - } - else { - yypushback(yylength() - 1); - return JetTokens.HASH; - } + case 71: + { pushState(DOC_COMMENT); + commentDepth = 0; + commentStart = getTokenStart(); } case 161: break; case 62: @@ -1142,83 +1144,77 @@ class _JetLexer implements FlexLexer { { return TokenType.BAD_CHARACTER; } case 167: break; + case 65: + { pushState(SHORT_TEMPLATE_ENTRY); + yypushback(yylength() - 1); + return JetTokens.SHORT_TEMPLATE_ENTRY_START; + } + case 168: break; case 72: { return JetTokens.NOT_IS; } - case 168: break; + case 169: break; case 15: { return JetTokens.MUL ; } - case 169: break; + case 170: break; case 24: { return JetTokens.RBRACKET ; } - case 170: break; + case 171: break; case 60: { return JetTokens.PLUSPLUS ; } - case 171: break; - case 87: - { return JetTokens.THIS_KEYWORD ; - } case 172: break; - case 9: - { return JetTokens.DOT ; - } - case 173: break; - case 27: - { return JetTokens.SEMICOLON ; - } - case 174: break; - case 51: - { return JetTokens.IF_KEYWORD ; - } - case 175: break; - case 67: - { return JetTokens.ESCAPE_SEQUENCE; - } - case 176: break; case 41: { pushState(BLOCK_COMMENT); commentDepth = 0; commentStart = getTokenStart(); } + case 173: break; + case 87: + { return JetTokens.THIS_KEYWORD ; + } + case 174: break; + case 9: + { return JetTokens.DOT ; + } + case 175: break; + case 27: + { return JetTokens.SEMICOLON ; + } + case 176: break; + case 51: + { return JetTokens.IF_KEYWORD ; + } case 177: break; + case 67: + { return JetTokens.ESCAPE_SEQUENCE; + } + case 178: break; case 31: { popState(); return JetTokens.CLOSING_QUOTE; } - case 178: break; + case 179: break; case 18: { return JetTokens.EQ ; } - case 179: break; + case 180: break; case 5: { return JetTokens.AT ; } - case 180: break; + case 181: break; case 77: { return JetTokens.AS_SAFE; } - case 181: break; + case 182: break; case 25: { return JetTokens.LPAR ; } - case 182: break; + case 183: break; case 10: { return JetTokens.MINUS ; } - case 183: break; - case 69: - { if (commentDepth > 0) { - commentDepth--; - } - else { - int state = yystate(); - popState(); - zzStartRead = commentStart; - return commentStateToTokenType(state); - } - } case 184: break; case 101: { return JetTokens.FALSE_KEYWORD ; @@ -1288,42 +1284,43 @@ class _JetLexer implements FlexLexer { { return JetTokens.MULTEQ ; } case 201: break; + case 43: + { if (zzCurrentPos == 0) { + return JetTokens.SHEBANG_COMMENT; + } + else { + yypushback(yylength() - 1); + return JetTokens.HASH; + } + } + case 202: break; case 13: { return JetTokens.LBRACE ; } - case 202: break; + case 203: break; case 102: { return JetTokens.OBJECT_KEYWORD ; } - case 203: break; + case 204: break; case 99: { return JetTokens.BREAK_KEYWORD ; } - case 204: break; + case 205: break; case 85: { return JetTokens.BLOCK_COMMENT; } - case 205: break; + case 206: break; case 96: { return JetTokens.TRAIT_KEYWORD ; } - case 206: break; + case 207: break; case 64: { return JetTokens.COLONCOLON; } - case 207: break; + case 208: break; case 33: { } - case 208: break; - case 35: - { if (lBraceCount == 0) { - popState(); - return JetTokens.LONG_TEMPLATE_ENTRY_END; - } - lBraceCount--; - return JetTokens.RBRACE; - } case 209: break; case 7: { return JetTokens.HASH ; diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile2.txt b/compiler/testData/psi/DocCommentAtBeginningOfFile2.txt deleted file mode 100644 index b6686bdc4a1..00000000000 --- a/compiler/testData/psi/DocCommentAtBeginningOfFile2.txt +++ /dev/null @@ -1,4 +0,0 @@ -JetFile: DocCommentAtBeginningOfFile2.jet - PsiComment(DOC_COMMENT)('/**\n/**') - NAMESPACE_HEADER - \ No newline at end of file diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile3.txt b/compiler/testData/psi/DocCommentAtBeginningOfFile3.txt deleted file mode 100644 index 9e62678cdd3..00000000000 --- a/compiler/testData/psi/DocCommentAtBeginningOfFile3.txt +++ /dev/null @@ -1,4 +0,0 @@ -JetFile: DocCommentAtBeginningOfFile3.jet - PsiComment(DOC_COMMENT)('/**\n\nfooo') - NAMESPACE_HEADER - \ No newline at end of file diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile4.txt b/compiler/testData/psi/DocCommentAtBeginningOfFile4.txt deleted file mode 100644 index 3c3a4906909..00000000000 --- a/compiler/testData/psi/DocCommentAtBeginningOfFile4.txt +++ /dev/null @@ -1,4 +0,0 @@ -JetFile: DocCommentAtBeginningOfFile4.jet - PsiComment(DOC_COMMENT)('/**\n\n/**foo*/\n\nasdfas') - NAMESPACE_HEADER - \ No newline at end of file diff --git a/compiler/testData/psi/EOLsInComments.txt b/compiler/testData/psi/EOLsInComments.txt index 6e5482c96d2..22d6429ed4a 100644 --- a/compiler/testData/psi/EOLsInComments.txt +++ b/compiler/testData/psi/EOLsInComments.txt @@ -25,7 +25,10 @@ JetFile: EOLsInComments.jet REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('a') PsiWhiteSpace('\n ') - PsiComment(DOC_COMMENT)('/** */') + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace(' ') + PsiElement(KDOC_END)('*/') PREFIX_EXPRESSION OPERATION_REFERENCE PsiElement(PLUS)('+') @@ -72,7 +75,10 @@ JetFile: EOLsInComments.jet REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('a') PsiWhiteSpace(' ') - PsiComment(DOC_COMMENT)('/**\n */') + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n ') + PsiElement(KDOC_END)('*/') PsiWhiteSpace(' ') OPERATION_REFERENCE PsiElement(PLUS)('+') diff --git a/compiler/testData/psi/NestedComments.txt b/compiler/testData/psi/NestedComments.txt index 59e29c154d8..69704f67b61 100644 --- a/compiler/testData/psi/NestedComments.txt +++ b/compiler/testData/psi/NestedComments.txt @@ -32,17 +32,30 @@ JetFile: NestedComments.jet REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('b') PsiWhiteSpace('\n') - PsiComment(DOC_COMMENT)('/***/') + KDoc + PsiElement(KDOC_START)('/**') + PsiElement(KDOC_END)('*/') PsiWhiteSpace('\n') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('b') PsiWhiteSpace('\n') - PsiComment(DOC_COMMENT)('/** /***/*/') + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('/***/') + PsiElement(KDOC_END)('*/') PsiWhiteSpace('\n') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('b') PsiWhiteSpace('\n') - PsiComment(DOC_COMMENT)('/** /**\n\n*/***/') + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('/**') + PsiWhiteSpace('\n\n') + PsiElement(KDOC_LEADING_ASTERISK)('*') + PsiElement(KDOC_TEXT)('/**') + PsiElement(KDOC_END)('*/') PsiWhiteSpace('\n') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('b') diff --git a/compiler/testData/psi/examples/array/MutableArray.txt b/compiler/testData/psi/examples/array/MutableArray.txt index 9d26293ba66..5f3a7339998 100644 --- a/compiler/testData/psi/examples/array/MutableArray.txt +++ b/compiler/testData/psi/examples/array/MutableArray.txt @@ -1,5 +1,44 @@ JetFile: MutableArray.jet - PsiComment(DOC_COMMENT)('/**\n These declarations are "shallow" in the sense that they are not really compiled, only the type-checker uses them\n*/') + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n ') + PsiElement(KDOC_TEXT)('These') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('declarations') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('are') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('"shallow"') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('in') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('the') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('sense') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('that') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('they') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('are') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('not') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('really') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('compiled,') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('only') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('the') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('type-checker') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('uses') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('them') + PsiWhiteSpace('\n') + PsiElement(KDOC_END)('*/') PsiWhiteSpace('\n\n') NAMESPACE_HEADER diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile1.jet b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile1.jet similarity index 100% rename from compiler/testData/psi/DocCommentAtBeginningOfFile1.jet rename to compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile1.jet diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile1.txt b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile1.txt similarity index 65% rename from compiler/testData/psi/DocCommentAtBeginningOfFile1.txt rename to compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile1.txt index b0c76e51b08..92ddc1091be 100644 --- a/compiler/testData/psi/DocCommentAtBeginningOfFile1.txt +++ b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile1.txt @@ -1,4 +1,5 @@ JetFile: DocCommentAtBeginningOfFile1.jet - PsiComment(DOC_COMMENT)('/**') + KDoc + PsiElement(KDOC_START)('/**') NAMESPACE_HEADER \ No newline at end of file diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile2.jet b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile2.jet similarity index 100% rename from compiler/testData/psi/DocCommentAtBeginningOfFile2.jet rename to compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile2.jet diff --git a/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile2.txt b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile2.txt new file mode 100644 index 00000000000..671a1aee945 --- /dev/null +++ b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile2.txt @@ -0,0 +1,7 @@ +JetFile: DocCommentAtBeginningOfFile2.jet + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n') + PsiElement(KDOC_TEXT)('/**') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile3.jet b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile3.jet similarity index 100% rename from compiler/testData/psi/DocCommentAtBeginningOfFile3.jet rename to compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile3.jet diff --git a/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile3.txt b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile3.txt new file mode 100644 index 00000000000..b52d14d6751 --- /dev/null +++ b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile3.txt @@ -0,0 +1,7 @@ +JetFile: DocCommentAtBeginningOfFile3.jet + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n\n') + PsiElement(KDOC_TEXT)('fooo') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile4.jet b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile4.jet similarity index 100% rename from compiler/testData/psi/DocCommentAtBeginningOfFile4.jet rename to compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile4.jet diff --git a/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile4.txt b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile4.txt new file mode 100644 index 00000000000..448c37b71ec --- /dev/null +++ b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile4.txt @@ -0,0 +1,9 @@ +JetFile: DocCommentAtBeginningOfFile4.jet + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n\n') + PsiElement(KDOC_TEXT)('/**foo*/') + PsiWhiteSpace('\n\n') + PsiElement(KDOC_TEXT)('asdfas') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/EndOnLeadingAsterisks.kt b/compiler/testData/psi/kdoc/EndOnLeadingAsterisks.kt new file mode 100644 index 00000000000..a33dbe069c4 --- /dev/null +++ b/compiler/testData/psi/kdoc/EndOnLeadingAsterisks.kt @@ -0,0 +1,2 @@ +/** + */ \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/EndOnLeadingAsterisks.txt b/compiler/testData/psi/kdoc/EndOnLeadingAsterisks.txt new file mode 100644 index 00000000000..ae11f8e6eaf --- /dev/null +++ b/compiler/testData/psi/kdoc/EndOnLeadingAsterisks.txt @@ -0,0 +1,7 @@ +JetFile: EndOnLeadingAsterisks.kt + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n ') + PsiElement(KDOC_END)('*/') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/EndRightAfterText.kt b/compiler/testData/psi/kdoc/EndRightAfterText.kt new file mode 100644 index 00000000000..ccbbe6b06a8 --- /dev/null +++ b/compiler/testData/psi/kdoc/EndRightAfterText.kt @@ -0,0 +1 @@ +/**text*/ \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/EndRightAfterText.txt b/compiler/testData/psi/kdoc/EndRightAfterText.txt new file mode 100644 index 00000000000..77d84b91e6c --- /dev/null +++ b/compiler/testData/psi/kdoc/EndRightAfterText.txt @@ -0,0 +1,7 @@ +JetFile: EndRightAfterText.kt + KDoc + PsiElement(KDOC_START)('/**') + PsiElement(KDOC_TEXT)('text') + PsiElement(KDOC_END)('*/') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/Incomplete.kt b/compiler/testData/psi/kdoc/Incomplete.kt new file mode 100644 index 00000000000..cd45fbeed1d --- /dev/null +++ b/compiler/testData/psi/kdoc/Incomplete.kt @@ -0,0 +1,2 @@ +/** + contents \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/Incomplete.txt b/compiler/testData/psi/kdoc/Incomplete.txt new file mode 100644 index 00000000000..349ed596f2f --- /dev/null +++ b/compiler/testData/psi/kdoc/Incomplete.txt @@ -0,0 +1,7 @@ +JetFile: Incomplete.kt + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n ') + PsiElement(KDOC_TEXT)('contents') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/Simple.kt b/compiler/testData/psi/kdoc/Simple.kt new file mode 100644 index 00000000000..af292d07506 --- /dev/null +++ b/compiler/testData/psi/kdoc/Simple.kt @@ -0,0 +1,7 @@ + /** line 0 + line 1 // + ** line 2 /* + line 3 /** +* line * 4 + *** line */ 5 + ** line 6 */ \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/Simple.txt b/compiler/testData/psi/kdoc/Simple.txt new file mode 100644 index 00000000000..8b705e5e454 --- /dev/null +++ b/compiler/testData/psi/kdoc/Simple.txt @@ -0,0 +1,52 @@ +JetFile: Simple.kt + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('0') + PsiWhiteSpace('\n ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('1') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('//') + PsiWhiteSpace('\n ') + PsiElement(KDOC_LEADING_ASTERISK)('**') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('2') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('/*') + PsiWhiteSpace('\n ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('3') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('/**') + PsiWhiteSpace('\n') + PsiElement(KDOC_LEADING_ASTERISK)('*') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('*') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('4') + PsiWhiteSpace('\n ') + PsiElement(KDOC_LEADING_ASTERISK)('***') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' */') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('5') + PsiWhiteSpace('\n ') + PsiElement(KDOC_LEADING_ASTERISK)('**') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('6') + PsiWhiteSpace(' ') + PsiElement(KDOC_END)('*/') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.kt b/compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.kt new file mode 100644 index 00000000000..fe101cccbd4 --- /dev/null +++ b/compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.kt @@ -0,0 +1,3 @@ +/** +**test + */ \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.txt b/compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.txt new file mode 100644 index 00000000000..4123145ff44 --- /dev/null +++ b/compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.txt @@ -0,0 +1,10 @@ +JetFile: TextRightAfterLeadAsterisks.kt + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n') + PsiElement(KDOC_LEADING_ASTERISK)('**') + PsiElement(KDOC_TEXT)('test') + PsiWhiteSpace('\n ') + PsiElement(KDOC_END)('*/') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java b/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java index 5ab65c1a2e3..c4e8de90ed4 100644 --- a/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java +++ b/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java @@ -139,6 +139,7 @@ public class JetParsingTest extends ParsingTestCase { suite.addTest(JetTestCaseBuilder.suiteForDirectory(prefix, "script", true, factory)); suite.addTest(JetTestCaseBuilder.suiteForDirectory(prefix, "recovery", true, factory)); suite.addTest(JetTestCaseBuilder.suiteForDirectory(prefix, "propertyDelegate", true, factory)); + suite.addTest(JetTestCaseBuilder.suiteForDirectory(prefix, "kdoc", true, factory)); return suite; } diff --git a/idea/src/org/jetbrains/jet/plugin/JetCommenter.java b/idea/src/org/jetbrains/jet/plugin/JetCommenter.java index 2e3d3ba5e1f..c5a11639197 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetCommenter.java +++ b/idea/src/org/jetbrains/jet/plugin/JetCommenter.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.plugin; import com.intellij.lang.CodeDocumentationAwareCommenter; import com.intellij.psi.PsiComment; import com.intellij.psi.tree.IElementType; +import org.jetbrains.jet.kdoc.psi.api.KDoc; import org.jetbrains.jet.lexer.JetTokens; public class JetCommenter implements CodeDocumentationAwareCommenter { @@ -79,6 +80,6 @@ public class JetCommenter implements CodeDocumentationAwareCommenter { @Override public boolean isDocumentationComment(PsiComment element) { - return element.getTokenType().equals(JetTokens.DOC_COMMENT); + return element instanceof KDoc; } }