001    /*
002     * Copyright 2010-2015 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.extapi.psi.ASTWrapperPsiElement;
020    import com.intellij.lang.ASTNode;
021    import com.intellij.lang.LanguageParserDefinitions;
022    import com.intellij.lang.ParserDefinition;
023    import com.intellij.lang.PsiParser;
024    import com.intellij.lexer.Lexer;
025    import com.intellij.openapi.project.Project;
026    import com.intellij.psi.FileViewProvider;
027    import com.intellij.psi.PsiElement;
028    import com.intellij.psi.PsiFile;
029    import com.intellij.psi.tree.IElementType;
030    import com.intellij.psi.tree.IFileElementType;
031    import com.intellij.psi.tree.TokenSet;
032    import org.jetbrains.annotations.NotNull;
033    import org.jetbrains.kotlin.JetNodeType;
034    import org.jetbrains.kotlin.JetNodeTypes;
035    import org.jetbrains.kotlin.idea.JetLanguage;
036    import org.jetbrains.kotlin.kdoc.parser.KDocElementType;
037    import org.jetbrains.kotlin.lexer.JetLexer;
038    import org.jetbrains.kotlin.lexer.JetTokens;
039    import org.jetbrains.kotlin.psi.JetFile;
040    import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementType;
041    import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
042    
043    public class JetParserDefinition implements ParserDefinition {
044        public static final String STD_SCRIPT_SUFFIX = "kts";
045        public static final String STD_SCRIPT_EXT = "." + STD_SCRIPT_SUFFIX;
046    
047        public JetParserDefinition() {
048            //todo: ApplicationManager.getApplication() is null during JetParsingTest setting up
049    
050            /*if (!ApplicationManager.getApplication().isCommandLine()) {
051            }*/
052        }
053    
054        @NotNull
055        public static JetParserDefinition getInstance() {
056            return (JetParserDefinition)LanguageParserDefinitions.INSTANCE.forLanguage(JetLanguage.INSTANCE);
057        }
058    
059        @Override
060        @NotNull
061        public Lexer createLexer(Project project) {
062            return new JetLexer();
063        }
064    
065        @Override
066        public PsiParser createParser(Project project) {
067            return new JetParser(project);
068        }
069    
070        @Override
071        public IFileElementType getFileNodeType() {
072            return JetStubElementTypes.FILE;
073        }
074    
075        @Override
076        @NotNull
077        public TokenSet getWhitespaceTokens() {
078            return JetTokens.WHITESPACES;
079        }
080    
081        @Override
082        @NotNull
083        public TokenSet getCommentTokens() {
084            return JetTokens.COMMENTS;
085        }
086    
087        @Override
088        @NotNull
089        public TokenSet getStringLiteralElements() {
090            return JetTokens.STRINGS;
091        }
092    
093        @Override
094        @NotNull
095        public PsiElement createElement(ASTNode astNode) {
096            IElementType elementType = astNode.getElementType();
097    
098            if (elementType instanceof JetStubElementType) {
099                return ((JetStubElementType) elementType).createPsiFromAst(astNode);
100            }
101            else if (elementType == JetNodeTypes.TYPE_CODE_FRAGMENT ||
102                     elementType == JetNodeTypes.EXPRESSION_CODE_FRAGMENT  ||
103                     elementType == JetNodeTypes.BLOCK_CODE_FRAGMENT) {
104                return new ASTWrapperPsiElement(astNode);
105            }
106            else if (elementType instanceof KDocElementType) {
107                return ((KDocElementType) elementType).createPsi(astNode);
108            }
109            else {
110                return ((JetNodeType) elementType).createPsi(astNode);
111            }
112        }
113    
114        @Override
115        public PsiFile createFile(FileViewProvider fileViewProvider) {
116            return new JetFile(fileViewProvider, false);
117        }
118    
119        @Override
120        public SpaceRequirements spaceExistanceTypeBetweenTokens(ASTNode astNode, ASTNode astNode1) {
121            return SpaceRequirements.MAY;
122        }
123    }