JET-142 Support string templates

idea/src/org/jetbrains/jet/JetNodeTypes.java

@@ -70,6 +70,12 @@ public interface JetNodeTypes {
     JetNodeType INTEGER_CONSTANT   = new JetNodeType("INTEGER_CONSTANT", JetConstantExpression.class);
     JetNodeType LONG_CONSTANT      = new JetNodeType("LONG_CONSTANT", JetConstantExpression.class);
 
+    JetNodeType STRING_TEMPLATE    = new JetNodeType("STRING_TEMPLATE", JetStringTemplateExpression.class);
+    JetNodeType LONG_STRING_TEMPLATE_ENTRY = new JetNodeType("LONG_STRING_TEMPLATE_ENTRY", JetBlockStringTemplateEntry.class);
+    JetNodeType SHORT_STRING_TEMPLATE_ENTRY = new JetNodeType("SHORT_STRING_TEMPLATE_ENTRY", JetSimpleNameStringTemplateEntry.class);
+    JetNodeType LITERAL_STRING_TEMPLATE_ENTRY = new JetNodeType("LITERAL_STRING_TEMPLATE_ENTRY", JetLiteralStringTemplateEntry.class);
+    JetNodeType ESCAPE_STRING_TEMPLATE_ENTRY = new JetNodeType("ESCAPE_STRING_TEMPLATE_ENTRY", JetEscapeStringTemplateEntry.class);
+
     JetNodeType TUPLE                     = new JetNodeType("TUPLE", JetTupleExpression.class);
     JetNodeType PARENTHESIZED             = new JetNodeType("PARENTHESIZED", JetParenthesizedExpression.class);
     JetNodeType RETURN                    = new JetNodeType("RETURN", JetReturnExpression.class);

idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -488,6 +488,25 @@ public class ExpressionCodegen extends JetVisitor {
         myStack.push(StackValue.constant(expression.getValue(), expressionType(expression)));
     }
 
+    @Override
+    public void visitStringTemplateExpression(JetStringTemplateExpression expression) {
+        final StringBuilder builder = new StringBuilder();
+        for (JetStringTemplateEntry entry : expression.getEntries()) {
+            entry.accept(new JetVisitor() {
+                @Override
+                public void visitStringTemplateEntry(JetStringTemplateEntry entry) {
+                    throw new UnsupportedOperationException("Unsupported string template entry: " + entry); // TODO
+                }
+
+                @Override
+                public void visitLiteralStringTemplateEntry(JetLiteralStringTemplateEntry entry) {
+                    builder.append(entry.getText());
+                }
+            });
+        }
+        myStack.push(StackValue.constant(builder.toString(), expressionType(expression)));
+    }
+
     @Override
     public void visitBlockExpression(JetBlockExpression expression) {
         List<JetElement> statements = expression.getStatements();

idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java

@@ -747,6 +747,17 @@ public class JetControlFlowProcessor {
             }
         }
 
+        @Override
+        public void visitStringTemplateExpression(JetStringTemplateExpression expression) {
+            for (JetStringTemplateEntry entry : expression.getEntries()) {
+                if (entry instanceof JetStringTemplateEntryWithExpression) {
+                    JetStringTemplateEntryWithExpression entryWithExpression = (JetStringTemplateEntryWithExpression) entry;
+                    value(entryWithExpression.getExpression(), true, false);
+                }
+            }
+            builder.read(expression);
+        }
+
         @Override
         public void visitTypeProjection(JetTypeProjection typeProjection) {
             // TODO : Support Type Arguments. Class object may be initialized at this point");

idea/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java

@@ -69,7 +69,9 @@ public class JetExpressionParsing extends AbstractJetParsing {
             IDENTIFIER, // SimpleName
             FIELD_IDENTIFIER, // Field reference
 
-            NAMESPACE_KEYWORD // for absolute qualified names
+            NAMESPACE_KEYWORD, // for absolute qualified names
+
+            OPEN_QUOTE // STRINGS
     );
 
     private static final TokenSet STATEMENT_FIRST = TokenSet.orSet(
@@ -535,12 +537,90 @@ public class JetExpressionParsing extends AbstractJetParsing {
         else if (at(LBRACE)) {
             parseFunctionLiteral();
         }
+        else if (at(OPEN_QUOTE)) {
+            parseStringTemplate();
+        }
         else if (!parseLiteralConstant()) {
             // TODO: better recovery if FIRST(element) did not match
             errorWithRecovery("Expecting an element", EXPRESSION_FOLLOW);
         }
     }
 
+    /*
+     * stringTemplate
+     *   : OPEN_QUOTE stringTemplateElement* CLOSING_QUOTE
+     *   ;
+     */
+    private void parseStringTemplate() {
+        assert _at(OPEN_QUOTE);
+
+        PsiBuilder.Marker template = mark();
+
+        advance(); // OPEN_QUOTE
+
+        while (!eof()) {
+            if (at(CLOSING_QUOTE) || at(DANGLING_NEWLINE)) {
+                break;
+            }
+            parseStringTemplateElement();
+        }
+
+        if (at(DANGLING_NEWLINE)) {
+            errorAndAdvance("Expecting '\"'");
+        }
+        else {
+            expect(CLOSING_QUOTE, "Expecting '\"'");
+        }
+        template.done(STRING_TEMPLATE);
+    }
+
+    /*
+     * stringTemplateElement
+     *   : RegularStringPart
+     *   : ShortTemplateEntry
+     *   : EscapeSequence
+     *   : longTemplate
+     *   ;
+     *
+     * longTemplate
+     *   : "${" expression "}"
+     *   ;
+     */
+    private void parseStringTemplateElement() {
+        if (at(REGULAR_STRING_PART)) {
+            PsiBuilder.Marker mark = mark();
+            advance(); // REGULAR_STRING_PART
+            mark.done(LITERAL_STRING_TEMPLATE_ENTRY);
+        }
+        else if (at(ESCAPE_SEQUENCE)) {
+            PsiBuilder.Marker mark = mark();
+            advance(); // ESCAPE_SEQUENCE
+            mark.done(ESCAPE_STRING_TEMPLATE_ENTRY);
+        }
+        else if (at(SHORT_TEMPLATE_ENTRY)) {
+            PsiBuilder.Marker entry = mark();
+
+            PsiBuilder.Marker reference = mark();
+            advance(); // SHORT_TEMPLATE_ENTRY
+            reference.done(REFERENCE_EXPRESSION);
+
+            entry.done(SHORT_STRING_TEMPLATE_ENTRY);
+        }
+        else if (at(LONG_TEMPLATE_ENTRY_START)) {
+            PsiBuilder.Marker longTemplateEntry = mark();
+
+            advance(); // LONG_TEMPLATE_ENTRY_START
+
+            parseExpression();
+
+            expect(LONG_TEMPLATE_ENTRY_END, "Expecting '}'", TokenSet.create(CLOSING_QUOTE, DANGLING_NEWLINE, REGULAR_STRING_PART, ESCAPE_SEQUENCE, SHORT_TEMPLATE_ENTRY));
+            longTemplateEntry.done(LONG_STRING_TEMPLATE_ENTRY);
+        }
+        else {
+            errorAndAdvance("Unexpected token in a string template");
+        }
+    }
+
     /*
      * literalConstant
      *   : "true" | "false"
@@ -788,6 +868,9 @@ public class JetExpressionParsing extends AbstractJetParsing {
         } else if (at(VAL_KEYWORD)) {
             parseBindingPattern();
             pattern.done(BINDING_PATTERN);
+        } else if (at(OPEN_QUOTE)) {
+            parseStringTemplate();
+            pattern.done(EXPRESSION_PATTERN);
         } else if (parseLiteralConstant()) {
             pattern.done(EXPRESSION_PATTERN);
         } else {

idea/src/org/jetbrains/jet/lang/psi/JetBlockStringTemplateEntry.java

@@ -0,0 +1,18 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public class JetBlockStringTemplateEntry extends JetStringTemplateEntryWithExpression {
+    public JetBlockStringTemplateEntry(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public void accept(@NotNull JetVisitor visitor) {
+        visitor.visitBlockStringTemplateEntry(this);
+    }
+}

idea/src/org/jetbrains/jet/lang/psi/JetConstantExpression.java

@@ -67,6 +67,7 @@ public class JetConstantExpression extends JetExpression {
             return nodeText.charAt(1);
         }
         else if (elementType == JetNodeTypes.STRING_CONSTANT) {
+            if (nodeText.length() == 1) return "";
             int tail = nodeText.length();
             if (nodeText.endsWith("\"")) tail--;
             return nodeText.substring(1, tail);

idea/src/org/jetbrains/jet/lang/psi/JetEscapeStringTemplateEntry.java

@@ -0,0 +1,18 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public class JetEscapeStringTemplateEntry extends JetStringTemplateEntry {
+    public JetEscapeStringTemplateEntry(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public void accept(@NotNull JetVisitor visitor) {
+        visitor.visitEscapeStringTemplateEntry(this);
+    }
+}

idea/src/org/jetbrains/jet/lang/psi/JetLiteralStringTemplateEntry.java

@@ -0,0 +1,18 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public class JetLiteralStringTemplateEntry extends JetStringTemplateEntry {
+    public JetLiteralStringTemplateEntry(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public void accept(@NotNull JetVisitor visitor) {
+        visitor.visitLiteralStringTemplateEntry(this);
+    }
+}

idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java

@@ -29,7 +29,7 @@ import java.util.List;
  * @author max
  */
 public class JetSimpleNameExpression extends JetReferenceExpression {
-    public static final TokenSet REFERENCE_TOKENS = TokenSet.orSet(JetTokens.LABELS, TokenSet.create(JetTokens.IDENTIFIER, JetTokens.FIELD_IDENTIFIER, JetTokens.THIS_KEYWORD));
+    public static final TokenSet REFERENCE_TOKENS = TokenSet.orSet(JetTokens.LABELS, TokenSet.create(JetTokens.IDENTIFIER, JetTokens.FIELD_IDENTIFIER, JetTokens.THIS_KEYWORD, JetTokens.SHORT_TEMPLATE_ENTRY));
 
     public JetSimpleNameExpression(@NotNull ASTNode node) {
         super(node);
@@ -41,7 +41,10 @@ public class JetSimpleNameExpression extends JetReferenceExpression {
         if (referencedNameElement == null) {
             return null;
         }
-        final String text = referencedNameElement.getNode().getText();
+        String text = referencedNameElement.getNode().getText();
+        if (referencedNameElement.getNode().getElementType() == JetTokens.SHORT_TEMPLATE_ENTRY) {
+            text = text.substring(1); // Strip the '$'
+        }
         if (text.startsWith("`") && text.endsWith("`") && text.length() >= 2) {
             return text.substring(1, text.length()-1);
         }

idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameStringTemplateEntry.java

@@ -0,0 +1,20 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.JetNodeTypes;
+
+/**
+ * @author abreslav
+ */
+public class JetSimpleNameStringTemplateEntry extends JetStringTemplateEntryWithExpression
+{
+    public JetSimpleNameStringTemplateEntry(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public void accept(@NotNull JetVisitor visitor) {
+        visitor.visitSimpleNameStringTemplateEntry(this);
+    }
+}

idea/src/org/jetbrains/jet/lang/psi/JetStringTemplateEntry.java

@@ -0,0 +1,20 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * @author abreslav
+ */
+public abstract class JetStringTemplateEntry extends JetElement {
+    public JetStringTemplateEntry(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Nullable
+    public JetExpression getExpression() {
+        return findChildByClass(JetExpression.class);
+    }
+
+}

idea/src/org/jetbrains/jet/lang/psi/JetStringTemplateEntryWithExpression.java

@@ -0,0 +1,18 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public abstract class JetStringTemplateEntryWithExpression extends JetStringTemplateEntry {
+    public JetStringTemplateEntryWithExpression(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public void accept(@NotNull JetVisitor visitor) {
+        visitor.visitStringTemplateEntryWithExpression(this);
+    }
+}

idea/src/org/jetbrains/jet/lang/psi/JetStringTemplateExpression.java

@@ -0,0 +1,23 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public class JetStringTemplateExpression extends JetExpression {
+    public JetStringTemplateExpression(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public void accept(JetVisitor visitor) {
+        visitor.visitStringTemplateExpression(this);
+    }
+
+    @NotNull
+    public JetStringTemplateEntry[] getEntries() {
+        return findChildrenByClass(JetStringTemplateEntry.class);
+    }
+}

idea/src/org/jetbrains/jet/lang/psi/JetVisitor.java

@@ -326,6 +326,10 @@ public class JetVisitor extends PsiElementVisitor {
         visitExpression(expression);
     }
 
+    public void visitStringTemplateExpression(JetStringTemplateExpression expression) {
+        visitExpression(expression);
+    }
+
     public void visitNamedDeclaration(JetNamedDeclaration declaration) {
         visitDeclaration(declaration);
     }
@@ -389,4 +393,28 @@ public class JetVisitor extends PsiElementVisitor {
     public void visitBindingPattern(JetBindingPattern pattern) {
         visitPattern(pattern);
     }
+
+    public void visitStringTemplateEntry(JetStringTemplateEntry entry) {
+        visitJetElement(entry);
+    }
+
+    public void visitStringTemplateEntryWithExpression(JetStringTemplateEntryWithExpression entry) {
+        visitStringTemplateEntry(entry);
+    }
+
+    public void visitBlockStringTemplateEntry(JetBlockStringTemplateEntry entry) {
+        visitStringTemplateEntryWithExpression(entry);
+    }
+
+    public void visitSimpleNameStringTemplateEntry(JetSimpleNameStringTemplateEntry entry) {
+        visitStringTemplateEntryWithExpression(entry);
+    }
+
+    public void visitLiteralStringTemplateEntry(JetLiteralStringTemplateEntry entry) {
+        visitStringTemplateEntry(entry);
+    }
+
+    public void visitEscapeStringTemplateEntry(JetEscapeStringTemplateEntry entry) {
+        visitStringTemplateEntry(entry);
+    }
 }

idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java

@@ -7,6 +7,7 @@ import com.google.common.collect.Sets;
 import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
@@ -865,7 +866,7 @@ public class JetTypeInferrer {
                 }
             }
             else {
-                assert  expression.getReferencedNameElementType() == JetTokens.IDENTIFIER;
+                assert TokenSet.create(JetTokens.IDENTIFIER, JetTokens.SHORT_TEMPLATE_ENTRY).contains(expression.getReferencedNameElementType());
                 if (referencedName != null) {
                     VariableDescriptor variable = context.scope.getVariable(referencedName);
                     if (variable != null) {
@@ -2431,6 +2432,41 @@ public class JetTypeInferrer {
             result = null;
         }
 
+
+        @Override
+        public void visitStringTemplateExpression(JetStringTemplateExpression expression) {
+            for (JetStringTemplateEntry entry : expression.getEntries()) {
+                entry.accept(new JetVisitor() {
+
+                    @Override
+                    public void visitStringTemplateEntryWithExpression(JetStringTemplateEntryWithExpression entry) {
+                        JetExpression entryExpression = entry.getExpression();
+                        if (entryExpression != null) {
+                            getType(context.scope, entryExpression, true);
+                        }
+                    }
+
+                    @Override
+                    public void visitLiteralStringTemplateEntry(JetLiteralStringTemplateEntry entry) {
+                        // Nothing
+                    }
+
+                    @Override
+                    public void visitEscapeStringTemplateEntry(JetEscapeStringTemplateEntry entry) {
+                        // TODO : Check escape
+                        String text = entry.getText();
+                        assert text.length() == 2;
+                        char escaped = text.charAt(1);
+                        Character[] legal = {'n', 'r', 't', 'b', 'f', '$', '\"', '$', '\\'};
+                        if (!Sets.newHashSet(legal).contains(escaped)) {
+                            context.trace.getErrorHandler().genericError(entry.getNode(), "Illegal escape sequence");
+                        }
+                    }
+                });
+            }
+            result = semanticServices.getStandardLibrary().getStringType();
+        }
+
         @Override
         public void visitJetElement(JetElement element) {
             context.trace.getErrorHandler().genericError(element.getNode(), "[JetTypeInferrer] Unsupported element: " + element + " " + element.getClass().getCanonicalName());

idea/src/org/jetbrains/jet/lexer/Jet.flex

@@ -1,6 +1,7 @@
 /* It's an automatically generated code. Do not modify it. */
 package org.jetbrains.jet.lexer;
 
+import java.util.*;
 import com.intellij.lexer.*;
 import com.intellij.psi.*;
 import com.intellij.psi.tree.IElementType;
@@ -12,17 +13,49 @@ import org.jetbrains.jet.lexer.JetTokens;
 %unicode
 %class _JetLexer
 %implements FlexLexer
+
+%{
+    private static final class State {
+        final int lBraceCount;
+        final int state;
+
+        public State(int state, int lBraceCount) {
+            this.state = state;
+            this.lBraceCount = lBraceCount;
+        }
+    }
+
+    private final Stack<State> states = new Stack<State>();
+    private int lBraceCount;
+
+    private void pushState(int state) {
+        states.push(new State(yystate(), lBraceCount));
+        lBraceCount = 0;
+        yybegin(state);
+    }
+
+    private void popState() {
+        State state = states.pop();
+        lBraceCount = state.lBraceCount;
+        yybegin(state.state);
+    }
+%}
+
 %function advance
 %type IElementType
 %eof{  return;
 %eof}
 
+%xstate STRING
+%state LONG_TEMPLATE
+
 DIGIT=[0-9]
 HEX_DIGIT=[0-9A-Fa-f]
 WHITE_SPACE_CHAR=[\ \n\t\f]
 
 // TODO: prohibit '$' in identifiers?
-PLAIN_IDENTIFIER=[:jletter:] [:jletterdigit:]*
+LETTER = [:letter:]|_
+PLAIN_IDENTIFIER={LETTER} ([:digit:]|{LETTER})*
 // TODO: this one MUST allow everything accepted by the runtime
 // TODO: Replace backticks by one backslash in the begining
 ESCAPED_IDENTIFIER = `{PLAIN_IDENTIFIER}`
@@ -68,109 +101,140 @@ ONE_TWO_QUO = (\"[^\"]) | (\"\"[^\"])
 QUO_STRING_CHAR = [^\"] | {ONE_TWO_QUO}
 RAW_STRING_LITERAL = {THREE_QUO} {QUO_STRING_CHAR}* {THREE_QUO}?
 
+REGULAR_STRING_PART=[^\\\"\n\$]+
+SHORT_TEMPLATE_ENTRY=\${IDENTIFIER}
+LONELY_DOLLAR=\$
+LONG_TEMPLATE_ENTRY_START=\$\{
+LONG_TEMPLATE_ENTRY_END=\}
+
 %%
 
-<YYINITIAL> {BLOCK_COMMENT} { return JetTokens.BLOCK_COMMENT; }
-<YYINITIAL> {DOC_COMMENT} { return JetTokens.DOC_COMMENT; }
+// String templates
 
-<YYINITIAL> ({WHITE_SPACE_CHAR})+ { return JetTokens.WHITE_SPACE; }
+\"                                     { pushState(STRING); return JetTokens.OPEN_QUOTE; }
 
-<YYINITIAL> {EOL_COMMENT} { return JetTokens.EOL_COMMENT; }
+<STRING> \"                            { popState(); return JetTokens.CLOSING_QUOTE; }
+<STRING> \n                            { popState(); yypushback(1); return JetTokens.DANGLING_NEWLINE; }
+<STRING> {REGULAR_STRING_PART}         { return JetTokens.REGULAR_STRING_PART; }
+<STRING> {ESCAPE_SEQUENCE}             { return JetTokens.ESCAPE_SEQUENCE; }
+<STRING> {SHORT_TEMPLATE_ENTRY}        { return JetTokens.SHORT_TEMPLATE_ENTRY; }
+<STRING> {LONELY_DOLLAR}               { return JetTokens.REGULAR_STRING_PART; }
+<STRING> {LONG_TEMPLATE_ENTRY_START}   { pushState(LONG_TEMPLATE); return JetTokens.LONG_TEMPLATE_ENTRY_START; }
 
-<YYINITIAL> {INTEGER_LITERAL}\.\. { yypushback(2); return JetTokens.INTEGER_LITERAL; }
-<YYINITIAL> {INTEGER_LITERAL} { return JetTokens.INTEGER_LITERAL; }
-//<YYINITIAL> {LONG_LITERAL} { return JetTokens.LONG_LITERAL; }
+<LONG_TEMPLATE> "{"                    { lBraceCount++; return JetTokens.LBRACE; }
+<LONG_TEMPLATE> "}"                    {
+                                           if (lBraceCount == 0) {
+                                             popState();
+                                             return JetTokens.LONG_TEMPLATE_ENTRY_END;
+                                           }
+                                           lBraceCount--;
+                                           return JetTokens.RBRACE;
+                                       }
 
-//<YYINITIAL> {FLOAT_LITERAL}      { return JetTokens.FLOAT_LITERAL; }
-//<YYINITIAL> {HEX_FLOAT_LITERAL}  { return JetTokens.FLOAT_LITERAL; }
-<YYINITIAL> {DOUBLE_LITERAL}     { return JetTokens.FLOAT_LITERAL; }
-<YYINITIAL> {HEX_DOUBLE_LITERAL} { return JetTokens.FLOAT_LITERAL; }
+// Mere mortals
+
+{BLOCK_COMMENT} { return JetTokens.BLOCK_COMMENT; }
+{DOC_COMMENT} { return JetTokens.DOC_COMMENT; }
+
+({WHITE_SPACE_CHAR})+ { return JetTokens.WHITE_SPACE; }
+
+{EOL_COMMENT} { return JetTokens.EOL_COMMENT; }
+
+{INTEGER_LITERAL}\.\. { yypushback(2); return JetTokens.INTEGER_LITERAL; }
+{INTEGER_LITERAL} { return JetTokens.INTEGER_LITERAL; }
+//{LONG_LITERAL} { return JetTokens.LONG_LITERAL; }
+
+//{FLOAT_LITERAL}      { return JetTokens.FLOAT_LITERAL; }
+//{HEX_FLOAT_LITERAL}  { return JetTokens.FLOAT_LITERAL; }
+{DOUBLE_LITERAL}     { return JetTokens.FLOAT_LITERAL; }
+{HEX_DOUBLE_LITERAL} { return JetTokens.FLOAT_LITERAL; }
+
+{CHARACTER_LITERAL} { return JetTokens.CHARACTER_LITERAL; }
+//{STRING_LITERAL} { return JetTokens.STRING_LITERAL; }
 
-<YYINITIAL> {CHARACTER_LITERAL} { return JetTokens.CHARACTER_LITERAL; }
-<YYINITIAL> {STRING_LITERAL} { return JetTokens.STRING_LITERAL; }
 // TODO: Decide what to do with """ ... """"
-<YYINITIAL> {RAW_STRING_LITERAL} { return JetTokens.RAW_STRING_LITERAL; }
+{RAW_STRING_LITERAL} { return JetTokens.RAW_STRING_LITERAL; }
 
-<YYINITIAL> "namespace"  { return JetTokens.NAMESPACE_KEYWORD ;}
-<YYINITIAL> "continue"   { return JetTokens.CONTINUE_KEYWORD ;}
-<YYINITIAL> "return"     { return JetTokens.RETURN_KEYWORD ;}
-<YYINITIAL> "object"     { return JetTokens.OBJECT_KEYWORD ;}
-<YYINITIAL> "while"      { return JetTokens.WHILE_KEYWORD ;}
-<YYINITIAL> "break"      { return JetTokens.BREAK_KEYWORD ;}
-<YYINITIAL> "class"      { return JetTokens.CLASS_KEYWORD ;}
-<YYINITIAL> "throw"      { return JetTokens.THROW_KEYWORD ;}
-<YYINITIAL> "false"      { return JetTokens.FALSE_KEYWORD ;}
-<YYINITIAL> "when"       { return JetTokens.WHEN_KEYWORD ;}
-<YYINITIAL> "true"       { return JetTokens.TRUE_KEYWORD ;}
-<YYINITIAL> "type"       { return JetTokens.TYPE_KEYWORD ;}
-<YYINITIAL> "this"       { return JetTokens.THIS_KEYWORD ;}
-<YYINITIAL> "null"       { return JetTokens.NULL_KEYWORD ;}
-<YYINITIAL> "else"       { return JetTokens.ELSE_KEYWORD ;}
-<YYINITIAL> "This"       { return JetTokens.CAPITALIZED_THIS_KEYWORD ;}
-<YYINITIAL> "try"        { return JetTokens.TRY_KEYWORD ;}
-<YYINITIAL> "val"        { return JetTokens.VAL_KEYWORD ;}
-<YYINITIAL> "var"        { return JetTokens.VAR_KEYWORD ;}
-<YYINITIAL> "fun"        { return JetTokens.FUN_KEYWORD ;}
-<YYINITIAL> "for"        { return JetTokens.FOR_KEYWORD ;}
-//<YYINITIAL> "new"        { return JetTokens.NEW_KEYWORD ;}
-<YYINITIAL> "is"         { return JetTokens.IS_KEYWORD ;}
-<YYINITIAL> "in"         { return JetTokens.IN_KEYWORD ;}
-<YYINITIAL> "if"         { return JetTokens.IF_KEYWORD ;}
-<YYINITIAL> "do"         { return JetTokens.DO_KEYWORD ;}
-<YYINITIAL> "as"         { return JetTokens.AS_KEYWORD ;}
+"namespace"  { return JetTokens.NAMESPACE_KEYWORD ;}
+"continue"   { return JetTokens.CONTINUE_KEYWORD ;}
+"return"     { return JetTokens.RETURN_KEYWORD ;}
+"object"     { return JetTokens.OBJECT_KEYWORD ;}
+"while"      { return JetTokens.WHILE_KEYWORD ;}
+"break"      { return JetTokens.BREAK_KEYWORD ;}
+"class"      { return JetTokens.CLASS_KEYWORD ;}
+"throw"      { return JetTokens.THROW_KEYWORD ;}
+"false"      { return JetTokens.FALSE_KEYWORD ;}
+"when"       { return JetTokens.WHEN_KEYWORD ;}
+"true"       { return JetTokens.TRUE_KEYWORD ;}
+"type"       { return JetTokens.TYPE_KEYWORD ;}
+"this"       { return JetTokens.THIS_KEYWORD ;}
+"null"       { return JetTokens.NULL_KEYWORD ;}
+"else"       { return JetTokens.ELSE_KEYWORD ;}
+"This"       { return JetTokens.CAPITALIZED_THIS_KEYWORD ;}
+"try"        { return JetTokens.TRY_KEYWORD ;}
+"val"        { return JetTokens.VAL_KEYWORD ;}
+"var"        { return JetTokens.VAR_KEYWORD ;}
+"fun"        { return JetTokens.FUN_KEYWORD ;}
+"for"        { return JetTokens.FOR_KEYWORD ;}
+//"new"        { return JetTokens.NEW_KEYWORD ;}
+"is"         { return JetTokens.IS_KEYWORD ;}
+"in"         { return JetTokens.IN_KEYWORD ;}
+"if"         { return JetTokens.IF_KEYWORD ;}
+"do"         { return JetTokens.DO_KEYWORD ;}
+"as"         { return JetTokens.AS_KEYWORD ;}
 
-<YYINITIAL> {FIELD_IDENTIFIER} { return JetTokens.FIELD_IDENTIFIER; }
-<YYINITIAL> {IDENTIFIER} { return JetTokens.IDENTIFIER; }
-<YYINITIAL> {LABEL_IDENTIFIER}   { return JetTokens.LABEL_IDENTIFIER; }
+{FIELD_IDENTIFIER} { return JetTokens.FIELD_IDENTIFIER; }
+{IDENTIFIER} { return JetTokens.IDENTIFIER; }
+{LABEL_IDENTIFIER}   { return JetTokens.LABEL_IDENTIFIER; }
 
-<YYINITIAL> "==="        { return JetTokens.EQEQEQ    ; }
-<YYINITIAL> "!=="        { return JetTokens.EXCLEQEQEQ; }
-<YYINITIAL> "!in"        { return JetTokens.NOT_IN; }
-<YYINITIAL> "!is"        { return JetTokens.NOT_IS; }
-<YYINITIAL> "as?"        { return JetTokens.AS_SAFE; }
-<YYINITIAL> "++"         { return JetTokens.PLUSPLUS  ; }
-<YYINITIAL> "--"         { return JetTokens.MINUSMINUS; }
-<YYINITIAL> "<="         { return JetTokens.LTEQ      ; }
-<YYINITIAL> ">="         { return JetTokens.GTEQ      ; }
-<YYINITIAL> "=="         { return JetTokens.EQEQ      ; }
-<YYINITIAL> "!="         { return JetTokens.EXCLEQ    ; }
-<YYINITIAL> "&&"         { return JetTokens.ANDAND    ; }
-<YYINITIAL> "||"         { return JetTokens.OROR      ; }
-<YYINITIAL> "?."         { return JetTokens.SAFE_ACCESS;}
-<YYINITIAL> "?:"         { return JetTokens.ELVIS     ; }
-//<YYINITIAL> ".*"         { return JetTokens.MAP       ; }
-//<YYINITIAL> ".?"         { return JetTokens.FILTER    ; }
-<YYINITIAL> "*="         { return JetTokens.MULTEQ    ; }
-<YYINITIAL> "/="         { return JetTokens.DIVEQ     ; }
-<YYINITIAL> "%="         { return JetTokens.PERCEQ    ; }
-<YYINITIAL> "+="         { return JetTokens.PLUSEQ    ; }
-<YYINITIAL> "-="         { return JetTokens.MINUSEQ   ; }
-<YYINITIAL> "->"         { return JetTokens.ARROW     ; }
-<YYINITIAL> "=>"         { return JetTokens.DOUBLE_ARROW; }
-<YYINITIAL> ".."         { return JetTokens.RANGE     ; }
-<YYINITIAL> "@@"         { return JetTokens.ATAT      ; }
-<YYINITIAL> "["          { return JetTokens.LBRACKET  ; }
-<YYINITIAL> "]"          { return JetTokens.RBRACKET  ; }
-<YYINITIAL> "{"          { return JetTokens.LBRACE    ; }
-<YYINITIAL> "}"          { return JetTokens.RBRACE    ; }
-<YYINITIAL> "("          { return JetTokens.LPAR      ; }
-<YYINITIAL> ")"          { return JetTokens.RPAR      ; }
-<YYINITIAL> "."          { return JetTokens.DOT       ; }
-<YYINITIAL> "*"          { return JetTokens.MUL       ; }
-<YYINITIAL> "+"          { return JetTokens.PLUS      ; }
-<YYINITIAL> "-"          { return JetTokens.MINUS     ; }
-<YYINITIAL> "!"          { return JetTokens.EXCL      ; }
-<YYINITIAL> "/"          { return JetTokens.DIV       ; }
-<YYINITIAL> "%"          { return JetTokens.PERC      ; }
-<YYINITIAL> "<"          { return JetTokens.LT        ; }
-<YYINITIAL> ">"          { return JetTokens.GT        ; }
-<YYINITIAL> "?"          { return JetTokens.QUEST     ; }
-<YYINITIAL> ":"          { return JetTokens.COLON     ; }
-<YYINITIAL> ";"          { return JetTokens.SEMICOLON ; }
-<YYINITIAL> "="          { return JetTokens.EQ        ; }
-<YYINITIAL> ","          { return JetTokens.COMMA     ; }
-<YYINITIAL> "#"          { return JetTokens.HASH      ; }
-<YYINITIAL> "@"          { return JetTokens.AT        ; }
+"==="        { return JetTokens.EQEQEQ    ; }
+"!=="        { return JetTokens.EXCLEQEQEQ; }
+"!in"        { return JetTokens.NOT_IN; }
+"!is"        { return JetTokens.NOT_IS; }
+"as?"        { return JetTokens.AS_SAFE; }
+"++"         { return JetTokens.PLUSPLUS  ; }
+"--"         { return JetTokens.MINUSMINUS; }
+"<="         { return JetTokens.LTEQ      ; }
+">="         { return JetTokens.GTEQ      ; }
+"=="         { return JetTokens.EQEQ      ; }
+"!="         { return JetTokens.EXCLEQ    ; }
+"&&"         { return JetTokens.ANDAND    ; }
+"||"         { return JetTokens.OROR      ; }
+"?."         { return JetTokens.SAFE_ACCESS;}
+"?:"         { return JetTokens.ELVIS     ; }
+//".*"         { return JetTokens.MAP       ; }
+//".?"         { return JetTokens.FILTER    ; }
+"*="         { return JetTokens.MULTEQ    ; }
+"/="         { return JetTokens.DIVEQ     ; }
+"%="         { return JetTokens.PERCEQ    ; }
+"+="         { return JetTokens.PLUSEQ    ; }
+"-="         { return JetTokens.MINUSEQ   ; }
+"->"         { return JetTokens.ARROW     ; }
+"=>"         { return JetTokens.DOUBLE_ARROW; }
+".."         { return JetTokens.RANGE     ; }
+"@@"         { return JetTokens.ATAT      ; }
+"["          { return JetTokens.LBRACKET  ; }
+"]"          { return JetTokens.RBRACKET  ; }
+"{"          { return JetTokens.LBRACE    ; }
+"}"          { return JetTokens.RBRACE    ; }
+"("          { return JetTokens.LPAR      ; }
+")"          { return JetTokens.RPAR      ; }
+"."          { return JetTokens.DOT       ; }
+"*"          { return JetTokens.MUL       ; }
+"+"          { return JetTokens.PLUS      ; }
+"-"          { return JetTokens.MINUS     ; }
+"!"          { return JetTokens.EXCL      ; }
+"/"          { return JetTokens.DIV       ; }
+"%"          { return JetTokens.PERC      ; }
+"<"          { return JetTokens.LT        ; }
+">"          { return JetTokens.GT        ; }
+"?"          { return JetTokens.QUEST     ; }
+":"          { return JetTokens.COLON     ; }
+";"          { return JetTokens.SEMICOLON ; }
+"="          { return JetTokens.EQ        ; }
+","          { return JetTokens.COMMA     ; }
+"#"          { return JetTokens.HASH      ; }
+"@"          { return JetTokens.AT        ; }
 
-<YYINITIAL> . { return TokenType.BAD_CHARACTER; }
+. { return TokenType.BAD_CHARACTER; }
 

idea/src/org/jetbrains/jet/lexer/JetTokens.java

@@ -21,6 +21,16 @@ public interface JetTokens {
     JetToken FLOAT_LITERAL      = new JetToken("FLOAT_CONSTANT");
     JetToken CHARACTER_LITERAL  = new JetToken("CHARACTER_LITERAL");
     JetToken STRING_LITERAL     = new JetToken("STRING_LITERAL");
+
+    JetToken CLOSING_QUOTE = new JetToken("CLOSING_QUOTE");
+    JetToken OPEN_QUOTE = new JetToken("OPEN_QUOTE");
+    JetToken REGULAR_STRING_PART = new JetToken("REGULAR_STRING_PART");
+    JetToken SHORT_TEMPLATE_ENTRY = new JetToken("SHORT_TEMPLATE_ENTRY");
+    JetToken ESCAPE_SEQUENCE = new JetToken("ESCAPE_SEQUENCE");
+    JetToken LONG_TEMPLATE_ENTRY_START = new JetToken("LONG_TEMPLATE_ENTRY_START");
+    JetToken LONG_TEMPLATE_ENTRY_END = new JetToken("LONG_TEMPLATE_ENTRY_END");
+    JetToken DANGLING_NEWLINE = new JetToken("DANGLING_NEWLINE");
+
     JetToken RAW_STRING_LITERAL = new JetToken("RAW_STRING_LITERAL");
 
     JetKeywordToken NAMESPACE_KEYWORD        = JetKeywordToken.keyword("namespace");

idea/src/org/jetbrains/jet/plugin/JetHighlighter.java

@@ -61,10 +61,20 @@ public class JetHighlighter extends SyntaxHighlighterBase {
                                                  SyntaxHighlighterColors.STRING.getDefaultAttributes()
                                                 );
 
-    private static final TextAttributesKey JET_COMMENT = TextAttributesKey.createTextAttributesKey(
-                                                       "JET.COMMENT",
-                                                       SyntaxHighlighterColors.LINE_COMMENT.getDefaultAttributes()
-                                                     );
+    public static final TextAttributesKey JET_STRING_ESCAPE = TextAttributesKey.createTextAttributesKey(
+                                                 "JET.STRING.ESCAPE",
+                                                 SyntaxHighlighterColors.VALID_STRING_ESCAPE.getDefaultAttributes()
+                                                );
+
+    private static final TextAttributesKey JET_COMMENT;
+    static {
+        TextAttributes attributes = SyntaxHighlighterColors.LINE_COMMENT.getDefaultAttributes().clone();
+        attributes.setFontType(Font.PLAIN);
+        JET_COMMENT = TextAttributesKey.createTextAttributesKey(
+                "JET.COMMENT",
+                attributes
+        );
+    }
 
     private static final TextAttributesKey JET_BAD_CHARACTER = TextAttributesKey.createTextAttributesKey(
                                                     "JET.BADCHARACTER",
@@ -72,6 +82,7 @@ public class JetHighlighter extends SyntaxHighlighterBase {
                                                   );
 
     public static final TextAttributesKey JET_AUTO_CAST_EXPRESSION;
+
     static {
         TextAttributes clone = SyntaxHighlighterColors.STRING.getDefaultAttributes().clone();
         clone.setFontType(Font.PLAIN);
@@ -105,6 +116,14 @@ public class JetHighlighter extends SyntaxHighlighterBase {
         keys1.put(JetTokens.FLOAT_LITERAL, JET_NUMBER);
 
         keys1.put(JetTokens.STRING_LITERAL, JET_STRING);
+        keys1.put(JetTokens.OPEN_QUOTE, JET_STRING);
+        keys1.put(JetTokens.CLOSING_QUOTE, JET_STRING);
+        keys1.put(JetTokens.REGULAR_STRING_PART, JET_STRING);
+        keys1.put(JetTokens.LONG_TEMPLATE_ENTRY_END, JET_STRING_ESCAPE);
+        keys1.put(JetTokens.LONG_TEMPLATE_ENTRY_START, JET_STRING_ESCAPE);
+
+        keys1.put(JetTokens.ESCAPE_SEQUENCE, JET_STRING_ESCAPE);
+
         keys1.put(JetTokens.CHARACTER_LITERAL, JET_STRING);
         keys1.put(JetTokens.RAW_STRING_LITERAL, JET_STRING);
 

idea/testData/checker/StringTemplates.jet

@@ -0,0 +1,21 @@
+fun demo() {
+  val abc = 1
+  val a = ""
+  val asd = 1
+  val bar = 5
+  fun map(f : fun () : Any?) : Int  = 1
+  fun buzz(f : fun () : Any?) : Int  = 1
+  val sdf = 1
+  val foo = 3;
+    "$abc"
+    "$"
+    "$.$.asdf$\t"
+    "asd\$"
+    "asd$a<error>\x</error>"
+    "asd$a$asd$ <error>$xxx</error>"
+    "fosdfasdo${1 + bar + 100}}sdsdfgdsfsdf"
+    "foo${bar + map {foo}}sdfsdf"
+    "foo${bar + map { "foo" }}sdfsdf"
+    "foo${bar + map {
+      "foo$sdf${ buzz{}}" }}sdfsdf"
+}

idea/testData/psi/SimpleExpressions.txt

@@ -84,8 +84,11 @@ JetFile: SimpleExpressions.jet
           PsiWhiteSpace(' ')
           PsiElement(EQ)('=')
           PsiWhiteSpace(' ')
-          STRING_CONSTANT
-            PsiElement(STRING_LITERAL)('"dsf"')
+          STRING_TEMPLATE
+            PsiElement(OPEN_QUOTE)('"')
+            LITERAL_STRING_TEMPLATE_ENTRY
+              PsiElement(REGULAR_STRING_PART)('dsf')
+            PsiElement(CLOSING_QUOTE)('"')
         PsiElement(COMMA)(',')
         PsiWhiteSpace('\n    ')
         VALUE_PARAMETER
@@ -325,8 +328,11 @@ JetFile: SimpleExpressions.jet
               PsiElement(INTEGER_LITERAL)('10')
             PsiElement(COMMA)(',')
             PsiWhiteSpace(' ')
-            STRING_CONSTANT
-              PsiElement(STRING_LITERAL)('"A"')
+            STRING_TEMPLATE
+              PsiElement(OPEN_QUOTE)('"')
+              LITERAL_STRING_TEMPLATE_ENTRY
+                PsiElement(REGULAR_STRING_PART)('A')
+              PsiElement(CLOSING_QUOTE)('"')
             PsiElement(COMMA)(',')
             PsiWhiteSpace(' ')
             INTEGER_CONSTANT

idea/testData/psi/StringTemplates.jet

@@ -0,0 +1,22 @@
+fun demo() {
+  val abc = 1
+  val a = ""
+  val asd = 1
+  val bar = 5
+  fun map(f : fun () : Any?) : Int  = 1
+  fun buzz(f : fun () : Any?) : Int  = 1
+  val sdf = 1
+  val foo = 3;
+    "$abc"
+    "$abc\"
+    "$"
+    "$.$.asdf$\t"
+    "asd\$"
+    "asd$a"
+    "asd$a$asd$"
+    "fosdfasdo${1 + bar + 100}}sdsdfgdsfsdf"
+    "foo${bar + map {foo}}sdfsdf"
+    "foo${bar + map { "foo" }}sdfsdf"
+    "foo${bar + map {
+      "foo$sdf${ buzz{}}" }}sdfsdf"
+}

idea/testData/psi/StringTemplates.txt

@@ -0,0 +1,368 @@
+JetFile: StringTemplates.jet
+  NAMESPACE
+    FUN
+      PsiElement(fun)('fun')
+      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('demo')
+      VALUE_PARAMETER_LIST
+        PsiElement(LPAR)('(')
+        PsiElement(RPAR)(')')
+      PsiWhiteSpace(' ')
+      BLOCK
+        PsiElement(LBRACE)('{')
+        PsiWhiteSpace('\n  ')
+        PROPERTY
+          PsiElement(val)('val')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('abc')
+          PsiWhiteSpace(' ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('1')
+        PsiWhiteSpace('\n  ')
+        PROPERTY
+          PsiElement(val)('val')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('a')
+          PsiWhiteSpace(' ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          STRING_TEMPLATE
+            PsiElement(OPEN_QUOTE)('"')
+            PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace('\n  ')
+        PROPERTY
+          PsiElement(val)('val')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('asd')
+          PsiWhiteSpace(' ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('1')
+        PsiWhiteSpace('\n  ')
+        PROPERTY
+          PsiElement(val)('val')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('bar')
+          PsiWhiteSpace(' ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('5')
+        PsiWhiteSpace('\n  ')
+        FUN
+          PsiElement(fun)('fun')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('map')
+          VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('f')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              TYPE_REFERENCE
+                FUNCTION_TYPE
+                  PsiElement(fun)('fun')
+                  PsiWhiteSpace(' ')
+                  VALUE_PARAMETER_LIST
+                    PsiElement(LPAR)('(')
+                    PsiElement(RPAR)(')')
+                  PsiWhiteSpace(' ')
+                  PsiElement(COLON)(':')
+                  PsiWhiteSpace(' ')
+                  TYPE_REFERENCE
+                    NULLABLE_TYPE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('Any')
+                      PsiElement(QUEST)('?')
+            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(COLON)(':')
+          PsiWhiteSpace(' ')
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Int')
+          PsiWhiteSpace('  ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('1')
+        PsiWhiteSpace('\n  ')
+        FUN
+          PsiElement(fun)('fun')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('buzz')
+          VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('f')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              TYPE_REFERENCE
+                FUNCTION_TYPE
+                  PsiElement(fun)('fun')
+                  PsiWhiteSpace(' ')
+                  VALUE_PARAMETER_LIST
+                    PsiElement(LPAR)('(')
+                    PsiElement(RPAR)(')')
+                  PsiWhiteSpace(' ')
+                  PsiElement(COLON)(':')
+                  PsiWhiteSpace(' ')
+                  TYPE_REFERENCE
+                    NULLABLE_TYPE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('Any')
+                      PsiElement(QUEST)('?')
+            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(COLON)(':')
+          PsiWhiteSpace(' ')
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Int')
+          PsiWhiteSpace('  ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('1')
+        PsiWhiteSpace('\n  ')
+        PROPERTY
+          PsiElement(val)('val')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('sdf')
+          PsiWhiteSpace(' ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('1')
+        PsiWhiteSpace('\n  ')
+        PROPERTY
+          PsiElement(val)('val')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('foo')
+          PsiWhiteSpace(' ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('3')
+        PsiElement(SEMICOLON)(';')
+        PsiWhiteSpace('\n    ')
+        STRING_TEMPLATE
+          PsiElement(OPEN_QUOTE)('"')
+          SHORT_STRING_TEMPLATE_ENTRY
+            REFERENCE_EXPRESSION
+              PsiElement(SHORT_TEMPLATE_ENTRY)('$abc')
+          PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace('\n    ')
+        STRING_TEMPLATE
+          PsiElement(OPEN_QUOTE)('"')
+          SHORT_STRING_TEMPLATE_ENTRY
+            REFERENCE_EXPRESSION
+              PsiElement(SHORT_TEMPLATE_ENTRY)('$abc')
+          ESCAPE_STRING_TEMPLATE_ENTRY
+            PsiElement(ESCAPE_SEQUENCE)('\"')
+          PsiErrorElement:Expecting '"'
+            <empty list>
+        PsiWhiteSpace('\n    ')
+        STRING_TEMPLATE
+          PsiElement(OPEN_QUOTE)('"')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('$')
+          PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace('\n    ')
+        STRING_TEMPLATE
+          PsiElement(OPEN_QUOTE)('"')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('$')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('.')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('$')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('.asdf')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('$')
+          ESCAPE_STRING_TEMPLATE_ENTRY
+            PsiElement(ESCAPE_SEQUENCE)('\t')
+          PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace('\n    ')
+        STRING_TEMPLATE
+          PsiElement(OPEN_QUOTE)('"')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('asd')
+          ESCAPE_STRING_TEMPLATE_ENTRY
+            PsiElement(ESCAPE_SEQUENCE)('\$')
+          PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace('\n    ')
+        STRING_TEMPLATE
+          PsiElement(OPEN_QUOTE)('"')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('asd')
+          SHORT_STRING_TEMPLATE_ENTRY
+            REFERENCE_EXPRESSION
+              PsiElement(SHORT_TEMPLATE_ENTRY)('$a')
+          PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace('\n    ')
+        STRING_TEMPLATE
+          PsiElement(OPEN_QUOTE)('"')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('asd')
+          SHORT_STRING_TEMPLATE_ENTRY
+            REFERENCE_EXPRESSION
+              PsiElement(SHORT_TEMPLATE_ENTRY)('$a')
+          SHORT_STRING_TEMPLATE_ENTRY
+            REFERENCE_EXPRESSION
+              PsiElement(SHORT_TEMPLATE_ENTRY)('$asd')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('$')
+          PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace('\n    ')
+        STRING_TEMPLATE
+          PsiElement(OPEN_QUOTE)('"')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('fosdfasdo')
+          LONG_STRING_TEMPLATE_ENTRY
+            PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
+            BINARY_EXPRESSION
+              BINARY_EXPRESSION
+                INTEGER_CONSTANT
+                  PsiElement(INTEGER_LITERAL)('1')
+                PsiWhiteSpace(' ')
+                OPERATION_REFERENCE
+                  PsiElement(PLUS)('+')
+                PsiWhiteSpace(' ')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('bar')
+              PsiWhiteSpace(' ')
+              OPERATION_REFERENCE
+                PsiElement(PLUS)('+')
+              PsiWhiteSpace(' ')
+              INTEGER_CONSTANT
+                PsiElement(INTEGER_LITERAL)('100')
+            PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('}sdsdfgdsfsdf')
+          PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace('\n    ')
+        STRING_TEMPLATE
+          PsiElement(OPEN_QUOTE)('"')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('foo')
+          LONG_STRING_TEMPLATE_ENTRY
+            PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
+            BINARY_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('bar')
+              PsiWhiteSpace(' ')
+              OPERATION_REFERENCE
+                PsiElement(PLUS)('+')
+              PsiWhiteSpace(' ')
+              CALL_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('map')
+                PsiWhiteSpace(' ')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    BLOCK
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('foo')
+                    PsiElement(RBRACE)('}')
+            PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('sdfsdf')
+          PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace('\n    ')
+        STRING_TEMPLATE
+          PsiElement(OPEN_QUOTE)('"')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('foo')
+          LONG_STRING_TEMPLATE_ENTRY
+            PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
+            BINARY_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('bar')
+              PsiWhiteSpace(' ')
+              OPERATION_REFERENCE
+                PsiElement(PLUS)('+')
+              PsiWhiteSpace(' ')
+              CALL_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('map')
+                PsiWhiteSpace(' ')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace(' ')
+                    BLOCK
+                      STRING_TEMPLATE
+                        PsiElement(OPEN_QUOTE)('"')
+                        LITERAL_STRING_TEMPLATE_ENTRY
+                          PsiElement(REGULAR_STRING_PART)('foo')
+                        PsiElement(CLOSING_QUOTE)('"')
+                    PsiWhiteSpace(' ')
+                    PsiElement(RBRACE)('}')
+            PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('sdfsdf')
+          PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace('\n    ')
+        STRING_TEMPLATE
+          PsiElement(OPEN_QUOTE)('"')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('foo')
+          LONG_STRING_TEMPLATE_ENTRY
+            PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
+            BINARY_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('bar')
+              PsiWhiteSpace(' ')
+              OPERATION_REFERENCE
+                PsiElement(PLUS)('+')
+              PsiWhiteSpace(' ')
+              CALL_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('map')
+                PsiWhiteSpace(' ')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace('\n      ')
+                    BLOCK
+                      STRING_TEMPLATE
+                        PsiElement(OPEN_QUOTE)('"')
+                        LITERAL_STRING_TEMPLATE_ENTRY
+                          PsiElement(REGULAR_STRING_PART)('foo')
+                        SHORT_STRING_TEMPLATE_ENTRY
+                          REFERENCE_EXPRESSION
+                            PsiElement(SHORT_TEMPLATE_ENTRY)('$sdf')
+                        LONG_STRING_TEMPLATE_ENTRY
+                          PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
+                          PsiWhiteSpace(' ')
+                          CALL_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('buzz')
+                            FUNCTION_LITERAL_EXPRESSION
+                              FUNCTION_LITERAL
+                                PsiElement(LBRACE)('{')
+                                BLOCK
+                                  <empty list>
+                                PsiElement(RBRACE)('}')
+                          PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
+                        PsiElement(CLOSING_QUOTE)('"')
+                    PsiWhiteSpace(' ')
+                    PsiElement(RBRACE)('}')
+            PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
+          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(REGULAR_STRING_PART)('sdfsdf')
+          PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace('\n')
+        PsiElement(RBRACE)('}')

idea/testData/psi/When.jet

@@ -67,6 +67,6 @@ fun foo() {
     is a @ (a, b) => c
     1, foo(), bar, 2 + 3,
     is a @ (a, b) => c
-    is a.a @ (val b, b) if (b == a + 3) => c
+    is a.a @ (val b, b) => c
   }
 }

idea/testData/psi/When.txt

@@ -243,8 +243,11 @@ JetFile: When.jet
               PsiElement(is)('is')
               PsiWhiteSpace(' ')
               EXPRESSION_PATTERN
-                STRING_CONSTANT
-                  PsiElement(STRING_LITERAL)('"sadfsa"')
+                STRING_TEMPLATE
+                  PsiElement(OPEN_QUOTE)('"')
+                  LITERAL_STRING_TEMPLATE_ENTRY
+                    PsiElement(REGULAR_STRING_PART)('sadfsa')
+                  PsiElement(CLOSING_QUOTE)('"')
             PsiWhiteSpace(' ')
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
@@ -1193,34 +1196,6 @@ JetFile: When.jet
                             PsiElement(IDENTIFIER)('b')
                   PsiElement(RPAR)(')')
             PsiWhiteSpace(' ')
-            PsiErrorElement:Expecting '=>' or 'when'
-              PsiElement(if)('if')
-            PsiWhiteSpace(' ')
-            PARENTHESIZED
-              PsiElement(LPAR)('(')
-              BINARY_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('b')
-                PsiWhiteSpace(' ')
-                OPERATION_REFERENCE
-                  PsiElement(EQEQ)('==')
-                PsiWhiteSpace(' ')
-                BINARY_EXPRESSION
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-                  PsiWhiteSpace(' ')
-                  OPERATION_REFERENCE
-                    PsiElement(PLUS)('+')
-                  PsiWhiteSpace(' ')
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('3')
-              PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          WHEN_ENTRY
-            WHEN_CONDITION_IS_PATTERN
-              EXPRESSION_PATTERN
-                PsiErrorElement:Expecting an element, is-condition or in-condition
-                  <empty list>
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
             REFERENCE_EXPRESSION

idea/testData/psi/examples/BinaryTree.txt

@@ -2480,8 +2480,11 @@ JetFile: BinaryTree.jet
                             VALUE_ARGUMENT_LIST
                               PsiElement(LPAR)('(')
                               VALUE_ARGUMENT
-                                STRING_CONSTANT
-                                  PsiElement(STRING_LITERAL)('"Nothing to remove"')
+                                STRING_TEMPLATE
+                                  PsiElement(OPEN_QUOTE)('"')
+                                  LITERAL_STRING_TEMPLATE_ENTRY
+                                    PsiElement(REGULAR_STRING_PART)('Nothing to remove')
+                                  PsiElement(CLOSING_QUOTE)('"')
                               PsiElement(RPAR)(')')
                     PsiWhiteSpace('\n      ')
                     CALL_EXPRESSION

idea/testData/psi/examples/Builder.txt

@@ -59,8 +59,14 @@ JetFile: Builder.jet
                           VALUE_ARGUMENT_LIST
                             PsiElement(LPAR)('(')
                             VALUE_ARGUMENT
-                              STRING_CONSTANT
-                                PsiElement(STRING_LITERAL)('"$libs/groovy-..."')
+                              STRING_TEMPLATE
+                                PsiElement(OPEN_QUOTE)('"')
+                                SHORT_STRING_TEMPLATE_ENTRY
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(SHORT_TEMPLATE_ENTRY)('$libs')
+                                LITERAL_STRING_TEMPLATE_ENTRY
+                                  PsiElement(REGULAR_STRING_PART)('/groovy-...')
+                                PsiElement(CLOSING_QUOTE)('"')
                             PsiElement(RPAR)(')')
                       PsiWhiteSpace('\n  ')
                       PsiElement(RBRACE)('}')
@@ -99,8 +105,14 @@ JetFile: Builder.jet
                               VALUE_ARGUMENT_LIST
                                 PsiElement(LPAR)('(')
                                 VALUE_ARGUMENT
-                                  STRING_CONSTANT
-                                    PsiElement(STRING_LITERAL)('"$gantHome/lib"')
+                                  STRING_TEMPLATE
+                                    PsiElement(OPEN_QUOTE)('"')
+                                    SHORT_STRING_TEMPLATE_ENTRY
+                                      REFERENCE_EXPRESSION
+                                        PsiElement(SHORT_TEMPLATE_ENTRY)('$gantHome')
+                                    LITERAL_STRING_TEMPLATE_ENTRY
+                                      PsiElement(REGULAR_STRING_PART)('/lib')
+                                    PsiElement(CLOSING_QUOTE)('"')
                                 PsiElement(RPAR)(')')
                             PsiElement(DOT)('.')
                             REFERENCE_EXPRESSION
@@ -162,8 +174,11 @@ JetFile: Builder.jet
                           OPERATION_REFERENCE
                             PsiElement(EQ)('=')
                           PsiWhiteSpace(' ')
-                          STRING_CONSTANT
-                            PsiElement(STRING_LITERAL)('"1.5"')
+                          STRING_TEMPLATE
+                            PsiElement(OPEN_QUOTE)('"')
+                            LITERAL_STRING_TEMPLATE_ENTRY
+                              PsiElement(REGULAR_STRING_PART)('1.5')
+                            PsiElement(CLOSING_QUOTE)('"')
                         PsiWhiteSpace('\n    ')
                         CALL_EXPRESSION
                           REFERENCE_EXPRESSION
@@ -191,8 +206,14 @@ JetFile: Builder.jet
                           VALUE_ARGUMENT_LIST
                             PsiElement(LPAR)('(')
                             VALUE_ARGUMENT
-                              STRING_CONSTANT
-                                PsiElement(STRING_LITERAL)('"$projectHome/antLayout/src"')
+                              STRING_TEMPLATE
+                                PsiElement(OPEN_QUOTE)('"')
+                                SHORT_STRING_TEMPLATE_ENTRY
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(SHORT_TEMPLATE_ENTRY)('$projectHome')
+                                LITERAL_STRING_TEMPLATE_ENTRY
+                                  PsiElement(REGULAR_STRING_PART)('/antLayout/src')
+                                PsiElement(CLOSING_QUOTE)('"')
                             PsiElement(RPAR)(')')
                       PsiWhiteSpace('\n  ')
                       PsiElement(RBRACE)('}')

idea/testData/psi/examples/With.txt

@@ -115,8 +115,11 @@ JetFile: With.jet
                   VALUE_ARGUMENT_LIST
                     PsiElement(LPAR)('(')
                     VALUE_ARGUMENT
-                      STRING_CONSTANT
-                        PsiElement(STRING_LITERAL)('"foo"')
+                      STRING_TEMPLATE
+                        PsiElement(OPEN_QUOTE)('"')
+                        LITERAL_STRING_TEMPLATE_ENTRY
+                          PsiElement(REGULAR_STRING_PART)('foo')
+                        PsiElement(CLOSING_QUOTE)('"')
                     PsiElement(RPAR)(')')
                 PsiElement(SEMICOLON)(';')
                 PsiWhiteSpace('\n    ')
@@ -126,8 +129,11 @@ JetFile: With.jet
                   VALUE_ARGUMENT_LIST
                     PsiElement(LPAR)('(')
                     VALUE_ARGUMENT
-                      STRING_CONSTANT
-                        PsiElement(STRING_LITERAL)('"bar"')
+                      STRING_TEMPLATE
+                        PsiElement(OPEN_QUOTE)('"')
+                        LITERAL_STRING_TEMPLATE_ENTRY
+                          PsiElement(REGULAR_STRING_PART)('bar')
+                        PsiElement(CLOSING_QUOTE)('"')
                     PsiElement(RPAR)(')')
                 PsiElement(SEMICOLON)(';')
               PsiWhiteSpace('\n  ')
@@ -153,8 +159,11 @@ JetFile: With.jet
                     VALUE_ARGUMENT_LIST
                       PsiElement(LPAR)('(')
                       VALUE_ARGUMENT
-                        STRING_CONSTANT
-                          PsiElement(STRING_LITERAL)('"foo"')
+                        STRING_TEMPLATE
+                          PsiElement(OPEN_QUOTE)('"')
+                          LITERAL_STRING_TEMPLATE_ENTRY
+                            PsiElement(REGULAR_STRING_PART)('foo')
+                          PsiElement(CLOSING_QUOTE)('"')
                       PsiElement(RPAR)(')')
                   PsiElement(SEMICOLON)(';')
                   PsiWhiteSpace('\n    ')
@@ -164,8 +173,11 @@ JetFile: With.jet
                     VALUE_ARGUMENT_LIST
                       PsiElement(LPAR)('(')
                       VALUE_ARGUMENT
-                        STRING_CONSTANT
-                          PsiElement(STRING_LITERAL)('"bar"')
+                        STRING_TEMPLATE
+                          PsiElement(OPEN_QUOTE)('"')
+                          LITERAL_STRING_TEMPLATE_ENTRY
+                            PsiElement(REGULAR_STRING_PART)('bar')
+                          PsiElement(CLOSING_QUOTE)('"')
                       PsiElement(RPAR)(')')
                   PsiElement(SEMICOLON)(';')
                 PsiWhiteSpace('\n  ')

idea/testData/resolve/StringTemplates.jet

@@ -0,0 +1,21 @@
+fun demo() {
+  ~abc~val abc = 1
+  ~a~val a = ""
+  ~asd~val asd = 1
+  ~bar~val bar = 5
+  ~map~fun map(f : fun () : Any?) : Int  = 1
+  ~buzz~fun buzz(f : fun () : Any?) : Int  = 1
+  ~sdf~val sdf = 1
+  ~foo~val foo = 3;
+    "`abc`$abc"
+    "$"
+    "$.$.asdf$\t"
+    "asd\$"
+    "asd`a`$a"
+    "asd`a`$a`asd`$asd$"
+    "fosdfasdo${1 + `bar`bar + 100}}sdsdfgdsfsdf"
+    "foo${`bar`bar + `map`map {`foo`foo}}sdfsdf"
+    "foo${`bar`bar + `map`map { "foo" }}sdfsdf"
+    "foo${`bar`bar + `map`map {
+      "foo`sdf`$sdf${ `buzz`buzz{}}" }}sdfsdf"
+}