Merge branch 'master' of github.com:JetBrains/kotlin

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java

@@ -322,6 +322,7 @@ public interface Errors {
     DiagnosticFactory<JetSimpleNameExpression> AMBIGUOUS_LABEL = DiagnosticFactory.create(ERROR, "Ambiguous label");
     DiagnosticFactory1<PsiElement, String> UNSUPPORTED = DiagnosticFactory1.create(ERROR, "Unsupported [{0}]");
     DiagnosticFactory1<PsiElement, JetType> UNNECESSARY_SAFE_CALL = DiagnosticFactory1.create(WARNING, "Unnecessary safe call on a non-null receiver of type {0}");
+    DiagnosticFactory1<PsiElement, JetType> UNNECESSARY_NOT_NULL_ASSERTION = DiagnosticFactory1.create(WARNING, "Unnecessary non-null assertion (!!) on a non-null receiver of type {0}");
     DiagnosticFactory2<JetSimpleNameExpression, JetTypeConstraint, JetTypeParameterListOwner> NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER = DiagnosticFactory2.create(ERROR, "{0} does not refer to a type parameter of {1}", new Renderer<JetTypeConstraint>() {
         @NotNull
         @Override

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

@@ -53,7 +53,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
             FUN_KEYWORD, FOR_KEYWORD, NULL_KEYWORD,
             TRUE_KEYWORD, FALSE_KEYWORD, IS_KEYWORD, THROW_KEYWORD, RETURN_KEYWORD, BREAK_KEYWORD,
             CONTINUE_KEYWORD, OBJECT_KEYWORD, IF_KEYWORD, TRY_KEYWORD, ELSE_KEYWORD, WHILE_KEYWORD, DO_KEYWORD,
-            WHEN_KEYWORD, RBRACKET, RBRACE, RPAR, PLUSPLUS, MINUSMINUS,
+            WHEN_KEYWORD, RBRACKET, RBRACE, RPAR, PLUSPLUS, MINUSMINUS, EXCLEXCL,
 //            MUL,
             PLUS, MINUS, EXCL, DIV, PERC, LTEQ,
             // TODO GTEQ,   foo<bar, baz>=x
@@ -64,7 +64,9 @@ public class JetExpressionParsing extends AbstractJetParsing {
 
     /*package*/ static final TokenSet EXPRESSION_FIRST = TokenSet.create(
             // Prefix
-            MINUS, PLUS, MINUSMINUS, PLUSPLUS, EXCL, LBRACKET, LABEL_IDENTIFIER, AT, ATAT,
+            MINUS, PLUS, MINUSMINUS, PLUSPLUS,
+            EXCL, EXCLEXCL, // Joining complex tokens makes it necessary to put EXCLEXCL here
+            LBRACKET, LABEL_IDENTIFIER, AT, ATAT,
             // Atomic
 
             LPAR, // parenthesized
@@ -126,7 +128,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
 
     @SuppressWarnings({"UnusedDeclaration"})
     private enum Precedence {
-        POSTFIX(PLUSPLUS, MINUSMINUS,
+        POSTFIX(PLUSPLUS, MINUSMINUS, EXCLEXCL,
 //                HASH,
                 DOT, SAFE_ACCESS), // typeArguments? valueArguments : typeArguments : arrayAccess
 
@@ -235,7 +237,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
             opSet.removeAll(usedSet);
             assert false : opSet;
         }
-        assert usedSet.size() == opSet.size();
+        assert usedSet.size() == opSet.size() : "Either some ops are unused, or something a non-op is used";
 
         usedSet.removeAll(opSet);
 
@@ -325,24 +327,34 @@ public class JetExpressionParsing extends AbstractJetParsing {
      */
     private void parsePrefixExpression() {
 //        System.out.println("pre at "  + myBuilder.getTokenText());
+
         if (at(LBRACKET)) {
             if (!parseLocalDeclaration()) {
                 PsiBuilder.Marker expression = mark();
                 myJetParsing.parseAnnotations(false);
                 parsePrefixExpression();
                 expression.done(ANNOTATED_EXPRESSION);
-            } else {
+            }
+            else {
                 return;
             }
-        } else if (atSet(Precedence.PREFIX.getOperations())) {
+        }
-            PsiBuilder.Marker expression = mark();
+        else {
+            myBuilder.disableJoiningComplexTokens();
+            if (atSet(Precedence.PREFIX.getOperations())) {
+                PsiBuilder.Marker expression = mark();
 
-            parseOperationReference();
+                parseOperationReference();
 
-            parsePrefixExpression();
+                myBuilder.restoreJoiningComplexTokensState();
-            expression.done(PREFIX_EXPRESSION);
+
-        } else {
+                parsePrefixExpression();
-            parsePostfixExpression();
+                expression.done(PREFIX_EXPRESSION);
+            }
+            else {
+                myBuilder.restoreJoiningComplexTokensState();
+                parsePostfixExpression();
+            }
         }
     }
 
@@ -350,7 +362,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
      * atomicExpression postfixUnaryOperation?
      *
      * postfixUnaryOperation
-     *   : "++" : "--"
+     *   : "++" : "--" : "!!"
      *   : typeArguments? valueArguments (getEntryPoint? functionLiteral)
      *   : typeArguments (getEntryPoint? functionLiteral)
      *   : arrayAccess

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

@@ -32,7 +32,7 @@ import static org.jetbrains.jet.lexer.JetTokens.*;
  * @author abreslav
  */
 public class SemanticWhitespaceAwarePsiBuilderImpl extends PsiBuilderAdapter implements SemanticWhitespaceAwarePsiBuilder {
-    private final TokenSet complexTokens = TokenSet.create(SAFE_ACCESS, ELVIS);
+    private final TokenSet complexTokens = TokenSet.create(SAFE_ACCESS, ELVIS, EXCLEXCL);
     private final Stack<Boolean> joinComplexTokens = new Stack<Boolean>();
 
     private final Stack<Boolean> newlinesEnabled = new Stack<Boolean>();
@@ -126,6 +126,10 @@ public class SemanticWhitespaceAwarePsiBuilderImpl extends PsiBuilderAdapter imp
             if (nextRawToken == DOT) return SAFE_ACCESS;
             if (nextRawToken == COLON) return ELVIS;
         }
+        else if (rawTokenType == EXCL) {
+            IElementType nextRawToken = rawLookup(rawLookupSteps);
+            if (nextRawToken == EXCL) return EXCLEXCL;
+        }
         return rawTokenType;
     }
 

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

@@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.calls.CallMaker;
 import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults;
 import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResultsUtil;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
+import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValueFactory;
 import org.jetbrains.jet.lang.resolve.constants.*;
 import org.jetbrains.jet.lang.resolve.constants.StringValue;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -661,7 +662,10 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     public JetType visitUnaryExpression(JetUnaryExpression expression, ExpressionTypingContext context, boolean isStatement) {
         JetExpression baseExpression = expression.getBaseExpression();
         if (baseExpression == null) return null;
+
         JetSimpleNameExpression operationSign = expression.getOperationReference();
+
+        // If it's a labeled expression
         if (JetTokens.LABELS.contains(operationSign.getReferencedNameElementType())) {
             String referencedName = operationSign.getReferencedName();
             referencedName = referencedName == null ? " <?>" : referencedName;
@@ -672,42 +676,62 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             context.labelResolver.exitLabeledElement(baseExpression);
             return DataFlowUtils.checkType(type, expression, context);
         }
+
         IElementType operationType = operationSign.getReferencedNameElementType();
+
+        // Type check the base expression
+        JetType type = facade.getType(baseExpression, context.replaceExpectedType(NO_EXPECTED_TYPE));
+        if (type == null) {
+            return null;
+        }
+
+        // Special case for expr!!
+        if (operationType == JetTokens.EXCLEXCL) {
+            JetType result;
+            if (isKnownToBeNotNull(baseExpression, context)) {
+                context.trace.report(UNNECESSARY_NOT_NULL_ASSERTION.on(operationSign, type));
+                result = type;
+            }
+            else {
+                result = TypeUtils.makeNotNullable(type);
+            }
+            return DataFlowUtils.checkType(result, expression, context);
+        }
+
+        // Conventions for unary operations
         String name = OperatorConventions.UNARY_OPERATION_NAMES.get(operationType);
         if (name == null) {
             context.trace.report(UNSUPPORTED.on(operationSign, "visitUnaryExpression"));
             return null;
         }
-        TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace);
-        BindingTrace initialTrace = context.trace;
-        context = context.replaceBindingTrace(temporaryTrace);
-        JetType type = facade.getType(baseExpression, context.replaceExpectedType(NO_EXPECTED_TYPE));
-        if (type == null) {
-            temporaryTrace.commit();
-            return null;
-        }
 
+        // a[i]++/-- takes special treatment because it is actually let j = i, arr = a in arr.set(j, a.get(j).inc())
         if ((operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) && baseExpression instanceof JetArrayAccessExpression) {
             JetExpression stubExpression = ExpressionTypingUtils.createStubExpressionOfNecessaryType(baseExpression.getProject(), type, context.trace);
-            resolveArrayAccessSetMethod((JetArrayAccessExpression) baseExpression, stubExpression, context.replaceExpectedType(NO_EXPECTED_TYPE).replaceBindingTrace(TemporaryBindingTrace.create(initialTrace)), context.trace);
+            resolveArrayAccessSetMethod((JetArrayAccessExpression) baseExpression,
+                                        stubExpression,
+                                        context.replaceExpectedType(NO_EXPECTED_TYPE).replaceBindingTrace(TemporaryBindingTrace.create(context.trace)),
+                                        context.trace);
         }
 
         ExpressionReceiver receiver = new ExpressionReceiver(baseExpression, type);
 
-        OverloadResolutionResults<FunctionDescriptor> functionDescriptor = context.resolveCallWithGivenNameToDescriptor(
+        // Resolve the operation reference
+        OverloadResolutionResults<FunctionDescriptor> resolutionResults = context.resolveCallWithGivenNameToDescriptor(
                 CallMaker.makeCall(receiver, expression),
                 expression.getOperationReference(),
                 name);
 
-        if (!functionDescriptor.isSuccess()) {
+        if (!resolutionResults.isSuccess()) {
-            temporaryTrace.commit();
             return null;
         }
-        JetType returnType = functionDescriptor.getResultingDescriptor().getReturnType();
+
+        // Computing the return type
+        JetType returnType = resolutionResults.getResultingDescriptor().getReturnType();
         JetType result;
         if (operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) {
             if (JetTypeChecker.INSTANCE.isSubtypeOf(returnType, JetStandardClasses.getUnitType())) {
-                result = JetStandardClasses.getUnitType();
+                result = ErrorUtils.createErrorType("Unit");
                 context.trace.report(INC_DEC_SHOULD_NOT_RETURN_UNIT.on(operationSign));
             }
             else {
@@ -727,10 +751,23 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         else {
             result = returnType;
         }
-        temporaryTrace.commit();
         return DataFlowUtils.checkType(result, expression, context);
     }
 
+    private boolean isKnownToBeNotNull(JetExpression expression, ExpressionTypingContext context) {
+        JetType type = context.trace.get(EXPRESSION_TYPE, expression);
+        assert type != null : "This method is only supposed to be called when the type is not null";
+        if (!type.isNullable()) return true;
+        List<JetType> possibleTypes = context.dataFlowInfo
+            .getPossibleTypes(DataFlowValueFactory.INSTANCE.createDataFlowValue(expression, type, context.trace.getBindingContext()));
+        for (JetType possibleType : possibleTypes) {
+            if (!possibleType.isNullable()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     public void checkLValue(BindingTrace trace, JetExpression expression) {
         checkLValue(trace, expression, false);
     }

compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex

@@ -164,6 +164,10 @@ LONG_TEMPLATE_ENTRY_END=\}
 
 // (Nested) comments
 
+"/**/" {
+    return JetTokens.BLOCK_COMMENT;
+}
+
 "/**" {
     pushState(DOC_COMMENT);
     commentDepth = 0;
@@ -266,6 +270,7 @@ LONG_TEMPLATE_ENTRY_END=\}
 ">="         { return JetTokens.GTEQ      ; }
 "=="         { return JetTokens.EQEQ      ; }
 "!="         { return JetTokens.EXCLEQ    ; }
+//"!!"         { return JetTokens.EXCLEXCL  ; }
 "&&"         { return JetTokens.ANDAND    ; }
 "||"         { return JetTokens.OROR      ; }
 //"?."         { return JetTokens.SAFE_ACCESS;}

compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java

@@ -107,6 +107,7 @@ public interface JetTokens {
     JetToken EXCLEQEQEQ  = new JetToken("EXCLEQEQEQ");
     JetToken EQEQ        = new JetToken("EQEQ");
     JetToken EXCLEQ      = new JetToken("EXCLEQ");
+    JetToken EXCLEXCL      = new JetToken("EXCLEXCL");
     JetToken ANDAND      = new JetToken("ANDAND");
     JetToken OROR        = new JetToken("OROR");
     JetToken SAFE_ACCESS = new JetToken("SAFE_ACCESS");
@@ -184,7 +185,7 @@ public interface JetTokens {
     TokenSet COMMENTS = TokenSet.create(EOL_COMMENT, BLOCK_COMMENT, DOC_COMMENT);
 
     TokenSet STRINGS = TokenSet.create(CHARACTER_LITERAL, REGULAR_STRING_PART);
-    TokenSet OPERATIONS = TokenSet.create(AS_KEYWORD, AS_SAFE, IS_KEYWORD, IN_KEYWORD, DOT, PLUSPLUS, MINUSMINUS, MUL, PLUS,
+    TokenSet OPERATIONS = TokenSet.create(AS_KEYWORD, AS_SAFE, IS_KEYWORD, IN_KEYWORD, DOT, PLUSPLUS, MINUSMINUS, EXCLEXCL, MUL, PLUS,
             MINUS, EXCL, DIV, PERC, LT, GT, LTEQ, GTEQ, EQEQEQ, EXCLEQEQEQ, EQEQ, EXCLEQ, ANDAND, OROR,
             SAFE_ACCESS, ELVIS,
 //            MAP, FILTER,

compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java

@@ -1,18 +1,19 @@
-/* The following code was generated by JFlex 1.4.3 on 3/21/12 3:48 PM */
+/* The following code was generated by JFlex 1.4.3 on 3/23/12 10:24 AM */
 
 package org.jetbrains.jet.lexer;
 
-import com.intellij.lexer.FlexLexer;
+import java.util.*;
-import com.intellij.psi.TokenType;
+import com.intellij.lexer.*;
+import com.intellij.psi.*;
 import com.intellij.psi.tree.IElementType;
 
-import java.util.Stack;
+import org.jetbrains.jet.lexer.JetTokens;
 
 
 /**
  * This class is a scanner generated by 
  * <a href="http://www.jflex.de/">JFlex</a> 1.4.3
- * on 3/21/12 3:48 PM from the specification file
+ * on 3/23/12 10:24 AM from the specification file
  * <tt>/Users/abreslav/work/jet/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex</tt>
  */
 class _JetLexer implements FlexLexer {
@@ -136,14 +137,14 @@ class _JetLexer implements FlexLexer {
     "\1\103\1\104\1\44\1\3\2\0\1\105\4\0\1\106"+
     "\4\3\1\107\10\3\1\110\4\3\1\111\1\112\2\3"+
     "\1\113\1\114\1\115\1\116\1\117\1\120\1\121\1\122"+
-    "\2\0\2\40\1\45\1\46\1\44\1\0\1\123\1\3"+
+    "\2\0\2\40\1\45\1\46\1\123\1\44\1\0\1\124"+
-    "\1\124\1\3\1\125\4\3\1\126\1\127\4\3\1\130"+
+    "\1\3\1\125\1\3\1\126\4\3\1\127\1\130\4\3"+
-    "\1\3\1\131\1\132\1\77\1\0\1\133\1\134\1\135"+
+    "\1\131\1\3\1\132\1\133\1\77\1\0\1\134\1\135"+
-    "\1\136\1\3\1\137\3\3\1\140\1\141\1\142\1\0"+
+    "\1\136\1\137\1\3\1\140\3\3\1\141\1\142\1\143"+
-    "\1\3\1\143\1\3\1\144\1\3\1\145\1\146";
+    "\1\0\1\3\1\144\1\3\1\145\1\3\1\146\1\147";
 
   private static int [] zzUnpackAction() {
-    int [] result = new int[229];
+    int [] result = new int[230];
     int offset = 0;
     offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result);
     return result;
@@ -186,20 +187,20 @@ class _JetLexer implements FlexLexer {
     "\0\u1680\0\u0180\0\u0180\0\u16c0\0\u0180\0\u0180\0\u0180\0\u0180"+
     "\0\u0180\0\u1700\0\u1740\0\u0180\0\u0180\0\u1780\0\u17c0\0\u1800"+
     "\0\u1840\0\u0180\0\u0180\0\u0180\0\u1880\0\u0180\0\u18c0\0\u1900"+
-    "\0\u0180\0\u1940\0\u1980\0\u19c0\0\u1a00\0\u0180\0\u1a40\0\u1a80"+
+    "\0\u1940\0\u1980\0\u19c0\0\u1a00\0\u1a40\0\u0180\0\u1a80\0\u1ac0"+
-    "\0\u1ac0\0\u1b00\0\u0200\0\u1b40\0\u1b80\0\u1bc0\0\u1c00\0\u1c40"+
+    "\0\u1b00\0\u1b40\0\u0200\0\u1b80\0\u1bc0\0\u1c00\0\u1c40\0\u1c80"+
-    "\0\u1c80\0\u1cc0\0\u1d00\0\u0180\0\u1d40\0\u1d80\0\u1dc0\0\u1e00"+
+    "\0\u1cc0\0\u1d00\0\u1d40\0\u0180\0\u1d80\0\u1dc0\0\u1e00\0\u1e40"+
-    "\0\u0200\0\u0200\0\u1e40\0\u1e80\0\u0200\0\u0200\0\u1ec0\0\u1ec0"+
+    "\0\u0200\0\u0200\0\u1e80\0\u1ec0\0\u0200\0\u0200\0\u1f00\0\u1f00"+
-    "\0\u0180\0\u0180\0\u0180\0\u0180\0\u1f00\0\u1f40\0\u0180\0\u1f80"+
+    "\0\u0180\0\u0180\0\u0180\0\u0180\0\u1f40\0\u1f80\0\u0180\0\u1fc0"+
-    "\0\u0180\0\u0180\0\u1fc0\0\u1880\0\u0200\0\u2000\0\u0200\0\u2040"+
+    "\0\u0180\0\u0180\0\u0180\0\u2000\0\u1880\0\u0200\0\u2040\0\u0200"+
-    "\0\u0200\0\u2080\0\u20c0\0\u2100\0\u2140\0\u0200\0\u0200\0\u2180"+
+    "\0\u2080\0\u0200\0\u20c0\0\u2100\0\u2140\0\u2180\0\u0200\0\u0200"+
-    "\0\u21c0\0\u2200\0\u2240\0\u0200\0\u2280\0\u0200\0\u0180\0\u0180"+
+    "\0\u21c0\0\u2200\0\u2240\0\u2280\0\u0200\0\u22c0\0\u0200\0\u0180"+
-    "\0\u22c0\0\u0c00\0\u0200\0\u0200\0\u0200\0\u2300\0\u0200\0\u2340"+
+    "\0\u0180\0\u2300\0\u0c00\0\u0200\0\u0200\0\u0200\0\u2340\0\u0200"+
-    "\0\u2380\0\u23c0\0\u0200\0\u0200\0\u0200\0\u2400\0\u2440\0\u0200"+
+    "\0\u2380\0\u23c0\0\u2400\0\u0200\0\u0200\0\u0200\0\u2440\0\u2480"+
-    "\0\u2480\0\u0200\0\u24c0\0\u0200\0\u0200";
+    "\0\u0200\0\u24c0\0\u0200\0\u2500\0\u0200\0\u0200";
 
   private static int [] zzUnpackRowMap() {
-    int [] result = new int[229];
+    int [] result = new int[230];
     int offset = 0;
     offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result);
     return result;
@@ -374,109 +375,109 @@ class _JetLexer implements FlexLexer {
     "\5\0\3\77\1\0\1\77\1\0\1\77\3\0\1\77"+
     "\2\0\2\77\1\270\1\77\1\0\22\77\22\0\1\215"+
     "\11\0\1\215\64\0\6\217\1\271\1\0\70\217\6\220"+
-    "\1\272\1\0\70\220\1\0\1\125\11\0\1\125\65\0"+
+    "\1\272\1\0\70\220\12\0\1\273\66\0\1\125\11\0"+
-    "\2\273\10\0\1\273\1\0\1\273\1\214\1\273\15\0"+
+    "\1\125\65\0\2\274\10\0\1\274\1\0\1\274\1\214"+
-    "\1\273\2\0\1\273\1\0\1\273\3\0\1\273\3\0"+
+    "\1\274\15\0\1\274\2\0\1\274\1\0\1\274\3\0"+
-    "\1\273\3\0\1\273\22\0\1\215\11\0\1\215\4\0"+
+    "\1\274\3\0\1\274\3\0\1\274\22\0\1\215\11\0"+
-    "\1\274\44\0\1\274\30\0\1\214\62\0\2\11\1\0"+
+    "\1\215\4\0\1\275\44\0\1\275\30\0\1\214\62\0"+
-    "\2\11\5\0\3\11\1\0\1\11\1\0\1\11\3\0"+
+    "\2\11\1\0\2\11\5\0\3\11\1\0\1\11\1\0"+
-    "\1\11\2\0\3\11\1\275\1\0\22\11\22\0\2\11"+
+    "\1\11\3\0\1\11\2\0\3\11\1\276\1\0\22\11"+
-    "\1\0\2\11\5\0\3\11\1\0\1\11\1\0\1\11"+
-    "\3\0\1\11\2\0\4\11\1\0\1\11\1\276\20\11"+
     "\22\0\2\11\1\0\2\11\5\0\3\11\1\0\1\11"+
-    "\1\0\1\11\3\0\1\11\2\0\4\11\1\0\3\11"+
+    "\1\0\1\11\3\0\1\11\2\0\4\11\1\0\1\11"+
-    "\1\277\16\11\22\0\2\11\1\0\2\11\5\0\3\11"+
+    "\1\277\20\11\22\0\2\11\1\0\2\11\5\0\3\11"+
-    "\1\0\1\11\1\0\1\11\3\0\1\11\2\0\2\11"+
+    "\1\0\1\11\1\0\1\11\3\0\1\11\2\0\4\11"+
-    "\1\300\1\11\1\0\22\11\22\0\2\11\1\0\2\11"+
+    "\1\0\3\11\1\300\16\11\22\0\2\11\1\0\2\11"+
     "\5\0\3\11\1\0\1\11\1\0\1\11\3\0\1\11"+
-    "\2\0\4\11\1\0\3\11\1\301\16\11\22\0\2\11"+
+    "\2\0\2\11\1\301\1\11\1\0\22\11\22\0\2\11"+
     "\1\0\2\11\5\0\3\11\1\0\1\11\1\0\1\11"+
     "\3\0\1\11\2\0\4\11\1\0\3\11\1\302\16\11"+
     "\22\0\2\11\1\0\2\11\5\0\3\11\1\0\1\11"+
-    "\1\0\1\11\3\0\1\11\2\0\1\303\3\11\1\0"+
+    "\1\0\1\11\3\0\1\11\2\0\4\11\1\0\3\11"+
-    "\22\11\22\0\2\11\1\0\2\11\5\0\3\11\1\0"+
+    "\1\303\16\11\22\0\2\11\1\0\2\11\5\0\3\11"+
-    "\1\11\1\0\1\11\3\0\1\11\2\0\3\11\1\304"+
+    "\1\0\1\11\1\0\1\11\3\0\1\11\2\0\1\304"+
-    "\1\0\22\11\22\0\2\11\1\0\2\11\5\0\3\11"+
+    "\3\11\1\0\22\11\22\0\2\11\1\0\2\11\5\0"+
-    "\1\0\1\11\1\0\1\11\3\0\1\11\2\0\4\11"+
+    "\3\11\1\0\1\11\1\0\1\11\3\0\1\11\2\0"+
-    "\1\0\3\11\1\305\16\11\22\0\2\11\1\0\2\11"+
+    "\3\11\1\305\1\0\22\11\22\0\2\11\1\0\2\11"+
     "\5\0\3\11\1\0\1\11\1\0\1\11\3\0\1\11"+
-    "\2\0\4\11\1\0\14\11\1\306\5\11\22\0\2\11"+
+    "\2\0\4\11\1\0\3\11\1\306\16\11\22\0\2\11"+
     "\1\0\2\11\5\0\3\11\1\0\1\11\1\0\1\11"+
-    "\3\0\1\11\2\0\4\11\1\0\3\11\1\307\16\11"+
+    "\3\0\1\11\2\0\4\11\1\0\14\11\1\307\5\11"+
     "\22\0\2\11\1\0\2\11\5\0\3\11\1\0\1\11"+
-    "\1\0\1\11\3\0\1\11\2\0\4\11\1\0\6\11"+
+    "\1\0\1\11\3\0\1\11\2\0\4\11\1\0\3\11"+
-    "\1\310\13\11\22\0\2\11\1\0\2\11\5\0\3\11"+
+    "\1\310\16\11\22\0\2\11\1\0\2\11\5\0\3\11"+
-    "\1\0\1\11\1\0\1\11\3\0\1\311\2\0\4\11"+
-    "\1\0\22\11\22\0\2\11\1\0\2\11\5\0\3\11"+
     "\1\0\1\11\1\0\1\11\3\0\1\11\2\0\4\11"+
-    "\1\0\5\11\1\312\14\11\22\0\2\11\1\0\2\11"+
+    "\1\0\6\11\1\311\13\11\22\0\2\11\1\0\2\11"+
-    "\5\0\3\11\1\0\1\11\1\0\1\11\3\0\1\11"+
+    "\5\0\3\11\1\0\1\11\1\0\1\11\3\0\1\312"+
-    "\2\0\4\11\1\0\14\11\1\313\5\11\22\0\2\11"+
-    "\1\0\2\11\5\0\3\11\1\0\1\11\1\0\1\11"+
-    "\3\0\1\11\2\0\4\11\1\0\2\11\1\314\17\11"+
-    "\22\0\2\11\1\0\2\11\5\0\3\11\1\0\1\11"+
-    "\1\0\1\11\3\0\1\11\2\0\3\11\1\315\1\0"+
-    "\22\11\22\0\2\11\1\0\2\11\5\0\3\11\1\0"+
-    "\1\11\1\0\1\11\3\0\1\11\2\0\3\11\1\316"+
-    "\1\0\22\11\22\0\2\317\1\0\2\317\5\0\3\317"+
-    "\1\0\1\317\1\0\1\317\3\0\1\317\2\0\4\317"+
-    "\1\0\22\317\21\0\6\265\1\320\1\0\70\265\1\0"+
-    "\2\321\10\0\1\321\1\0\1\321\1\0\1\321\15\0"+
-    "\1\321\2\0\1\321\1\0\1\321\3\0\1\321\3\0"+
-    "\1\321\3\0\1\321\22\0\2\77\1\0\2\77\5\0"+
-    "\3\77\1\0\1\77\1\0\1\77\3\0\1\77\2\0"+
-    "\3\77\1\322\1\0\22\77\22\0\2\273\10\0\1\273"+
-    "\1\0\1\273\1\0\1\273\1\0\1\224\13\0\1\273"+
-    "\2\0\1\273\1\224\1\273\3\0\1\273\3\0\1\273"+
-    "\3\0\1\273\22\0\2\11\1\0\2\11\5\0\3\11"+
-    "\1\0\1\11\1\0\1\11\3\0\1\11\2\0\4\11"+
-    "\1\0\13\11\1\323\6\11\22\0\2\11\1\0\2\11"+
-    "\5\0\3\11\1\0\1\11\1\0\1\11\3\0\1\11"+
-    "\2\0\1\324\3\11\1\0\22\11\22\0\2\11\1\0"+
-    "\2\11\5\0\3\11\1\0\1\11\1\0\1\11\3\0"+
-    "\1\11\2\0\4\11\1\0\10\11\1\325\11\11\22\0"+
-    "\2\11\1\0\2\11\5\0\3\11\1\0\1\11\1\0"+
-    "\1\11\3\0\1\11\2\0\2\11\1\326\1\11\1\0"+
-    "\22\11\22\0\2\11\1\0\2\11\5\0\3\11\1\0"+
-    "\1\11\1\0\1\11\3\0\1\11\2\0\3\11\1\327"+
-    "\1\0\22\11\22\0\2\11\1\0\2\11\5\0\3\11"+
-    "\1\0\1\11\1\0\1\11\3\0\1\11\2\0\4\11"+
-    "\1\0\1\330\21\11\22\0\2\11\1\0\2\11\5\0"+
-    "\3\11\1\0\1\11\1\0\1\11\3\0\1\11\2\0"+
-    "\4\11\1\0\5\11\1\331\14\11\22\0\2\11\1\0"+
-    "\2\11\5\0\3\11\1\0\1\11\1\0\1\11\3\0"+
-    "\1\11\2\0\4\11\1\0\10\11\1\332\11\11\22\0"+
-    "\2\11\1\0\2\11\5\0\3\11\1\0\1\11\1\0"+
-    "\1\11\3\0\1\11\2\0\4\11\1\0\6\11\1\333"+
-    "\13\11\22\0\2\11\1\0\2\11\5\0\3\11\1\0"+
-    "\1\11\1\0\1\11\3\0\1\11\2\0\4\11\1\0"+
-    "\3\11\1\334\16\11\22\0\2\11\1\0\2\11\5\0"+
-    "\3\11\1\0\1\11\1\0\1\11\3\0\1\11\2\0"+
-    "\4\11\1\0\3\11\1\335\16\11\22\0\2\336\10\0"+
-    "\1\336\1\0\1\336\1\0\1\336\15\0\1\336\2\0"+
-    "\1\336\1\0\1\336\3\0\1\336\3\0\1\336\3\0"+
-    "\1\336\22\0\2\11\1\0\2\11\5\0\3\11\1\0"+
-    "\1\11\1\0\1\11\3\0\1\11\2\0\4\11\1\0"+
-    "\2\11\1\337\17\11\22\0\2\11\1\0\2\11\5\0"+
-    "\3\11\1\0\1\11\1\0\1\11\3\0\1\11\2\0"+
-    "\1\340\3\11\1\0\22\11\22\0\2\11\1\0\2\11"+
-    "\5\0\3\11\1\0\1\11\1\0\1\11\3\0\1\11"+
-    "\2\0\4\11\1\0\7\11\1\341\12\11\22\0\2\11"+
-    "\1\0\2\11\5\0\3\11\1\0\1\11\1\0\1\11"+
-    "\3\0\1\11\2\0\4\11\1\0\2\11\1\342\17\11"+
-    "\22\0\2\205\10\0\1\205\1\0\1\205\1\0\1\205"+
-    "\15\0\1\205\2\0\1\205\1\0\1\205\3\0\1\205"+
-    "\3\0\1\205\3\0\1\205\22\0\2\11\1\0\2\11"+
-    "\5\0\3\11\1\0\1\11\1\0\1\11\3\0\1\343"+
     "\2\0\4\11\1\0\22\11\22\0\2\11\1\0\2\11"+
     "\5\0\3\11\1\0\1\11\1\0\1\11\3\0\1\11"+
-    "\2\0\4\11\1\0\3\11\1\344\16\11\22\0\2\11"+
+    "\2\0\4\11\1\0\5\11\1\313\14\11\22\0\2\11"+
+    "\1\0\2\11\5\0\3\11\1\0\1\11\1\0\1\11"+
+    "\3\0\1\11\2\0\4\11\1\0\14\11\1\314\5\11"+
+    "\22\0\2\11\1\0\2\11\5\0\3\11\1\0\1\11"+
+    "\1\0\1\11\3\0\1\11\2\0\4\11\1\0\2\11"+
+    "\1\315\17\11\22\0\2\11\1\0\2\11\5\0\3\11"+
+    "\1\0\1\11\1\0\1\11\3\0\1\11\2\0\3\11"+
+    "\1\316\1\0\22\11\22\0\2\11\1\0\2\11\5\0"+
+    "\3\11\1\0\1\11\1\0\1\11\3\0\1\11\2\0"+
+    "\3\11\1\317\1\0\22\11\22\0\2\320\1\0\2\320"+
+    "\5\0\3\320\1\0\1\320\1\0\1\320\3\0\1\320"+
+    "\2\0\4\320\1\0\22\320\21\0\6\265\1\321\1\0"+
+    "\70\265\1\0\2\322\10\0\1\322\1\0\1\322\1\0"+
+    "\1\322\15\0\1\322\2\0\1\322\1\0\1\322\3\0"+
+    "\1\322\3\0\1\322\3\0\1\322\22\0\2\77\1\0"+
+    "\2\77\5\0\3\77\1\0\1\77\1\0\1\77\3\0"+
+    "\1\77\2\0\3\77\1\323\1\0\22\77\22\0\2\274"+
+    "\10\0\1\274\1\0\1\274\1\0\1\274\1\0\1\224"+
+    "\13\0\1\274\2\0\1\274\1\224\1\274\3\0\1\274"+
+    "\3\0\1\274\3\0\1\274\22\0\2\11\1\0\2\11"+
+    "\5\0\3\11\1\0\1\11\1\0\1\11\3\0\1\11"+
+    "\2\0\4\11\1\0\13\11\1\324\6\11\22\0\2\11"+
+    "\1\0\2\11\5\0\3\11\1\0\1\11\1\0\1\11"+
+    "\3\0\1\11\2\0\1\325\3\11\1\0\22\11\22\0"+
+    "\2\11\1\0\2\11\5\0\3\11\1\0\1\11\1\0"+
+    "\1\11\3\0\1\11\2\0\4\11\1\0\10\11\1\326"+
+    "\11\11\22\0\2\11\1\0\2\11\5\0\3\11\1\0"+
+    "\1\11\1\0\1\11\3\0\1\11\2\0\2\11\1\327"+
+    "\1\11\1\0\22\11\22\0\2\11\1\0\2\11\5\0"+
+    "\3\11\1\0\1\11\1\0\1\11\3\0\1\11\2\0"+
+    "\3\11\1\330\1\0\22\11\22\0\2\11\1\0\2\11"+
+    "\5\0\3\11\1\0\1\11\1\0\1\11\3\0\1\11"+
+    "\2\0\4\11\1\0\1\331\21\11\22\0\2\11\1\0"+
+    "\2\11\5\0\3\11\1\0\1\11\1\0\1\11\3\0"+
+    "\1\11\2\0\4\11\1\0\5\11\1\332\14\11\22\0"+
+    "\2\11\1\0\2\11\5\0\3\11\1\0\1\11\1\0"+
+    "\1\11\3\0\1\11\2\0\4\11\1\0\10\11\1\333"+
+    "\11\11\22\0\2\11\1\0\2\11\5\0\3\11\1\0"+
+    "\1\11\1\0\1\11\3\0\1\11\2\0\4\11\1\0"+
+    "\6\11\1\334\13\11\22\0\2\11\1\0\2\11\5\0"+
+    "\3\11\1\0\1\11\1\0\1\11\3\0\1\11\2\0"+
+    "\4\11\1\0\3\11\1\335\16\11\22\0\2\11\1\0"+
+    "\2\11\5\0\3\11\1\0\1\11\1\0\1\11\3\0"+
+    "\1\11\2\0\4\11\1\0\3\11\1\336\16\11\22\0"+
+    "\2\337\10\0\1\337\1\0\1\337\1\0\1\337\15\0"+
+    "\1\337\2\0\1\337\1\0\1\337\3\0\1\337\3\0"+
+    "\1\337\3\0\1\337\22\0\2\11\1\0\2\11\5\0"+
+    "\3\11\1\0\1\11\1\0\1\11\3\0\1\11\2\0"+
+    "\4\11\1\0\2\11\1\340\17\11\22\0\2\11\1\0"+
+    "\2\11\5\0\3\11\1\0\1\11\1\0\1\11\3\0"+
+    "\1\11\2\0\1\341\3\11\1\0\22\11\22\0\2\11"+
+    "\1\0\2\11\5\0\3\11\1\0\1\11\1\0\1\11"+
+    "\3\0\1\11\2\0\4\11\1\0\7\11\1\342\12\11"+
+    "\22\0\2\11\1\0\2\11\5\0\3\11\1\0\1\11"+
+    "\1\0\1\11\3\0\1\11\2\0\4\11\1\0\2\11"+
+    "\1\343\17\11\22\0\2\205\10\0\1\205\1\0\1\205"+
+    "\1\0\1\205\15\0\1\205\2\0\1\205\1\0\1\205"+
+    "\3\0\1\205\3\0\1\205\3\0\1\205\22\0\2\11"+
+    "\1\0\2\11\5\0\3\11\1\0\1\11\1\0\1\11"+
+    "\3\0\1\344\2\0\4\11\1\0\22\11\22\0\2\11"+
     "\1\0\2\11\5\0\3\11\1\0\1\11\1\0\1\11"+
     "\3\0\1\11\2\0\4\11\1\0\3\11\1\345\16\11"+
-    "\21\0";
+    "\22\0\2\11\1\0\2\11\5\0\3\11\1\0\1\11"+
+    "\1\0\1\11\3\0\1\11\2\0\4\11\1\0\3\11"+
+    "\1\346\16\11\21\0";
 
   private static int [] zzUnpackTrans() {
-    int [] result = new int[9472];
+    int [] result = new int[9536];
     int offset = 0;
     offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result);
     return result;
@@ -524,12 +525,12 @@ class _JetLexer implements FlexLexer {
     "\5\11\1\1\1\0\7\1\1\11\20\1\1\0\1\1"+
     "\1\0\1\11\1\0\2\11\1\1\5\11\1\1\1\0"+
     "\2\11\1\1\2\0\1\1\3\11\1\1\1\11\2\0"+
-    "\1\11\4\0\1\11\15\1\1\11\14\1\4\11\2\0"+
+    "\1\1\4\0\1\11\15\1\1\11\14\1\4\11\2\0"+
-    "\1\11\1\1\2\11\1\1\1\0\22\1\2\11\1\0"+
+    "\1\11\1\1\3\11\1\1\1\0\22\1\2\11\1\0"+
     "\14\1\1\0\7\1";
 
   private static int [] zzUnpackAttribute() {
-    int [] result = new int[229];
+    int [] result = new int[230];
     int offset = 0;
     offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result);
     return result;
@@ -621,11 +622,6 @@ class _JetLexer implements FlexLexer {
         yybegin(state.state);
     }
 
-    private boolean atCommentState() {
-        int state = yystate();
-        return state == BLOCK_COMMENT || state == DOC_COMMENT;
-    }
-
     private IElementType commentStateToTokenType(int state) {
         switch (state) {
             case BLOCK_COMMENT:
@@ -637,10 +633,6 @@ class _JetLexer implements FlexLexer {
         }
     }
 
-    void p(Object o) {
-      System.out.println(o);
-    }
-
 
   _JetLexer(java.io.Reader in) {
     this.zzReader = in;
@@ -892,23 +884,23 @@ class _JetLexer implements FlexLexer {
         case 3: 
           { return JetTokens.IDENTIFIER;
           }
-        case 103: break;
+        case 104: break;
         case 10: 
           { pushState(STRING); return JetTokens.OPEN_QUOTE;
           }
-        case 104: break;
+        case 105: break;
         case 74: 
           { return JetTokens.FOR_KEYWORD ;
           }
-        case 105: break;
+        case 106: break;
-        case 100: 
+        case 101: 
           { return JetTokens.RETURN_KEYWORD ;
           }
-        case 106: break;
+        case 107: break;
-        case 86: 
+        case 87: 
           { return JetTokens.NULL_KEYWORD ;
           }
-        case 107: break;
+        case 108: break;
         case 35: 
           { if (lBraceCount == 0) {
                                              popState();
@@ -917,159 +909,159 @@ class _JetLexer implements FlexLexer {
                                            lBraceCount--;
                                            return JetTokens.RBRACE;
           }
-        case 108: break;
+        case 109: break;
         case 15: 
           { return JetTokens.LT        ;
           }
-        case 109: break;
+        case 110: break;
         case 52: 
           { return JetTokens.DO_KEYWORD ;
           }
-        case 110: break;
+        case 111: break;
         case 20: 
           { return JetTokens.PLUS      ;
           }
-        case 111: break;
+        case 112: break;
         case 58: 
           { return JetTokens.PLUSEQ    ;
           }
-        case 112: break;
+        case 113: break;
-        case 91: 
+        case 92: 
           { popState(); return JetTokens.THIS_KEYWORD;
           }
-        case 113: break;
+        case 114: break;
         case 28: 
           { return JetTokens.COMMA     ;
           }
-        case 114: break;
+        case 115: break;
         case 17: 
           { return JetTokens.GT        ;
           }
-        case 115: break;
+        case 116: break;
         case 4: 
           { return JetTokens.WHITE_SPACE;
           }
-        case 116: break;
+        case 117: break;
         case 25: 
           { return JetTokens.RPAR      ;
           }
-        case 117: break;
+        case 118: break;
         case 56: 
           { return JetTokens.DOUBLE_ARROW;
           }
-        case 118: break;
+        case 119: break;
-        case 84: 
+        case 85: 
           { return JetTokens.TRUE_KEYWORD ;
           }
-        case 119: break;
+        case 120: break;
         case 80: 
           { return JetTokens.IDE_TEMPLATE_START    ;
           }
-        case 120: break;
+        case 121: break;
         case 37: 
           { return JetTokens.FIELD_IDENTIFIER;
           }
-        case 121: break;
+        case 122: break;
         case 60: 
           { return JetTokens.ANDAND    ;
           }
-        case 122: break;
+        case 123: break;
         case 64: 
           { pushState(LONG_TEMPLATE_ENTRY); return JetTokens.LONG_TEMPLATE_ENTRY_START;
           }
-        case 123: break;
+        case 124: break;
         case 36: 
           { return JetTokens.FLOAT_LITERAL;
           }
-        case 124: break;
+        case 125: break;
         case 40: 
           { return JetTokens.EOL_COMMENT;
           }
-        case 125: break;
+        case 126: break;
-        case 88: 
+        case 89: 
           { return JetTokens.WHEN_KEYWORD ;
           }
-        case 126: break;
+        case 127: break;
         case 70: 
           { pushState(RAW_STRING); return JetTokens.OPEN_QUOTE;
           }
-        case 127: break;
+        case 128: break;
         case 26: 
           { return JetTokens.COLON     ;
           }
-        case 128: break;
+        case 129: break;
         case 54: 
           { return JetTokens.LTEQ      ;
           }
-        case 129: break;
+        case 130: break;
         case 45: 
           { return JetTokens.ARROW     ;
           }
-        case 130: break;
+        case 131: break;
         case 32: 
           { popState(); return JetTokens.IDENTIFIER;
           }
-        case 131: break;
+        case 132: break;
         case 22: 
           { return JetTokens.LBRACKET  ;
           }
-        case 132: break;
+        case 133: break;
         case 68: 
           { yypushback(2); return JetTokens.INTEGER_LITERAL;
           }
-        case 133: break;
+        case 134: break;
         case 9: 
           { return JetTokens.CHARACTER_LITERAL;
           }
-        case 134: break;
+        case 135: break;
         case 75: 
           { return JetTokens.VAR_KEYWORD ;
           }
-        case 135: break;
+        case 136: break;
         case 55: 
           { return JetTokens.GTEQ      ;
           }
-        case 136: break;
+        case 137: break;
         case 2: 
           { return JetTokens.INTEGER_LITERAL;
           }
-        case 137: break;
+        case 138: break;
         case 12: 
           { return JetTokens.RBRACE    ;
           }
-        case 138: break;
+        case 139: break;
-        case 95: 
+        case 96: 
           { return JetTokens.CLASS_KEYWORD ;
           }
-        case 139: break;
+        case 140: break;
         case 14: 
           { return JetTokens.EXCL      ;
           }
-        case 140: break;
+        case 141: break;
         case 71: 
           { return JetTokens.TRY_KEYWORD ;
           }
-        case 141: break;
+        case 142: break;
         case 53: 
           { return JetTokens.EXCLEQ    ;
           }
-        case 142: break;
+        case 143: break;
         case 46: 
           { return JetTokens.MINUSEQ   ;
           }
-        case 143: break;
+        case 144: break;
-        case 101: 
+        case 102: 
           { return JetTokens.PACKAGE_KEYWORD ;
           }
-        case 144: break;
+        case 145: break;
-        case 92: 
+        case 93: 
           { return JetTokens.THROW_KEYWORD ;
           }
-        case 145: break;
+        case 146: break;
-        case 94: 
+        case 95: 
           { return JetTokens.SUPER_KEYWORD ;
           }
-        case 146: break;
+        case 147: break;
         case 67: 
           { if (commentDepth > 0) {
             commentDepth--;
@@ -1081,241 +1073,245 @@ class _JetLexer implements FlexLexer {
              return commentStateToTokenType(state);
         }
           }
-        case 147: break;
+        case 148: break;
-        case 97: 
+        case 98: 
           { return JetTokens.WHILE_KEYWORD ;
           }
-        case 148: break;
+        case 149: break;
         case 44: 
           { return JetTokens.MINUSMINUS;
           }
-        case 149: break;
+        case 150: break;
-        case 102: 
+        case 103: 
           { return JetTokens.CONTINUE_KEYWORD ;
           }
-        case 150: break;
+        case 151: break;
         case 78: 
           { return JetTokens.NOT_IN;
           }
-        case 151: break;
+        case 152: break;
         case 39: 
           { return JetTokens.ATAT      ;
           }
-        case 152: break;
+        case 153: break;
         case 6: 
           { return JetTokens.DIV       ;
           }
-        case 153: break;
+        case 154: break;
         case 81: 
           { return JetTokens.IDE_TEMPLATE_END    ;
           }
-        case 154: break;
+        case 155: break;
         case 38: 
           { return JetTokens.LABEL_IDENTIFIER;
           }
-        case 155: break;
+        case 156: break;
         case 29: 
           { return JetTokens.REGULAR_STRING_PART;
           }
-        case 156: break;
+        case 157: break;
         case 19: 
           { return JetTokens.QUEST     ;
           }
-        case 157: break;
+        case 158: break;
         case 69: 
           { pushState(DOC_COMMENT);
     commentDepth = 0;
     commentStart = getTokenStart();
           }
-        case 158: break;
+        case 159: break;
         case 61: 
           { return JetTokens.OROR      ;
           }
-        case 159: break;
+        case 160: break;
         case 21: 
           { return JetTokens.PERC      ;
           }
-        case 160: break;
+        case 161: break;
         case 79: 
           { return JetTokens.EXCLEQEQEQ;
           }
-        case 161: break;
+        case 162: break;
         case 62: 
           { return JetTokens.PERCEQ    ;
           }
-        case 162: break;
+        case 163: break;
         case 43: 
           { return JetTokens.RANGE     ;
           }
-        case 163: break;
+        case 164: break;
         case 1: 
           { return TokenType.BAD_CHARACTER;
           }
-        case 164: break;
+        case 165: break;
         case 63: 
           { pushState(SHORT_TEMPLATE_ENTRY);
                                                         yypushback(yylength() - 1);
                                                         return JetTokens.SHORT_TEMPLATE_ENTRY_START;
           }
-        case 165: break;
+        case 166: break;
         case 77: 
           { return JetTokens.NOT_IS;
           }
-        case 166: break;
+        case 167: break;
         case 13: 
           { return JetTokens.MUL       ;
           }
-        case 167: break;
+        case 168: break;
         case 23: 
           { return JetTokens.RBRACKET  ;
           }
-        case 168: break;
+        case 169: break;
         case 59: 
           { return JetTokens.PLUSPLUS  ;
           }
-        case 169: break;
+        case 170: break;
         case 41: 
           { pushState(BLOCK_COMMENT);
     commentDepth = 0;
     commentStart = getTokenStart();
           }
-        case 170: break;
+        case 171: break;
-        case 83: 
+        case 84: 
           { return JetTokens.THIS_KEYWORD ;
           }
-        case 171: break;
+        case 172: break;
         case 7: 
           { return JetTokens.DOT       ;
           }
-        case 172: break;
+        case 173: break;
         case 27: 
           { return JetTokens.SEMICOLON ;
           }
-        case 173: break;
+        case 174: break;
         case 49: 
           { return JetTokens.IF_KEYWORD ;
           }
-        case 174: break;
+        case 175: break;
         case 65: 
           { return JetTokens.ESCAPE_SEQUENCE;
           }
-        case 175: break;
+        case 176: break;
         case 31: 
           { popState(); return JetTokens.CLOSING_QUOTE;
           }
-        case 176: break;
+        case 177: break;
         case 18: 
           { return JetTokens.EQ        ;
           }
-        case 177: break;
+        case 178: break;
         case 5: 
           { return JetTokens.AT        ;
           }
-        case 178: break;
+        case 179: break;
         case 72: 
           { return JetTokens.AS_SAFE;
           }
-        case 179: break;
+        case 180: break;
         case 24: 
           { return JetTokens.LPAR      ;
           }
-        case 180: break;
+        case 181: break;
         case 8: 
           { return JetTokens.MINUS     ;
           }
-        case 181: break;
+        case 182: break;
-        case 98: 
+        case 99: 
           { return JetTokens.FALSE_KEYWORD ;
           }
-        case 182: break;
+        case 183: break;
-        case 85: 
+        case 86: 
           { return JetTokens.TYPE_KEYWORD ;
           }
-        case 183: break;
+        case 184: break;
         case 66: 
           { commentDepth++;
           }
-        case 184: break;
+        case 185: break;
         case 73: 
           { return JetTokens.FUN_KEYWORD ;
           }
-        case 185: break;
+        case 186: break;
         case 47: 
           { return JetTokens.IS_KEYWORD ;
           }
-        case 186: break;
+        case 187: break;
         case 30: 
           { popState(); yypushback(1); return JetTokens.DANGLING_NEWLINE;
           }
-        case 187: break;
+        case 188: break;
         case 34: 
           { lBraceCount++; return JetTokens.LBRACE;
           }
-        case 188: break;
+        case 189: break;
-        case 90: 
+        case 91: 
           { yypushback(3); return JetTokens.EXCL;
           }
-        case 189: break;
+        case 190: break;
         case 42: 
           { return JetTokens.DIVEQ     ;
           }
-        case 190: break;
+        case 191: break;
-        case 87: 
+        case 88: 
           { return JetTokens.ELSE_KEYWORD ;
           }
-        case 191: break;
+        case 192: break;
         case 51: 
           { return JetTokens.AS_KEYWORD ;
           }
-        case 192: break;
+        case 193: break;
         case 48: 
           { return JetTokens.IN_KEYWORD ;
           }
-        case 193: break;
+        case 194: break;
         case 57: 
           { return JetTokens.EQEQ      ;
           }
-        case 194: break;
+        case 195: break;
         case 82: 
           { return JetTokens.EQEQEQ    ;
           }
-        case 195: break;
+        case 196: break;
         case 76: 
           { return JetTokens.VAL_KEYWORD ;
           }
-        case 196: break;
+        case 197: break;
-        case 89: 
+        case 90: 
           { return JetTokens.CAPITALIZED_THIS_KEYWORD ;
           }
-        case 197: break;
+        case 198: break;
         case 50: 
           { return JetTokens.MULTEQ    ;
           }
-        case 198: break;
+        case 199: break;
         case 11: 
           { return JetTokens.LBRACE    ;
           }
-        case 199: break;
+        case 200: break;
-        case 99: 
+        case 100: 
           { return JetTokens.OBJECT_KEYWORD ;
           }
-        case 200: break;
+        case 201: break;
-        case 96: 
+        case 97: 
           { return JetTokens.BREAK_KEYWORD ;
           }
-        case 201: break;
+        case 202: break;
-        case 93: 
+        case 83: 
+          { return JetTokens.BLOCK_COMMENT;
+          }
+        case 203: break;
+        case 94: 
           { return JetTokens.TRAIT_KEYWORD ;
           }
-        case 202: break;
+        case 204: break;
         case 33: 
           { 
           }
-        case 203: break;
+        case 205: break;
         case 16: 
           { return JetTokens.HASH      ;
           }
-        case 204: break;
+        case 206: break;
         default:
           if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
             zzAtEOF = true;
@@ -1327,14 +1323,14 @@ class _JetLexer implements FlexLexer {
         zzStartRead = commentStart;
         return commentStateToTokenType(state);
             }
-            case 230: break;
+            case 231: break;
             case DOC_COMMENT: {
               int state = yystate();
         popState();
         zzStartRead = commentStart;
         return commentStateToTokenType(state);
             }
-            case 231: break;
+            case 232: break;
             default:
             return null;
             }

compiler/testData/diagnostics/tests/nullabilityAndAutoCasts/AssertNotNull.jet

@@ -0,0 +1,35 @@
+fun main(args : Array<String>) {
+    val a : Int? = null
+    val b : Int? = null
+    a!! : Int
+    a!! + 2
+    a!!.plus(2)
+    a!!.plus(b!!)
+    2.plus(b!!)
+    2 + b!!
+
+    val c = 1
+    c<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
+
+    val d : Any? = null
+
+    if (d != null) {
+        d<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
+    }
+
+    if (d is String) {
+        d<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
+    }
+
+    if (d is String?) {
+        if (d != null) {
+            d<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
+        }
+        if (d is String) {
+            d<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
+        }
+    }
+
+    val <!UNUSED_VARIABLE!>f<!> : String = <!TYPE_MISMATCH!>a!!<!>
+    <!TYPE_MISMATCH!>a!!<!> : String
+}

compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.jet

@@ -0,0 +1,16 @@
+fun main(args : Array<String>) {
+    val a : Int? = null;
+    var v = 1
+    val <!UNUSED_VARIABLE!>b<!> : String = <!TYPE_MISMATCH!>v<!>;
+    val <!UNUSED_VARIABLE!>f<!> : String = <!TYPE_MISMATCH!>a!!<!>;
+    val <!UNUSED_VARIABLE!>g<!> : String = <!TYPE_MISMATCH!>v++<!>;
+    val <!UNUSED_VARIABLE!>g1<!> : String = <!TYPE_MISMATCH!>++v<!>;
+    val <!UNUSED_VARIABLE!>h<!> : String = <!TYPE_MISMATCH!>v--<!>;
+    val <!UNUSED_VARIABLE!>h1<!> : String = <!TYPE_MISMATCH!>--v<!>;
+    val <!UNUSED_VARIABLE!>i<!> : String = <!TYPE_MISMATCH!>!true<!>;
+    val <!UNUSED_VARIABLE!>j<!> : String = <!TYPE_MISMATCH!>@foo <!ERROR_COMPILE_TIME_VALUE!>true<!><!>;
+    val <!UNUSED_VARIABLE!>j1<!> : String = <!TYPE_MISMATCH!>@ <!ERROR_COMPILE_TIME_VALUE!>true<!><!>;
+    val <!UNUSED_VARIABLE!>j2<!> : String = <!TYPE_MISMATCH!>@@ <!ERROR_COMPILE_TIME_VALUE!>true<!><!>;
+    val <!UNUSED_VARIABLE!>k<!> : String = <!TYPE_MISMATCH!>-1<!>;
+    val <!UNUSED_VARIABLE!>l<!> : String = <!TYPE_MISMATCH!>+1<!>;
+}

compiler/testData/psi/AssertNotNull.jet

@@ -0,0 +1,10 @@
+fun main(args : Array<String>) {
+    !true;
+    !!true;
+    !!!true;
+    !!!!true;
+    true!!!
+    true!!!!
+    true!!and(false)
+    true!!.and(false)
+}

compiler/testData/psi/AssertNotNull.txt

@@ -0,0 +1,126 @@
+JetFile: AssertNotNull.jet
+  NAMESPACE_HEADER
+    <empty list>
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('main')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('args')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Array')
+            TYPE_ARGUMENT_LIST
+              PsiElement(LT)('<')
+              TYPE_PROJECTION
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('String')
+              PsiElement(GT)('>')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(EXCL)('!')
+        BOOLEAN_CONSTANT
+          PsiElement(true)('true')
+      PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace('\n    ')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(EXCL)('!')
+        PREFIX_EXPRESSION
+          OPERATION_REFERENCE
+            PsiElement(EXCL)('!')
+          BOOLEAN_CONSTANT
+            PsiElement(true)('true')
+      PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace('\n    ')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(EXCL)('!')
+        PREFIX_EXPRESSION
+          OPERATION_REFERENCE
+            PsiElement(EXCL)('!')
+          PREFIX_EXPRESSION
+            OPERATION_REFERENCE
+              PsiElement(EXCL)('!')
+            BOOLEAN_CONSTANT
+              PsiElement(true)('true')
+      PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace('\n    ')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(EXCL)('!')
+        PREFIX_EXPRESSION
+          OPERATION_REFERENCE
+            PsiElement(EXCL)('!')
+          PREFIX_EXPRESSION
+            OPERATION_REFERENCE
+              PsiElement(EXCL)('!')
+            PREFIX_EXPRESSION
+              OPERATION_REFERENCE
+                PsiElement(EXCL)('!')
+              BOOLEAN_CONSTANT
+                PsiElement(true)('true')
+      PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace('\n    ')
+      POSTFIX_EXPRESSION
+        BOOLEAN_CONSTANT
+          PsiElement(true)('true')
+        OPERATION_REFERENCE
+          PsiElement(EXCLEXCL)('!!')
+      PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+        PsiElement(EXCL)('!')
+      PsiWhiteSpace('\n    ')
+      POSTFIX_EXPRESSION
+        POSTFIX_EXPRESSION
+          BOOLEAN_CONSTANT
+            PsiElement(true)('true')
+          OPERATION_REFERENCE
+            PsiElement(EXCLEXCL)('!!')
+        OPERATION_REFERENCE
+          PsiElement(EXCLEXCL)('!!')
+      PsiWhiteSpace('\n    ')
+      BINARY_EXPRESSION
+        POSTFIX_EXPRESSION
+          BOOLEAN_CONSTANT
+            PsiElement(true)('true')
+          OPERATION_REFERENCE
+            PsiElement(EXCLEXCL)('!!')
+        OPERATION_REFERENCE
+          PsiElement(IDENTIFIER)('and')
+        PARENTHESIZED
+          PsiElement(LPAR)('(')
+          BOOLEAN_CONSTANT
+            PsiElement(false)('false')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n    ')
+      DOT_QUALIFIED_EXPRESSION
+        POSTFIX_EXPRESSION
+          BOOLEAN_CONSTANT
+            PsiElement(true)('true')
+          OPERATION_REFERENCE
+            PsiElement(EXCLEXCL)('!!')
+        PsiElement(DOT)('.')
+        CALL_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('and')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            VALUE_ARGUMENT
+              BOOLEAN_CONSTANT
+                PsiElement(false)('false')
+            PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/NestedComments.jet

@@ -10,10 +10,10 @@ b
 b
 /***/
 b
-/**/***/*/
+/** /***/*/
 b
 /** /**
 
 */***/
 b
-}
+}

compiler/testData/psi/NestedComments.txt

@@ -17,11 +17,27 @@ JetFile: NestedComments.jet
       REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('b')
       PsiWhiteSpace('\n')
-      PsiComment(DOC_COMMENT)('/**/\nb\n/* */\nb\n/*/**/*/\nb\n/***/\nb\n/**/***/')
+      PsiComment(BLOCK_COMMENT)('/**/')
-      PsiErrorElement:Expecting an element
+      PsiWhiteSpace('\n')
-        PsiElement(MUL)('*')
+      REFERENCE_EXPRESSION
-      PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+        PsiElement(IDENTIFIER)('b')
-        PsiElement(DIV)('/')
+      PsiWhiteSpace('\n')
+      PsiComment(BLOCK_COMMENT)('/* */')
+      PsiWhiteSpace('\n')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n')
+      PsiComment(BLOCK_COMMENT)('/*/**/*/')
+      PsiWhiteSpace('\n')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n')
+      PsiComment(DOC_COMMENT)('/***/')
+      PsiWhiteSpace('\n')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n')
+      PsiComment(DOC_COMMENT)('/** /***/*/')
       PsiWhiteSpace('\n')
       REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('b')

grammar/src/expressions.grm

@@ -212,7 +212,7 @@ prefixUnaryOperation
   ;
 
 postfixUnaryOperation
-  : "++" : "--"
+  : "++" : "--" : "!!"
   : callSuffix
   : arrayAccess
   : memberAccessOperation postfixUnaryExpression // TODO: Review

idea/src/org/jetbrains/jet/plugin/annotations/DebugInfoAnnotator.java

@@ -50,7 +50,7 @@ import static org.jetbrains.jet.lexer.JetTokens.*;
  */
 public class DebugInfoAnnotator implements Annotator {
 
-    public static final TokenSet EXCLUDED = TokenSet.create(COLON, AS_KEYWORD, AS_SAFE, IS_KEYWORD, NOT_IS, OROR, ANDAND, EQ, EQEQEQ, EXCLEQEQEQ, ELVIS);
+    public static final TokenSet EXCLUDED = TokenSet.create(COLON, AS_KEYWORD, AS_SAFE, IS_KEYWORD, NOT_IS, OROR, ANDAND, EQ, EQEQEQ, EXCLEQEQEQ, ELVIS, EXCLEXCL);
 
     private static volatile boolean debugInfoEnabled = true;
 

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

@@ -30,8 +30,7 @@ import com.intellij.util.Consumer;
 import com.intellij.util.ProcessingContext;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lexer.JetTokens;
@@ -41,22 +40,27 @@ import org.jetbrains.jet.plugin.compiler.WholeProjectAnalyzerFacade;
 import org.jetbrains.jet.plugin.references.JetSimpleNameReference;
 
 import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
 
 /**
  * @author Nikolay Krasko
  */
 public class JetCompletionContributor extends CompletionContributor {
 
+    private static class CompletionSession {
+        public boolean isSomethingAdded = false;
+        public int customInvocationCount = 0;
+    }
+
     public JetCompletionContributor() {
         extend(CompletionType.BASIC, PlatformPatterns.psiElement(),
                new CompletionProvider<CompletionParameters>() {
                    @Override
                    protected void addCompletions(@NotNull CompletionParameters parameters, ProcessingContext context,
                                                  @NotNull CompletionResultSet result) {
+                       result.restartCompletionWhenNothingMatches();
 
-                       Set<LookupPositionObject> positions = new HashSet<LookupPositionObject>();
+                       CompletionSession session = new CompletionSession();
+                       session.customInvocationCount = parameters.getInvocationCount();
 
                        PsiElement position = parameters.getPosition();
                        if (!(position.getContainingFile() instanceof JetFile)) {
@@ -65,49 +69,74 @@ public class JetCompletionContributor extends CompletionContributor {
 
                        JetSimpleNameReference jetReference = getJetReference(parameters);
                        if (jetReference != null) {
+                           completeForReference(parameters, result, position, jetReference, session);
 
-                           // Prevent from adding reference variants from standard reference contributor
+                           if (!session.isSomethingAdded && session.customInvocationCount == 0) {
-                           result.stopHere();
+                               // Rerun completion if nothing was found
-
+                               session.customInvocationCount = 1;
-                           if (isOnlyKeywordCompletion(position)) {
+                               completeForReference(parameters, result, position, jetReference, session);
-                               return;
-                           }
-
-                           if (shouldRunTypeCompletionOnly(position, jetReference)) {
-                               addClasses(parameters, result);
-                               return;
-                           }
-
-                           for (Object variant : jetReference.getVariants()) {
-                               addReferenceVariant(result, variant, positions);
-                           }
-
-                           String prefix = result.getPrefixMatcher().getPrefix();
-
-                           // Try to avoid computing not-imported descriptors for empty prefix
-                           if (prefix.isEmpty()) {
-                               if (parameters.getInvocationCount() < 2) {
-                                   return;
-                               }
-
-                               if (PsiTreeUtil.getParentOfType(jetReference.getElement(), JetDotQualifiedExpression.class) == null) {
-                                   return;
-                               }
-                           }
-
-                           if (shouldRunTopLevelCompletion(parameters, prefix)) {
-                               addClasses(parameters, result);
-                               addJetTopLevelFunctions(jetReference.getExpression(), result, position, positions);
-                           }
-
-                           if (shouldRunExtensionsCompletion(parameters, prefix)) {
-                               addJetExtensions(jetReference.getExpression(), result, position);
                            }
                        }
                    }
                });
     }
 
+    private static void completeForReference(
+        @NotNull CompletionParameters parameters,
+        @NotNull CompletionResultSet result,
+        @NotNull PsiElement position,
+        @NotNull JetSimpleNameReference jetReference,
+        @NotNull CompletionSession session
+    ) {
+        // Prevent from adding reference variants from standard reference contributor
+        result.stopHere();
+
+        if (isOnlyKeywordCompletion(position)) {
+            return;
+        }
+
+        if (shouldRunTypeCompletionOnly(position, jetReference)) {
+            if (session.customInvocationCount > 0) {
+                addClasses(parameters, result);
+            }
+            else {
+                for (Object variant : jetReference.getVariants()) {
+                    if (isTypeDeclaration(variant)) {
+                        addReferenceVariant(result, variant, session);
+                    }
+                }
+            }
+
+            return;
+        }
+
+        for (Object variant : jetReference.getVariants()) {
+            addReferenceVariant(result, variant, session);
+        }
+
+        String prefix = result.getPrefixMatcher().getPrefix();
+
+        // Try to avoid computing not-imported descriptors for empty prefix
+        if (prefix.isEmpty()) {
+            if (session.customInvocationCount < 2) {
+                return;
+            }
+
+            if (PsiTreeUtil.getParentOfType(jetReference.getElement(), JetDotQualifiedExpression.class) == null) {
+                return;
+            }
+        }
+
+        if (shouldRunTopLevelCompletion(parameters, session)) {
+            addClasses(parameters, result);
+            addJetTopLevelFunctions(jetReference.getExpression(), result, position, session);
+        }
+
+        if (shouldRunExtensionsCompletion(parameters, prefix, session)) {
+            addJetExtensions(jetReference.getExpression(), result, position);
+        }
+    }
+
     private static boolean isOnlyKeywordCompletion(PsiElement position) {
         return PsiTreeUtil.getParentOfType(position, JetModifierList.class) != null;
     }
@@ -135,18 +164,32 @@ public class JetCompletionContributor extends CompletionContributor {
     private static void addReferenceVariant(
             @NotNull CompletionResultSet result,
             @NotNull Object variant,
-            @NotNull Set<LookupPositionObject> positions) {
+            @NotNull CompletionSession session) {
 
         if (variant instanceof LookupElement) {
-            addCompletionToResult(result, (LookupElement) variant, positions);
+            addCompletionToResult(result, (LookupElement) variant, session);
         }
         else {
-            addCompletionToResult(result, LookupElementBuilder.create(variant.toString()), positions);
+            addCompletionToResult(result, LookupElementBuilder.create(variant.toString()), session);
         }
     }
 
+    public static boolean isTypeDeclaration(@NotNull Object variant) {
+        if (variant instanceof LookupElement) {
+            Object object = ((LookupElement)variant).getObject();
+            if (object instanceof JetLookupObject) {
+                DeclarationDescriptor descriptor = ((JetLookupObject) object).getDescriptor();
+                return (descriptor instanceof ClassDescriptor) ||
+                       (descriptor instanceof NamespaceDescriptor) ||
+                       (descriptor instanceof TypeParameterDescriptor);
+            }
+        }
+
+        return false;
+    }
+
     private static void addJetTopLevelFunctions(JetSimpleNameExpression expression, @NotNull CompletionResultSet result, @NotNull PsiElement position,
-                                                @NotNull Set<LookupPositionObject> positions) {
+                                                @NotNull CompletionSession session) {
 
         String actualPrefix = result.getPrefixMatcher().getPrefix();
 
@@ -161,7 +204,7 @@ public class JetCompletionContributor extends CompletionContributor {
         for (String name : functionNames) {
             if (name.contains(actualPrefix)) {
                 for (FunctionDescriptor function : namesCache.getTopLevelFunctionDescriptorsByName(name, expression, scope)) {
-                    addCompletionToResult(result, DescriptorLookupConverter.createLookupElement(resolutionContext, function), positions);
+                    addCompletionToResult(result, DescriptorLookupConverter.createLookupElement(resolutionContext, function), session);
                 }
             }
         }
@@ -194,8 +237,8 @@ public class JetCompletionContributor extends CompletionContributor {
         return false;
     }
 
-    private static boolean shouldRunTopLevelCompletion(@NotNull CompletionParameters parameters, String prefix) {
+    private static boolean shouldRunTopLevelCompletion(@NotNull CompletionParameters parameters, CompletionSession session) {
-        if (parameters.getInvocationCount() == 0 && prefix.length() < 3) {
+        if (session.customInvocationCount == 0) {
             return false;
         }
 
@@ -212,8 +255,8 @@ public class JetCompletionContributor extends CompletionContributor {
         return false;
     }
 
-    private static boolean shouldRunExtensionsCompletion(CompletionParameters parameters, String prefix) {
+    private static boolean shouldRunExtensionsCompletion(CompletionParameters parameters, String prefix, CompletionSession session) {
-        if (parameters.getInvocationCount() == 0 && prefix.length() < 3) {
+        if (session.customInvocationCount == 0 && prefix.length() < 3) {
             return false;
         }
 
@@ -243,36 +286,28 @@ public class JetCompletionContributor extends CompletionContributor {
     private static void addCompletionToResult(
             @NotNull CompletionResultSet result,
             @NotNull LookupElement element,
-            @NotNull Set<LookupPositionObject> positions) {
+            @NotNull CompletionSession session) {
 
-//        LookupPositionObject lookupPosition = getLookupPosition(element);
+        if (result.getPrefixMatcher().prefixMatches(element)) {
-//        if (lookupPosition != null) {
-//            if (!positions.contains(lookupPosition)) {
-//                positions.add(lookupPosition);
-//                result.addElement(element);
-//            }
-//
-//            // There is already an element with same position - ignore duplicate
-//        }
-//        else {
             result.addElement(element);
-//         }
+            session.isSomethingAdded = true;
+        }
     }
 
-    private static LookupPositionObject getLookupPosition(LookupElement element) {
+    //private static LookupPositionObject getLookupPosition(LookupElement element) {
-        Object lookupObject = element.getObject();
+    //    Object lookupObject = element.getObject();
-        if (lookupObject instanceof PsiElement) {
+    //    if (lookupObject instanceof PsiElement) {
-            return new LookupPositionObject((PsiElement) lookupObject);
+    //        return new LookupPositionObject((PsiElement) lookupObject);
-        }
+    //    }
-        else if (lookupObject instanceof JetLookupObject) {
+    //    else if (lookupObject instanceof JetLookupObject) {
-            PsiElement psiElement = ((JetLookupObject) lookupObject).getPsiElement();
+    //        PsiElement psiElement = ((JetLookupObject) lookupObject).getPsiElement();
-            if (psiElement != null) {
+    //        if (psiElement != null) {
-                return new LookupPositionObject(psiElement);
+    //            return new LookupPositionObject(psiElement);
-            }
+    //        }
-        }
+    //    }
-
+    //
-        return null;
+    //    return null;
-    }
+    //}
 
     @Override
     public void beforeCompletion(@NotNull CompletionInitializationContext context) {

idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java

@@ -75,7 +75,7 @@ public class JetFormattingModelBuilder implements FormattingModelBuilder {
                 .aroundInside(TokenSet.create(LT, GT, LTEQ, GTEQ), BINARY_EXPRESSION).spaceIf(jetCommonSettings.SPACE_AROUND_RELATIONAL_OPERATORS)
                 .around(TokenSet.create(PLUS, MINUS)).spaceIf(jetCommonSettings.SPACE_AROUND_ADDITIVE_OPERATORS)
                 .aroundInside(TokenSet.create(MUL, DIV, PERC), BINARY_EXPRESSION).spaceIf(jetCommonSettings.SPACE_AROUND_MULTIPLICATIVE_OPERATORS)
-                .around(TokenSet.create(PLUSPLUS, MINUSMINUS, MINUS, PLUS, EXCL)).spaceIf(jetCommonSettings.SPACE_AROUND_UNARY_OPERATOR)
+                .around(TokenSet.create(PLUSPLUS, MINUSMINUS, EXCLEXCL, MINUS, PLUS, EXCL)).spaceIf(jetCommonSettings.SPACE_AROUND_UNARY_OPERATOR)
                 .around(RANGE).spaceIf(jetSettings.SPACE_AROUND_RANGE)
 
                 .beforeInside(BLOCK, FUN).spaceIf(jetCommonSettings.SPACE_BEFORE_METHOD_LBRACE)

idea/testData/completion/basic/OnlyScopedClassesWithoutExplicit.kt

@@ -0,0 +1,10 @@
+package first
+
+fun firstFun() {
+  val a = In<caret>
+}
+
+// RUNTIME: 1
+// TIME: 0
+// EXIST: Int~(jet)
+// ABSENT: Int~(jet.runtime.SharedVar)

idea/tests/org/jetbrains/jet/completion/ExpectedCompletionUtils.java

@@ -16,8 +16,13 @@
 
 package org.jetbrains.jet.completion;
 
+import com.google.common.base.Function;
+import com.google.common.collect.Collections2;
+import com.intellij.codeInsight.lookup.LookupElement;
+import com.intellij.codeInsight.lookup.LookupElementPresentation;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.ArrayUtil;
+import junit.framework.Assert;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -34,6 +39,39 @@ import java.util.List;
  * @author Nikolay Krasko
  */
 public class ExpectedCompletionUtils {
+
+    public static class CompletionProposal {
+        public static final String TAIL_FLAG = "~";
+
+        private final String lookupString;
+        private final String tailString;
+
+
+
+        public CompletionProposal(@NotNull String lookupString, @Nullable String tailString) {
+            this.lookupString = lookupString;
+            this.tailString = tailString != null ? tailString.trim() : null;
+        }
+
+        public boolean isSuitable(CompletionProposal proposal) {
+            if (proposal.tailString != null) {
+                if (!proposal.tailString.equals(tailString)) {
+                    return false;
+                }
+            }
+
+            return lookupString.equals(proposal.lookupString);
+        }
+
+        @Override
+        public String toString() {
+            if (tailString != null) {
+                return lookupString + TAIL_FLAG + tailString;
+            }
+
+            return lookupString;
+        }
+    }
     
     public static final String EXIST_LINE_PREFIX = "// EXIST:";
     public static final String ABSENT_LINE_PREFIX = "// ABSENT:";
@@ -57,13 +95,30 @@ public class ExpectedCompletionUtils {
     }
 
     @NotNull
-    public String[] itemsShouldExist(String fileText) {
+    public CompletionProposal[] itemsShouldExist(String fileText) {
-        return findListWithPrefix(existLinePrefix, fileText);
+        return processProposalAssertions(existLinePrefix, fileText);
     }
 
     @NotNull
-    public String[] itemsShouldAbsent(String fileText) {
+    public CompletionProposal[] itemsShouldAbsent(String fileText) {
-        return findListWithPrefix(absentLinePrefix, fileText);
+        return processProposalAssertions(absentLinePrefix, fileText);
+    }
+
+    public static CompletionProposal[] processProposalAssertions(String prefix, String fileText) {
+        List<CompletionProposal> proposals = new ArrayList<CompletionProposal>();
+        for (String proposalStr : findListWithPrefix(prefix, fileText)) {
+            int tailChar = proposalStr.indexOf(CompletionProposal.TAIL_FLAG);
+
+            if (tailChar > 0) {
+                proposals.add(new CompletionProposal(proposalStr.substring(0, tailChar),
+                                                     proposalStr.substring(tailChar + 1, proposalStr.length())));
+            }
+            else {
+                proposals.add(new CompletionProposal(proposalStr, null));
+            }
+        }
+
+        return ArrayUtil.toObjectArray(proposals, CompletionProposal.class);
     }
 
     @Nullable
@@ -137,4 +192,57 @@ public class ExpectedCompletionUtils {
 
         return result;
     }
+
+    protected static void assertContainsRenderedItems(CompletionProposal[] expected, LookupElement[] items) {
+        List<CompletionProposal> itemsInformation = getItemsInformation(items);
+
+        for (CompletionProposal expectedProposal : expected) {
+            boolean isFound = false;
+
+            for (CompletionProposal proposal : itemsInformation) {
+                if (proposal.isSuitable(expectedProposal)) {
+                    isFound = true;
+                    break;
+                }
+            }
+
+            Assert.assertTrue("Expected '" + expectedProposal + "' not found in " + listToString(itemsInformation), isFound);
+        }
+    }
+
+    protected static void assertNotContainsRenderedItems(CompletionProposal[] unexpected,LookupElement[] items) {
+        List<CompletionProposal> itemsInformation = getItemsInformation(items);
+
+        for (CompletionProposal unexpectedProposal : unexpected) {
+            for (CompletionProposal proposal : itemsInformation) {
+                Assert.assertFalse("Unexpected '" + unexpectedProposal + "' presented in " + listToString(itemsInformation),
+                                   proposal.isSuitable(unexpectedProposal));
+            }
+        }
+    }
+
+    protected static List<CompletionProposal> getItemsInformation(LookupElement[] items) {
+        final LookupElementPresentation presentation = new LookupElementPresentation();
+
+        List<CompletionProposal> result = new ArrayList<CompletionProposal>();
+        if (items != null) {
+            for (LookupElement item : items) {
+                item.renderElement(presentation);
+                result.add(new ExpectedCompletionUtils.CompletionProposal(item.getLookupString(), presentation.getTailText()));
+            }
+        }
+
+        return result;
+    }
+
+    protected static String listToString(List<ExpectedCompletionUtils.CompletionProposal> items) {
+        return StringUtil.join(
+            Collections2.transform(items, new Function<CompletionProposal, String>() {
+                @Override
+                public String apply(@Nullable CompletionProposal proposal) {
+                    assert proposal != null;
+                    return proposal.toString();
+                }
+            }), "\n");
+    }
 }

idea/tests/org/jetbrains/jet/completion/JetBasicCompletionTest.java

@@ -97,6 +97,10 @@ public class JetBasicCompletionTest extends JetCompletionTestBase {
         doTest();
     }
 
+    public void testOnlyScopedClassesWithoutExplicit() {
+        doTest();
+    }
+
     public void testOverloadFunctions() {
         doTest();
     }

idea/tests/org/jetbrains/jet/completion/JetCompletionMultiTestBase.java

@@ -17,10 +17,6 @@
 package org.jetbrains.jet.completion;
 
 import com.intellij.codeInsight.completion.CompletionTestCase;
-import com.intellij.codeInsight.lookup.LookupElement;
-import com.intellij.util.containers.HashSet;
-
-import java.util.Set;
 
 /**
  * @author Nikolay Krasko
@@ -41,8 +37,8 @@ public abstract class JetCompletionMultiTestBase extends CompletionTestCase {
             final String fileText = getFile().getText();
             final ExpectedCompletionUtils completionUtils = new ExpectedCompletionUtils();
 
-            assertContainsItems(completionUtils.itemsShouldExist(fileText));
+            ExpectedCompletionUtils.assertContainsRenderedItems(completionUtils.itemsShouldExist(fileText), myItems);
-            assertNotContainItems(completionUtils.itemsShouldAbsent(fileText));
+            ExpectedCompletionUtils.assertNotContainsRenderedItems(completionUtils.itemsShouldAbsent(fileText), myItems);
 
             Integer itemsNumber = completionUtils.getExpectedNumber(fileText);
             if (itemsNumber != null) {
@@ -56,33 +52,4 @@ public abstract class JetCompletionMultiTestBase extends CompletionTestCase {
     protected void doFileTest() {
         doFileTest(1);
     }
-
-    // Copied from com.intellij.codeInsight.completion.LightCompletionTestCase
-    protected void assertContainsItems(final String... expected) {
-        final Set<String> actual = getLookupStrings();
-        for (String s : expected) {
-            assertTrue("Expected '" + s + "' not found in " + actual,
-                       actual.contains(s));
-        }
-    }
-
-    // Copied from com.intellij.codeInsight.completion.LightCompletionTestCase
-    protected void assertNotContainItems(final String... unexpected) {
-        final Set<String> actual = getLookupStrings();
-        for (String s : unexpected) {
-            assertFalse("Unexpected '" + s + "' presented in " + actual,
-                        actual.contains(s));
-        }
-    }
-
-    // Copied from com.intellij.codeInsight.completion.LightCompletionTestCase
-    private Set<String> getLookupStrings() {
-        final Set<String> actual = new HashSet<String>();
-        if (myItems != null) {
-            for (LookupElement lookupElement : myItems) {
-                actual.add(lookupElement.getLookupString());
-            }
-        }
-        return actual;
-    }
 }

idea/tests/org/jetbrains/jet/completion/JetCompletionTestBase.java

@@ -59,14 +59,14 @@ public abstract class JetCompletionTestBase extends LightCompletionTestCase {
 
                 complete(completionTime == null ? 1 : completionTime);
 
-                final String[] expected = completionUtils.itemsShouldExist(fileText);
+                ExpectedCompletionUtils.CompletionProposal[] expected = completionUtils.itemsShouldExist(fileText);
-                final String[] unexpected = completionUtils.itemsShouldAbsent(fileText);
+                ExpectedCompletionUtils.CompletionProposal[] unexpected = completionUtils.itemsShouldAbsent(fileText);
                 Integer itemsNumber = completionUtils.getExpectedNumber(fileText);
 
                 assertTrue("Should be some assertions about completion", expected.length != 0 || unexpected.length != 0 || itemsNumber != null);
 
-                assertContainsItems(expected);
+                ExpectedCompletionUtils.assertContainsRenderedItems(expected, myItems);
-                assertNotContainItems(unexpected);
+                ExpectedCompletionUtils.assertNotContainsRenderedItems(unexpected, myItems);
 
                 if (itemsNumber != null) {
                     assertEquals("Invalid number of completion items", itemsNumber.intValue(), myItems.length);