Parser for JetBlockCodeFragment

compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java

@@ -152,4 +152,5 @@ public interface JetNodeTypes {
 
     IFileElementType TYPE_CODE_FRAGMENT = new JetTypeCodeFragmentType();
     IFileElementType EXPRESSION_CODE_FRAGMENT = new JetExpressionCodeFragmentType();
+    IFileElementType BLOCK_CODE_FRAGMENT = new JetBlockCodeFragmentType();
 }

compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParser.java

@@ -65,4 +65,11 @@ public class JetParser implements PsiParser {
         jetParsing.parseExpressionCodeFragment();
         return psiBuilder.getTreeBuilt();
     }
+
+    @NotNull
+    public static ASTNode parseBlockCodeFragment(PsiBuilder psiBuilder) {
+        JetParsing jetParsing = JetParsing.createForTopLevel(new SemanticWhitespaceAwarePsiBuilderImpl(psiBuilder));
+        jetParsing.parseBlockCodeFragment();
+        return psiBuilder.getTreeBuilt();
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParserDefinition.java

@@ -97,7 +97,9 @@ public class JetParserDefinition implements ParserDefinition {
         if (elementType instanceof JetStubElementType) {
             return ((JetStubElementType) elementType).createPsiFromAst(astNode);
         }
-        else if (elementType == JetNodeTypes.TYPE_CODE_FRAGMENT || elementType == JetNodeTypes.EXPRESSION_CODE_FRAGMENT) {
+        else if (elementType == JetNodeTypes.TYPE_CODE_FRAGMENT ||
+                 elementType == JetNodeTypes.EXPRESSION_CODE_FRAGMENT  ||
+                 elementType == JetNodeTypes.BLOCK_CODE_FRAGMENT) {
             return new ASTWrapperPsiElement(astNode);
         }
         else {

compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParsing.java

@@ -106,10 +106,7 @@ public class JetParsing extends AbstractJetParsing {
         PsiBuilder.Marker marker = mark();
         parseTypeRef();
 
-        while (!eof()) {
+        checkForUnexpectedSymbols();
-            error("unexpected symbol");
-            advance();
-        }
 
         marker.done(TYPE_CODE_FRAGMENT);
     }
@@ -118,14 +115,29 @@ public class JetParsing extends AbstractJetParsing {
         PsiBuilder.Marker marker = mark();
         myExpressionParsing.parseExpression();
 
-        while (!eof()) {
+        checkForUnexpectedSymbols();
-            error("unexpected symbol");
-            advance();
-        }
 
         marker.done(EXPRESSION_CODE_FRAGMENT);
     }
 
+    void parseBlockCodeFragment() {
+        PsiBuilder.Marker marker = mark();
+        PsiBuilder.Marker blockMarker = mark();
+
+        if (at(PACKAGE_KEYWORD) || at(IMPORT_KEYWORD)) {
+            PsiBuilder.Marker err = mark();
+            parsePreamble();
+            err.error("Package directive and imports are forbidden in code fragments");
+        }
+
+        myExpressionParsing.parseStatements();
+
+        checkForUnexpectedSymbols();
+
+        blockMarker.done(BLOCK);
+        marker.done(BLOCK_CODE_FRAGMENT);
+    }
+
     void parseScript() {
         PsiBuilder.Marker fileMarker = mark();
 
@@ -137,11 +149,19 @@ public class JetParsing extends AbstractJetParsing {
 
         myExpressionParsing.parseStatements();
 
+        checkForUnexpectedSymbols();
+
         blockMarker.done(BLOCK);
         scriptMarker.done(SCRIPT);
         fileMarker.done(JET_FILE);
     }
 
+    private void checkForUnexpectedSymbols() {
+        while (!eof()) {
+            errorAndAdvance("unexpected symbol");
+        }
+    }
+
     /*
      *preamble
      *  : packageDirective? import*

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBlockCodeFragment.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2014 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.lang.psi
+
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiElement
+import org.jetbrains.jet.JetNodeTypes
+
+public class JetBlockCodeFragment(
+        project: Project,
+        name: String,
+        text: CharSequence,
+        context: PsiElement?
+) : JetCodeFragment(project, name, text, JetNodeTypes.BLOCK_CODE_FRAGMENT, context) {
+
+    fun getBlock() = findChildByClass(javaClass<JetBlockExpression>()) ?: throw IllegalStateException("Block expression should be parsed for BlockCodeFragment")
+}

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBlockCodeFragmentType.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-2014 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.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.lang.Language;
+import com.intellij.lang.PsiBuilder;
+import com.intellij.lang.PsiBuilderFactory;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.parsing.JetParser;
+import org.jetbrains.jet.lang.psi.stubs.elements.JetFileElementType;
+
+public class JetBlockCodeFragmentType extends JetFileElementType {
+    private static final String NAME = "jet.BLOCK_CODE_FRAGMENT";
+
+    public JetBlockCodeFragmentType() {
+        super(NAME);
+    }
+
+    @NotNull
+    @Override
+    public String getExternalId() {
+        return NAME;
+    }
+
+    @Override
+    protected ASTNode doParseContents(@NotNull ASTNode chameleon, @NotNull PsiElement psi) {
+        Project project = psi.getProject();
+        Language languageForParser = getLanguageForParser(psi);
+        PsiBuilder builder = PsiBuilderFactory.getInstance().createBuilder(project, chameleon, null, languageForParser, chameleon.getChars());
+        return JetParser.parseBlockCodeFragment(builder).getFirstChildNode();
+    }
+}
+

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java

@@ -344,6 +344,11 @@ public class JetPsiFactory {
         return new JetExpressionCodeFragment(project, "fragment.kt", text, context);
     }
 
+    @NotNull
+    public static JetBlockCodeFragment createBlockCodeFragment(Project project, String text, PsiElement context) {
+        return new JetBlockCodeFragment(project, "fragment.kt", text, context);
+    }
+
     @NotNull
     public static JetReturnExpression createReturn(Project project, @NotNull String text) {
         return (JetReturnExpression) createExpression(project, "return " + text);

compiler/testData/parseCodeFragment/block/expressionOnTopLevel.kt

@@ -0,0 +1,2 @@
+val a = 1
+1 + 1

compiler/testData/parseCodeFragment/block/expressionOnTopLevel.txt

@@ -0,0 +1,21 @@
+JetFile: fragment.kt
+  BLOCK
+    PROPERTY
+      PsiElement(val)('val')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')
+    PsiWhiteSpace('\n')
+    BINARY_EXPRESSION
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace(' ')
+      OPERATION_REFERENCE
+        PsiElement(PLUS)('+')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')

compiler/testData/parseCodeFragment/block/imports.kt

@@ -0,0 +1,2 @@
+import a
+val a = 1

compiler/testData/parseCodeFragment/block/imports.txt

@@ -0,0 +1,21 @@
+JetFile: fragment.kt
+  BLOCK
+    PsiErrorElement:Package directive and imports are forbidden in code fragments
+      PACKAGE_DIRECTIVE
+        <empty list>
+      IMPORT_LIST
+        IMPORT_DIRECTIVE
+          PsiElement(import)('import')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+    PsiWhiteSpace('\n')
+    PROPERTY
+      PsiElement(val)('val')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')

compiler/testData/parseCodeFragment/block/localFun.kt

@@ -0,0 +1,2 @@
+fun foo() = 1
+foo()

compiler/testData/parseCodeFragment/block/localFun.txt

@@ -0,0 +1,21 @@
+JetFile: fragment.kt
+  BLOCK
+    FUN
+      PsiElement(fun)('fun')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('foo')
+      VALUE_PARAMETER_LIST
+        PsiElement(LPAR)('(')
+        PsiElement(RPAR)(')')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')
+    PsiWhiteSpace('\n')
+    CALL_EXPRESSION
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
+      VALUE_ARGUMENT_LIST
+        PsiElement(LPAR)('(')
+        PsiElement(RPAR)(')')

compiler/testData/parseCodeFragment/block/oneLine.kt

@@ -0,0 +1 @@
+val a = 1;val b = 2

compiler/testData/parseCodeFragment/block/oneLine.txt

@@ -0,0 +1,21 @@
+JetFile: fragment.kt
+  BLOCK
+    PROPERTY
+      PsiElement(val)('val')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')
+    PsiElement(SEMICOLON)(';')
+    PROPERTY
+      PsiElement(val)('val')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('2')

compiler/testData/parseCodeFragment/block/oneStatement.kt

@@ -0,0 +1 @@
+val a = 1

compiler/testData/parseCodeFragment/block/oneStatement.txt

@@ -0,0 +1,11 @@
+JetFile: fragment.kt
+  BLOCK
+    PROPERTY
+      PsiElement(val)('val')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')

compiler/testData/parseCodeFragment/block/packageAndImport.kt

@@ -0,0 +1,5 @@
+package a
+
+import foo.*
+
+val a = 1

compiler/testData/parseCodeFragment/block/packageAndImport.txt

@@ -0,0 +1,27 @@
+JetFile: fragment.kt
+  BLOCK
+    PsiErrorElement:Package directive and imports are forbidden in code fragments
+      PACKAGE_DIRECTIVE
+        PsiElement(package)('package')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace('\n\n')
+      IMPORT_LIST
+        IMPORT_DIRECTIVE
+          PsiElement(import)('import')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('foo')
+          PsiElement(DOT)('.')
+          PsiElement(MUL)('*')
+    PsiWhiteSpace('\n\n')
+    PROPERTY
+      PsiElement(val)('val')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')

compiler/testData/parseCodeFragment/block/packageDirective.kt

@@ -0,0 +1,2 @@
+package a
+val a = 1

compiler/testData/parseCodeFragment/block/packageDirective.txt

@@ -0,0 +1,18 @@
+JetFile: fragment.kt
+  BLOCK
+    PsiErrorElement:Package directive and imports are forbidden in code fragments
+      PACKAGE_DIRECTIVE
+        PsiElement(package)('package')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+    PsiWhiteSpace('\n')
+    PROPERTY
+      PsiElement(val)('val')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')

compiler/testData/parseCodeFragment/block/severalExpressions.kt

@@ -0,0 +1,2 @@
+1 + 1
+1 * 1

compiler/testData/parseCodeFragment/block/severalExpressions.txt

@@ -0,0 +1,21 @@
+JetFile: fragment.kt
+  BLOCK
+    BINARY_EXPRESSION
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace(' ')
+      OPERATION_REFERENCE
+        PsiElement(PLUS)('+')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')
+    PsiWhiteSpace('\n')
+    BINARY_EXPRESSION
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace(' ')
+      OPERATION_REFERENCE
+        PsiElement(MUL)('*')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')

compiler/testData/parseCodeFragment/block/severalStatements.kt

@@ -0,0 +1,2 @@
+val a = 1
+val b = 2

compiler/testData/parseCodeFragment/block/severalStatements.txt

@@ -0,0 +1,21 @@
+JetFile: fragment.kt
+  BLOCK
+    PROPERTY
+      PsiElement(val)('val')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')
+    PsiWhiteSpace('\n')
+    PROPERTY
+      PsiElement(val)('val')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('2')

compiler/testData/parseCodeFragment/block/unexpectedSymbol.kt

@@ -0,0 +1,3 @@
+val a = 1
+}
+val b = 4

compiler/testData/parseCodeFragment/block/unexpectedSymbol.txt

@@ -0,0 +1,26 @@
+JetFile: fragment.kt
+  BLOCK
+    PROPERTY
+      PsiElement(val)('val')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')
+    PsiWhiteSpace('\n')
+    PsiErrorElement:unexpected symbol
+      PsiElement(RBRACE)('}')
+    PsiWhiteSpace('\n')
+    PsiErrorElement:unexpected symbol
+      PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiErrorElement:unexpected symbol
+      PsiElement(IDENTIFIER)('b')
+    PsiWhiteSpace(' ')
+    PsiErrorElement:unexpected symbol
+      PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    PsiErrorElement:unexpected symbol
+      PsiElement(INTEGER_LITERAL)('4')

compiler/testData/parseCodeFragment/expression/error.kt

@@ -0,0 +1 @@
+1 +

compiler/testData/parseCodeFragment/expression/error.txt

@@ -0,0 +1,9 @@
+JetFile: fragment.kt
+  BINARY_EXPRESSION
+    INTEGER_CONSTANT
+      PsiElement(INTEGER_LITERAL)('1')
+    PsiWhiteSpace(' ')
+    OPERATION_REFERENCE
+      PsiElement(PLUS)('+')
+    PsiErrorElement:Expecting an element
+      <empty list>

compiler/testData/parseCodeFragment/expression/simple.kt

@@ -0,0 +1 @@
+1 + 1

compiler/testData/parseCodeFragment/expression/simple.txt

@@ -0,0 +1,10 @@
+JetFile: fragment.kt
+  BINARY_EXPRESSION
+    INTEGER_CONSTANT
+      PsiElement(INTEGER_LITERAL)('1')
+    PsiWhiteSpace(' ')
+    OPERATION_REFERENCE
+      PsiElement(PLUS)('+')
+    PsiWhiteSpace(' ')
+    INTEGER_CONSTANT
+      PsiElement(INTEGER_LITERAL)('1')

compiler/testData/psi/script/unexpectedSymbol.kts

@@ -0,0 +1,2 @@
+println(1)
+}

compiler/testData/psi/script/unexpectedSymbol.txt

@@ -0,0 +1,17 @@
+JetFile: unexpectedSymbol.kts
+  PACKAGE_DIRECTIVE
+    <empty list>
+  SCRIPT
+    BLOCK
+      CALL_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('println')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            INTEGER_CONSTANT
+              PsiElement(INTEGER_LITERAL)('1')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      PsiErrorElement:unexpected symbol
+        PsiElement(RBRACE)('}')

compiler/tests/org/jetbrains/jet/parsing/AbstractJetParsingTest.java

@@ -18,14 +18,18 @@ package org.jetbrains.jet.parsing;
 
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.psi.PsiErrorElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.testFramework.ParsingTestCase;
 import com.intellij.util.PathUtil;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.lang.parsing.JetParserDefinition;
 import org.jetbrains.jet.lang.psi.IfNotParsed;
 import org.jetbrains.jet.lang.psi.JetElement;
+import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.psi.JetVisitorVoid;
 
 import java.lang.annotation.Annotation;
@@ -72,8 +76,20 @@ public abstract class AbstractJetParsingTest extends ParsingTestCase {
     }
 
     protected void doParsingTest(@NotNull String filePath) throws Exception {
+        doBaseTest(filePath, JetNodeTypes.JET_FILE);
+    }
+
+    protected void doExpressionCodeFragmentParsingTest(@NotNull String filePath) throws Exception {
+        doBaseTest(filePath, JetNodeTypes.EXPRESSION_CODE_FRAGMENT);
+    }
+
+    protected void doBlockCodeFragmentParsingTest(@NotNull String filePath) throws Exception {
+        doBaseTest(filePath, JetNodeTypes.BLOCK_CODE_FRAGMENT);
+    }
+
+    private void doBaseTest(@NotNull String filePath, @NotNull IElementType fileType) throws Exception {
         myFileExt = FileUtil.getExtension(PathUtil.getFileName(filePath));
-        myFile = createPsiFile(FileUtil.getNameWithoutExtension(PathUtil.getFileName(filePath)), loadFile(filePath));
+        myFile = createFile(filePath, fileType);
 
         myFile.acceptChildren(new JetVisitorVoid() {
             @Override
@@ -90,4 +106,16 @@ public abstract class AbstractJetParsingTest extends ParsingTestCase {
 
         doCheckResult(myFullDataPath, filePath.replaceAll("\\.kts?", ".txt"), toParseTreeText(myFile, false, false).trim());
     }
+
+    private PsiFile createFile(@NotNull String filePath, @NotNull IElementType fileType) throws Exception {
+        if (fileType == JetNodeTypes.EXPRESSION_CODE_FRAGMENT) {
+            return JetPsiFactory.createExpressionCodeFragment(myProject, loadFile(filePath), null);
+        }
+        else if (fileType == JetNodeTypes.BLOCK_CODE_FRAGMENT) {
+            return JetPsiFactory.createBlockCodeFragment(myProject, loadFile(filePath), null);
+        }
+        else {
+            return createPsiFile(FileUtil.getNameWithoutExtension(PathUtil.getFileName(filePath)), loadFile(filePath));
+        }
+    }
 }

generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt

@@ -139,6 +139,8 @@ fun main(args: Array<String>) {
 
         testClass(javaClass<AbstractJetParsingTest>()) {
             model("psi", testMethod = "doParsingTest", pattern = "^(.*)\\.kts?$")
+            model("parseCodeFragment/expression", testMethod = "doExpressionCodeFragmentParsingTest", extension = "kt")
+            model("parseCodeFragment/block", testMethod = "doBlockCodeFragmentParsingTest", extension = "kt")
         }
 
         GenerateRangesCodegenTestData.main(array<String>())