Merge branch 'master' of git://github.com/jgl87/kotlin

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -1902,6 +1902,20 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         JetExpression callee = expression.getCalleeExpression();
         assert callee != null;
 
+        DottedCallInfo dottedCallInfo = bindingContext.get(BindingContext.DOTTED_CALL_INFO, expression);
+        if (dottedCallInfo != null) {
+            ResolvedCall<? extends FunctionDescriptor> resolvedDotCall = dottedCallInfo.getResolvedCall();
+            FunctionDescriptor dotFunDescriptor = accessibleFunctionDescriptor(resolvedDotCall.getResultingDescriptor());
+
+            JetType dotType = dotFunDescriptor.getReturnType();
+            assert dotType != null : "can't resolve type of dot operation: " + dotFunDescriptor;
+
+            StackValue newReceiver = invokeFunction(dottedCallInfo.getCall(), receiver, resolvedDotCall);
+            if (!KotlinBuiltIns.getInstance().isUnit(dotType)) {
+                receiver = newReceiver;
+            }
+        }
+
         ResolvedCall<?> resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, callee);
         if (resolvedCall == null) {
             throw new CompilationException("Cannot resolve: " + callee.getText(), null, expression);

compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java

@@ -31,6 +31,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.CompileTimeConstantUtils;
+import org.jetbrains.jet.lang.resolve.calls.model.DottedCallInfo;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument;
 import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall;
@@ -784,6 +785,11 @@ public class JetControlFlowProcessor {
 
             generateInstructions(selectorExpression, NOT_IN_CONDITION);
 
+            DottedCallInfo dottedCallInfo = trace.get(BindingContext.DOTTED_CALL_INFO, selectorExpression);
+            if (dottedCallInfo != null) {
+                generateInstructions((JetCallExpression) dottedCallInfo.getCall().getCallElement(), NOT_IN_CONDITION);
+            }
+
             // receiver was generated for resolvedCall
             JetExpression calleeExpression = JetPsiUtil.getCalleeExpressionIfAny(selectorExpression);
             if (calleeExpression == null || getResolvedCall(calleeExpression) == null) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java

@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.TailRecursionKind;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystemCompleter;
+import org.jetbrains.jet.lang.resolve.calls.model.DottedCallInfo;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -79,6 +80,7 @@ public interface BindingContext {
 
     WritableSlice<JetTypeReference, JetType> TYPE = Slices.createSimpleSlice();
     WritableSlice<JetExpression, JetType> EXPRESSION_TYPE = new BasicWritableSlice<JetExpression, JetType>(DO_NOTHING);
+    WritableSlice<JetExpression, JetType> DOTTED_EXPRESSION_TYPE = new BasicWritableSlice<JetExpression, JetType>(DO_NOTHING);
     WritableSlice<JetExpression, JetType> EXPECTED_EXPRESSION_TYPE = new BasicWritableSlice<JetExpression, JetType>(DO_NOTHING);
     WritableSlice<JetExpression, DataFlowInfo> EXPRESSION_DATA_FLOW_INFO = new BasicWritableSlice<JetExpression, DataFlowInfo>(DO_NOTHING);
     WritableSlice<JetExpression, DataFlowInfo> DATAFLOW_INFO_AFTER_CONDITION = Slices.createSimpleSlice();
@@ -92,6 +94,8 @@ public interface BindingContext {
     WritableSlice<JetElement, ConstraintSystemCompleter> CONSTRAINT_SYSTEM_COMPLETER = new BasicWritableSlice<JetElement, ConstraintSystemCompleter>(DO_NOTHING);
     WritableSlice<JetElement, Call> CALL = new BasicWritableSlice<JetElement, Call>(DO_NOTHING);
 
+    WritableSlice<JetElement, DottedCallInfo> DOTTED_CALL_INFO = new BasicWritableSlice<JetElement, DottedCallInfo>(DO_NOTHING);
+
     @KotlinSignature("val AMBIGUOUS_REFERENCE_TARGET: WritableSlice<JetExpression, Collection<DeclarationDescriptor>>")
     WritableSlice<JetExpression, Collection<? extends DeclarationDescriptor>> AMBIGUOUS_REFERENCE_TARGET =
             new BasicWritableSlice<JetExpression, Collection<? extends DeclarationDescriptor>>(DO_NOTHING);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java

@@ -32,10 +32,10 @@ import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.context.CheckValueArgumentsMode;
 import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.context.TemporaryTraceAndCache;
+import org.jetbrains.jet.lang.resolve.calls.model.DottedCallInfo;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
-import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsImpl;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsUtil;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
@@ -451,6 +451,52 @@ public class CallExpressionResolver {
 
         context = context.replaceDataFlowInfo(receiverTypeInfo.getDataFlowInfo());
 
+        if (PsiTreeUtil.getParentOfType(expression, JetAnnotationEntry.class) == null) {
+            TemporaryTraceAndCache temporaryForDotOperation = TemporaryTraceAndCache.create(
+                    context, "trace to check dot operation", expression
+            );
+
+            JetCallExpression fakeOperation = (JetCallExpression) JetPsiFactory.createExpression(expression.getProject(), "dot()");
+            Call dotCall = CallMaker.makeCall(
+                    fakeOperation,
+                    new ExpressionReceiver(receiverExpression, receiverType),
+                    null,
+                    fakeOperation.getCalleeExpression(),
+                    Collections.<ValueArgument>emptyList()
+            );
+            OverloadResolutionResults<FunctionDescriptor> dotOperationDescriptors =
+                    expressionTypingServices.getCallResolver().resolveCallWithGivenName(
+                            context.replaceTraceAndCache(temporaryForDotOperation),
+                            dotCall,
+                            fakeOperation, Name.identifier("dot")
+                    );
+            JetType dotOperationType =
+                    OverloadResolutionResultsUtil.getResultingType(dotOperationDescriptors, context.contextDependency);
+
+            if (dotOperationDescriptors.isSingleResult() && dotOperationType != null) {
+                ResolvedCall<FunctionDescriptor> resolvedDotCall = dotOperationDescriptors.getResultingCall();
+                ((ResolvedCallWithTrace) resolvedDotCall).markCallAsCompleted();
+
+                DottedCallInfo dottedCallInfo = new DottedCallInfo(dotCall, resolvedDotCall);
+
+                context.trace.record(DOTTED_EXPRESSION_TYPE, receiverExpression, dotOperationType);
+                context.trace.record(DOTTED_CALL_INFO, selectorExpression, dottedCallInfo);
+                context.trace.record(RESOLVED_CALL, dotCall.getCalleeExpression(), resolvedDotCall);
+
+                if (!KotlinBuiltIns.getInstance().isUnit(dotOperationType)) {
+                    receiverType = dotOperationType;
+                    context = context.replaceDataFlowInfo(resolvedDotCall.getDataFlowInfoForArguments().getResultInfo());
+                }
+            }
+            else if (dotOperationDescriptors.isAmbiguity()) {
+                context.trace.report(
+                        OVERLOAD_RESOLUTION_AMBIGUITY.on(
+                                expression.getOperationTokenNode().getPsi(), dotOperationDescriptors.getResultingCalls()
+                        )
+                );
+            }
+        }
+
         JetTypeInfo selectorReturnTypeInfo = getSelectorReturnTypeInfo(
                 new ExpressionReceiver(receiverExpression, receiverType),
                 expression.getOperationTokenNode(), selectorExpression, context);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/DottedCallInfo.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.calls.model
+
+import org.jetbrains.jet.lang.psi.Call
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor
+import org.jetbrains.jet.lang.types.JetType
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
+
+class DottedCallInfo(val call: Call, val resolvedCall: ResolvedCall<out FunctionDescriptor>)

compiler/testData/cfg/basic/humbleSimplicityOfDots.instructions

@@ -0,0 +1,124 @@
+== dot ==
+fun Int.dot(): Int {
+    return this + 1
+}
+---------------------
+L0:
+  1 <START>
+  2 mark({ return this + 1 })
+    mark(this + 1)
+    r(this)
+    r(1)
+    call(+, plus)
+    ret(*) L1
+L1:
+  1 <END>                        NEXT:[<SINK>]
+error:
+    <ERROR>                      PREV:[]
+sink:
+    <SINK>                       PREV:[<ERROR>, <END>]
+=====================
+== dot ==
+fun String?.dot(): String = this ?: ""
+---------------------
+L0:
+  1 <START>
+    r(this)
+    jt(L2)      NEXT:[mark(""), <END>]
+    mark("")
+    r("")
+L1:
+L2:
+    <END>       NEXT:[<SINK>]             PREV:[jt(L2), r("")]
+error:
+    <ERROR>     PREV:[]
+sink:
+    <SINK>      PREV:[<ERROR>, <END>]
+=====================
+== i ==
+fun i(): Int? = null
+---------------------
+L0:
+  1 <START>
+    r(null)
+L1:
+    <END>      NEXT:[<SINK>]
+error:
+    <ERROR>    PREV:[]
+sink:
+    <SINK>     PREV:[<ERROR>, <END>]
+=====================
+== s ==
+fun s(): String? = null
+---------------------
+L0:
+  1 <START>
+    r(null)
+L1:
+    <END>      NEXT:[<SINK>]
+error:
+    <ERROR>    PREV:[]
+sink:
+    <SINK>     PREV:[<ERROR>, <END>]
+=====================
+== f ==
+fun f() : Unit {
+    2.toLong()
+    3.equals(4)
+    i()?.toLong()
+
+    "test".length
+    s().length()
+}
+---------------------
+L0:
+  1 <START>
+  2 mark({ 2.toLong() 3.equals(4) i()?.toLong() "test".length s().length() })
+    mark(2.toLong())
+    mark(toLong())
+    r(2)
+    call(toLong, toLong)
+    mark(dot())
+    r(2)
+    call(dot, dot)
+    mark(3.equals(4))
+    mark(equals(4))
+    r(3)
+    r(4)
+    call(equals, equals)
+    mark(dot())
+    r(3)
+    call(dot, dot)
+    mark(i()?.toLong())
+    mark(toLong())
+    mark(i())
+    call(i, i)
+    call(toLong, toLong)
+    mark(dot())
+    mark(i())
+    call(i, i)
+    call(dot, dot)
+    mark("test".length)
+    mark("test")
+    r("test")
+    r(length)
+    mark(dot())
+    mark("test")
+    r("test")
+    call(dot, dot)
+    mark(s().length())
+    mark(length())
+    mark(s())
+    call(s, s)
+    r(length)
+    mark(dot())
+    mark(s())
+    call(s, s)
+    call(dot, dot)
+L1:
+  1 <END>                                                                        NEXT:[<SINK>]
+error:
+    <ERROR>                                                                      PREV:[]
+sink:
+    <SINK>                                                                       PREV:[<ERROR>, <END>]
+=====================

compiler/testData/cfg/basic/humbleSimplicityOfDots.kt

@@ -0,0 +1,18 @@
+fun Int.dot(): Int {
+    return this + 1
+}
+
+fun String?.dot(): String = this ?: ""
+
+fun i(): Int? = null
+
+fun s(): String? = null
+
+fun f() : Unit {
+    2.toLong()
+    3.equals(4)
+    i()?.toLong()
+
+    "test".length
+    s().length()
+}

compiler/testData/codegen/box/dot/inTheVoidOfDots.kt

@@ -0,0 +1,22 @@
+class Foo {
+    fun foo(): String {
+        return "O"
+    }
+}
+
+class Bar {
+    fun bar(): String {
+        return ""
+    }
+}
+
+var t: String = ""
+
+fun Foo.dot() {
+    t = "K"
+}
+
+fun box(): String {
+    val f: Foo = Foo()
+    return f.foo() + t
+}

compiler/testData/codegen/box/dot/onlyDotCanKeepYouFromFailure.kt

@@ -0,0 +1,23 @@
+class Foo {
+    fun foo(): String {
+        return "FAIL"
+    }
+}
+
+class Bar {
+    fun bar(): String {
+        return "O"
+    }
+}
+
+var t: String = ""
+
+fun Foo.dot(): Bar {
+    t = "K"
+    return Bar()
+}
+
+fun box(): String {
+    val f: Foo = Foo()
+    return f.bar() + t
+}

compiler/testData/diagnostics/tests/dataFlow/nothingLikeDot.kt

@@ -0,0 +1,8 @@
+fun Any?.dot(): Nothing {
+    throw RuntimeException()
+}
+
+fun test(): String {
+    val s: String? = ""
+    <!UNREACHABLE_CODE!>return s.dot()<!>
+}

compiler/tests/org/jetbrains/jet/cfg/ControlFlowTestGenerated.java

@@ -86,6 +86,11 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
             doTest("compiler/testData/cfg/basic/EmptyFunction.kt");
         }
         
+        @TestMetadata("humbleSimplicityOfDots.kt")
+        public void testHumbleSimplicityOfDots() throws Exception {
+            doTest("compiler/testData/cfg/basic/humbleSimplicityOfDots.kt");
+        }
+        
         @TestMetadata("ShortFunction.kt")
         public void testShortFunction() throws Exception {
             doTest("compiler/testData/cfg/basic/ShortFunction.kt");

compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java

@@ -1957,6 +1957,11 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest("compiler/testData/diagnostics/tests/dataFlow/IsExpression.kt");
             }
             
+            @TestMetadata("nothingLikeDot.kt")
+            public void testNothingLikeDot() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/dataFlow/nothingLikeDot.kt");
+            }
+            
             @TestMetadata("WhenSubject.kt")
             public void testWhenSubject() throws Exception {
                 doTest("compiler/testData/diagnostics/tests/dataFlow/WhenSubject.kt");

compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java

@@ -31,7 +31,7 @@ import org.jetbrains.jet.codegen.generated.AbstractBlackBoxCodegenTest;
 /** This class is generated by {@link org.jetbrains.jet.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
 @SuppressWarnings("all")
 @TestMetadata("compiler/testData/codegen/box")
-@InnerTestClasses({BlackBoxCodegenTestGenerated.Arrays.class, BlackBoxCodegenTestGenerated.BinaryOp.class, BlackBoxCodegenTestGenerated.Bridges.class, BlackBoxCodegenTestGenerated.BuiltinStubMethods.class, BlackBoxCodegenTestGenerated.CallableReference.class, BlackBoxCodegenTestGenerated.Casts.class, BlackBoxCodegenTestGenerated.Classes.class, BlackBoxCodegenTestGenerated.Closures.class, BlackBoxCodegenTestGenerated.Constants.class, BlackBoxCodegenTestGenerated.ControlStructures.class, BlackBoxCodegenTestGenerated.DefaultArguments.class, BlackBoxCodegenTestGenerated.DelegatedProperty.class, BlackBoxCodegenTestGenerated.Elvis.class, BlackBoxCodegenTestGenerated.Enum.class, BlackBoxCodegenTestGenerated.ExclExcl.class, BlackBoxCodegenTestGenerated.ExtensionFunctions.class, BlackBoxCodegenTestGenerated.ExtensionProperties.class, BlackBoxCodegenTestGenerated.FakeOverride.class, BlackBoxCodegenTestGenerated.FieldRename.class, BlackBoxCodegenTestGenerated.Finally.class, BlackBoxCodegenTestGenerated.Functions.class, BlackBoxCodegenTestGenerated.InnerNested.class, BlackBoxCodegenTestGenerated.Instructions.class, BlackBoxCodegenTestGenerated.Intrinsics.class, BlackBoxCodegenTestGenerated.Labels.class, BlackBoxCodegenTestGenerated.LocalClasses.class, BlackBoxCodegenTestGenerated.MultiDecl.class, BlackBoxCodegenTestGenerated.Objects.class, BlackBoxCodegenTestGenerated.OperatorConventions.class, BlackBoxCodegenTestGenerated.Package.class, BlackBoxCodegenTestGenerated.PrimitiveTypes.class, BlackBoxCodegenTestGenerated.Properties.class, BlackBoxCodegenTestGenerated.Reflection.class, BlackBoxCodegenTestGenerated.SafeCall.class, BlackBoxCodegenTestGenerated.SamConstructors.class, BlackBoxCodegenTestGenerated.Strings.class, BlackBoxCodegenTestGenerated.Super.class, BlackBoxCodegenTestGenerated.ToArray.class, BlackBoxCodegenTestGenerated.Traits.class, BlackBoxCodegenTestGenerated.TypeInfo.class, BlackBoxCodegenTestGenerated.TypeMapping.class, BlackBoxCodegenTestGenerated.UnaryOp.class, BlackBoxCodegenTestGenerated.Unit.class, BlackBoxCodegenTestGenerated.Vararg.class, BlackBoxCodegenTestGenerated.When.class})
+@InnerTestClasses({BlackBoxCodegenTestGenerated.Arrays.class, BlackBoxCodegenTestGenerated.BinaryOp.class, BlackBoxCodegenTestGenerated.Bridges.class, BlackBoxCodegenTestGenerated.BuiltinStubMethods.class, BlackBoxCodegenTestGenerated.CallableReference.class, BlackBoxCodegenTestGenerated.Casts.class, BlackBoxCodegenTestGenerated.Classes.class, BlackBoxCodegenTestGenerated.Closures.class, BlackBoxCodegenTestGenerated.Constants.class, BlackBoxCodegenTestGenerated.ControlStructures.class, BlackBoxCodegenTestGenerated.DefaultArguments.class, BlackBoxCodegenTestGenerated.DelegatedProperty.class, BlackBoxCodegenTestGenerated.Dot.class, BlackBoxCodegenTestGenerated.Elvis.class, BlackBoxCodegenTestGenerated.Enum.class, BlackBoxCodegenTestGenerated.ExclExcl.class, BlackBoxCodegenTestGenerated.ExtensionFunctions.class, BlackBoxCodegenTestGenerated.ExtensionProperties.class, BlackBoxCodegenTestGenerated.FakeOverride.class, BlackBoxCodegenTestGenerated.FieldRename.class, BlackBoxCodegenTestGenerated.Finally.class, BlackBoxCodegenTestGenerated.Functions.class, BlackBoxCodegenTestGenerated.InnerNested.class, BlackBoxCodegenTestGenerated.Instructions.class, BlackBoxCodegenTestGenerated.Intrinsics.class, BlackBoxCodegenTestGenerated.Labels.class, BlackBoxCodegenTestGenerated.LocalClasses.class, BlackBoxCodegenTestGenerated.MultiDecl.class, BlackBoxCodegenTestGenerated.Objects.class, BlackBoxCodegenTestGenerated.OperatorConventions.class, BlackBoxCodegenTestGenerated.Package.class, BlackBoxCodegenTestGenerated.PrimitiveTypes.class, BlackBoxCodegenTestGenerated.Properties.class, BlackBoxCodegenTestGenerated.Reflection.class, BlackBoxCodegenTestGenerated.SafeCall.class, BlackBoxCodegenTestGenerated.SamConstructors.class, BlackBoxCodegenTestGenerated.Strings.class, BlackBoxCodegenTestGenerated.Super.class, BlackBoxCodegenTestGenerated.ToArray.class, BlackBoxCodegenTestGenerated.Traits.class, BlackBoxCodegenTestGenerated.TypeInfo.class, BlackBoxCodegenTestGenerated.TypeMapping.class, BlackBoxCodegenTestGenerated.UnaryOp.class, BlackBoxCodegenTestGenerated.Unit.class, BlackBoxCodegenTestGenerated.Vararg.class, BlackBoxCodegenTestGenerated.When.class})
 public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
     public void testAllFilesPresentInBox() throws Exception {
         JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), true);
@@ -2246,6 +2246,24 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
         
     }
     
+    @TestMetadata("compiler/testData/codegen/box/dot")
+    public static class Dot extends AbstractBlackBoxCodegenTest {
+        public void testAllFilesPresentInDot() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/codegen/box/dot"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+        
+        @TestMetadata("inTheVoidOfDots.kt")
+        public void testInTheVoidOfDots() throws Exception {
+            doTest("compiler/testData/codegen/box/dot/inTheVoidOfDots.kt");
+        }
+        
+        @TestMetadata("onlyDotCanKeepYouFromFailure.kt")
+        public void testOnlyDotCanKeepYouFromFailure() throws Exception {
+            doTest("compiler/testData/codegen/box/dot/onlyDotCanKeepYouFromFailure.kt");
+        }
+        
+    }
+    
     @TestMetadata("compiler/testData/codegen/box/elvis")
     public static class Elvis extends AbstractBlackBoxCodegenTest {
         public void testAllFilesPresentInElvis() throws Exception {
@@ -5485,6 +5503,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
         suite.addTestSuite(ControlStructures.class);
         suite.addTest(DefaultArguments.innerSuite());
         suite.addTestSuite(DelegatedProperty.class);
+        suite.addTestSuite(Dot.class);
         suite.addTestSuite(Elvis.class);
         suite.addTestSuite(Enum.class);
         suite.addTestSuite(ExclExcl.class);

idea/src/org/jetbrains/jet/plugin/codeInsight/TipsManager.java

@@ -57,7 +57,10 @@ public final class TipsManager {
         if (receiverExpression != null && inPositionForCompletionWithReceiver) {
             // Process as call expression
             JetScope resolutionScope = context.get(BindingContext.RESOLUTION_SCOPE, expression);
-            JetType expressionType = context.get(BindingContext.EXPRESSION_TYPE, receiverExpression);
+            JetType expressionType = context.get(BindingContext.DOTTED_EXPRESSION_TYPE, receiverExpression);
+            if (expressionType == null) {
+                expressionType = context.get(BindingContext.EXPRESSION_TYPE, receiverExpression);
+            }
 
             if (expressionType != null && resolutionScope != null && !expressionType.isError()) {
                 if (!(expressionType instanceof PackageType)) {

idea/testData/completion/basic/common/javaDotNet.kt

@@ -0,0 +1,15 @@
+class Java() {
+    fun oracleRulezzz()
+}
+
+class DotNet {
+    fun microsoftRulezzz()
+}
+
+fun Java.dot(): DotNet = DotNet()
+
+fun test() {
+    Java().<caret>
+}
+
+// EXIST: microsoftRulezzz

idea/testData/completion/basic/common/onlyDotSurvives.kt

@@ -0,0 +1,10 @@
+fun String?.dot(): Nothing {
+    throw RuntimeException()
+}
+
+fun box(): String {
+    val s: String? = ""
+    return s.<caret>
+}
+
+// EXIST: dot

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

@@ -309,6 +309,11 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
             doTest("idea/testData/completion/basic/common/InTypeAnnotation.kt");
         }
         
+        @TestMetadata("javaDotNet.kt")
+        public void testJavaDotNet() throws Exception {
+            doTest("idea/testData/completion/basic/common/javaDotNet.kt");
+        }
+        
         @TestMetadata("JavaPackage.kt")
         public void testJavaPackage() throws Exception {
             doTest("idea/testData/completion/basic/common/JavaPackage.kt");
@@ -374,6 +379,11 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
             doTest("idea/testData/completion/basic/common/ObjectRedeclaration2.kt");
         }
         
+        @TestMetadata("onlyDotSurvives.kt")
+        public void testOnlyDotSurvives() throws Exception {
+            doTest("idea/testData/completion/basic/common/onlyDotSurvives.kt");
+        }
+        
         @TestMetadata("OnlyScopedClassesWithoutExplicit.kt")
         public void testOnlyScopedClassesWithoutExplicit() throws Exception {
             doTest("idea/testData/completion/basic/common/OnlyScopedClassesWithoutExplicit.kt");

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

@@ -309,6 +309,11 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
             doTest("idea/testData/completion/basic/common/InTypeAnnotation.kt");
         }
         
+        @TestMetadata("javaDotNet.kt")
+        public void testJavaDotNet() throws Exception {
+            doTest("idea/testData/completion/basic/common/javaDotNet.kt");
+        }
+        
         @TestMetadata("JavaPackage.kt")
         public void testJavaPackage() throws Exception {
             doTest("idea/testData/completion/basic/common/JavaPackage.kt");
@@ -374,6 +379,11 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
             doTest("idea/testData/completion/basic/common/ObjectRedeclaration2.kt");
         }
         
+        @TestMetadata("onlyDotSurvives.kt")
+        public void testOnlyDotSurvives() throws Exception {
+            doTest("idea/testData/completion/basic/common/onlyDotSurvives.kt");
+        }
+        
         @TestMetadata("OnlyScopedClassesWithoutExplicit.kt")
         public void testOnlyScopedClassesWithoutExplicit() throws Exception {
             doTest("idea/testData/completion/basic/common/OnlyScopedClassesWithoutExplicit.kt");