Renamed JetIdeTemplateExpression to JetIdeTemplate and made not a subtype of JetExpression. Fixed corresponding tests.

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

@@ -162,5 +162,5 @@ public interface JetNodeTypes {
     JetNodeType NAMESPACE_HEADER = new JetNodeType("NAMESPACE_HEADER", JetNamespaceHeader.class);
     JetNodeType SCRIPT = new JetNodeType("SCRIPT", JetScript.class);
 
-    JetNodeType IDE_TEMPLATE_EXPRESSION   = new JetNodeType("IDE_TEMPLATE_EXPRESSION", JetIdeTemplateExpression.class);
+    JetNodeType IDE_TEMPLATE_EXPRESSION   = new JetNodeType("IDE_TEMPLATE_EXPRESSION", JetIdeTemplate.class);
 }

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

@@ -26,19 +26,19 @@ import org.jetbrains.jet.lexer.JetTokens;
  * @author Evgeny Gerashchenko
  * @since 2/8/12
  */
-public class JetIdeTemplateExpression extends JetExpressionImpl {
+public class JetIdeTemplate extends JetElementImpl {
-    public JetIdeTemplateExpression(@NotNull ASTNode node) {
+    public JetIdeTemplate(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
     public void accept(@NotNull JetVisitorVoid visitor) {
-        visitor.visitIdeTemplateExpression(this);
+        visitor.visitIdeTemplate(this);
     }
 
     @Override
     public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
-        return visitor.visitIdeTemplateExpression(this, data);
+        return visitor.visitIdeTemplate(this, data);
     }
 
     @Nullable

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

@@ -276,7 +276,7 @@ public class JetVisitor<R, D> extends PsiElementVisitor {
         return visitExpression(expression, data);
     }
 
-    public R visitIdeTemplateExpression(JetIdeTemplateExpression expression, D data) {
+    public R visitIdeTemplate(JetIdeTemplate expression, D data) {
         return null;
     }
 

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

@@ -274,7 +274,7 @@ public class JetVisitorVoid extends PsiElementVisitor {
         visitExpression(expression);
     }
 
-    public void visitIdeTemplateExpression(JetIdeTemplateExpression expression) {
+    public void visitIdeTemplate(JetIdeTemplate expression) {
     }
 
     public void visitCatchSection(JetCatchClause catchClause) {

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java

@@ -279,6 +279,9 @@ public class ExpressionTypingServices {
         JetTypeInfo result = JetTypeInfo.create(null, context.dataFlowInfo);
         for (Iterator<? extends JetElement> iterator = block.iterator(); iterator.hasNext(); ) {
             final JetElement statement = iterator.next();
+            if (!(statement instanceof JetExpression)) {
+                continue;
+            }
             trace.record(STATEMENT, statement);
             final JetExpression statementExpression = (JetExpression) statement;
             //TODO constructor assert context.expectedType != FORBIDDEN : ""

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java

@@ -26,7 +26,6 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.DeferredType;
 import org.jetbrains.jet.lang.types.ErrorUtils;
-import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.JetTypeInfo;
 import org.jetbrains.jet.util.lazy.ReenteringLazyValueComputationException;
 
@@ -38,8 +37,8 @@ import static org.jetbrains.jet.lang.diagnostics.Errors.TYPECHECKER_HAS_RUN_INTO
 public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, ExpressionTypingContext> implements ExpressionTypingInternals {
 
     @Override
-    public JetTypeInfo visitIdeTemplateExpression(JetIdeTemplateExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitIdeTemplate(JetIdeTemplate expression, ExpressionTypingContext data) {
-        return basic.visitIdeTemplateExpression(expression, data);
+        return basic.visitIdeTemplate(expression, data);
     }
 
     @NotNull

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

@@ -34,6 +34,7 @@ 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.JetIdeTemplate;
 import org.jetbrains.jet.lang.psi.JetVisitorVoid;
 
 import java.io.File;
@@ -104,10 +105,11 @@ public class JetParsingTest extends ParsingTestCase {
             if (result == null) {
                 for (Annotation annotation : method.getDeclaredAnnotations()) {
                     if (annotation instanceof IfNotParsed) {
-                        assertNotNull(
+                        assertTrue(
                                 "Incomplete operation in parsed OK test, method " + methodName +
                                 " in " + declaringClass.getSimpleName() + " returns null. Element text: \n" + elem.getText(),
-                                PsiTreeUtil.findChildOfType(elem, PsiErrorElement.class));
+                                PsiTreeUtil.findChildOfType(elem, PsiErrorElement.class) == null
+                                || PsiTreeUtil.findChildOfType(elem, JetIdeTemplate.class) == null);
                     }
                 }
             }

idea/src/org/jetbrains/jet/plugin/completion/JetTemplateParameterTraversalPolicy.java

@@ -27,7 +27,7 @@ import com.intellij.psi.PsiFile;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetIdeTemplateExpression;
+import org.jetbrains.jet.lang.psi.JetIdeTemplate;
 import org.jetbrains.jet.lexer.JetToken;
 import org.jetbrains.jet.lexer.JetTokens;
 
@@ -38,7 +38,7 @@ import org.jetbrains.jet.lexer.JetTokens;
 public class JetTemplateParameterTraversalPolicy implements TemplateParameterTraversalPolicy {
     @Override
     public boolean isValidForFile(Editor editor, PsiFile file) {
-        return file instanceof JetFile && PsiTreeUtil.findChildOfType(file, JetIdeTemplateExpression.class) != null;
+        return file instanceof JetFile && PsiTreeUtil.findChildOfType(file, JetIdeTemplate.class) != null;
     }
 
     @Override