Merge remote-tracking branch 'origin/master' into idea14

Conflicts: update_dependencies.xml
2014-06-27 14:44:05 +04:00
parent 6095faed14 46da00a9a7
commit e7a1cba1eb
252 changed files with 1663 additions and 1096 deletions
@@ -139,7 +139,7 @@

        <echo file="${kotlin-home}/build.txt" message="${build.number}"/>

-        <chmod dir="${kotlin-home}/bin" includes="*" perm="755"/>
+        <chmod dir="${kotlin-home}/bin" excludes="**/*.bat" perm="755"/>
    </target>

    <target name="compilerSources">
@@ -31,7 +31,6 @@ import org.jetbrains.jet.lang.psi.JetModifierListOwner;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.constants.*;
-import org.jetbrains.jet.lang.resolve.constants.StringValue;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
@@ -174,7 +173,7 @@ public abstract class AnnotationCodegen {
            return;
        }

-        boolean isNullableType = JvmCodegenUtil.isNullableType(type);
+        boolean isNullableType = TypeUtils.isNullableType(type);

        Class<?> annotationClass = isNullableType ? Nullable.class : NotNull.class;

@@ -58,6 +58,7 @@ import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.getType;
 import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.ABI_VERSION_FIELD_NAME;
 import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.KotlinSyntheticClass;
 import static org.jetbrains.jet.lang.resolve.java.mapping.PrimitiveTypesUtil.asmTypeForPrimitive;
+import static org.jetbrains.jet.lang.types.TypeUtils.isNullableType;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;

 public class AsmUtil {
@@ -54,6 +54,7 @@ import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmMethodSignature;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.*;
 import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetTokens;
@@ -3506,7 +3507,7 @@ The "returned" value of try expression with no finally is either the last expres
                value.put(boxType(value.type), v);

                if (opToken != JetTokens.AS_SAFE) {
-                    if (!JvmCodegenUtil.isNullableType(rightType)) {
+                    if (!TypeUtils.isNullableType(rightType)) {
                        v.dup();
                        Label nonnull = new Label();
                        v.ifnonnull(nonnull);
@@ -43,6 +43,7 @@ import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
@@ -838,7 +839,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                    iv.anew(thisDescriptorType);
                    iv.dup();

-                    ConstructorDescriptor constructor = DescriptorUtils.getConstructorOfDataClass(descriptor);
+                    ConstructorDescriptor constructor = DeclarationResolver.getConstructorOfDataClass(descriptor);
                    assert function.getValueParameters().size() == constructor.getValueParameters().size() :
                            "Number of parameters of copy function and constructor are different. " +
                            "Copy: " + function.getValueParameters().size() + ", " +
@@ -1124,9 +1125,11 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {

    protected void genInitSingleton(ClassDescriptor fieldTypeDescriptor, StackValue.Field field) {
        if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
-            ConstructorDescriptor constructorDescriptor = DescriptorUtils.getConstructorOfSingletonObject(fieldTypeDescriptor);
+            Collection<ConstructorDescriptor> constructors = fieldTypeDescriptor.getConstructors();
+            assert constructors.size() == 1 : "Class of singleton object must have only one constructor: " + constructors;
+
            ExpressionCodegen codegen = createOrGetClInitCodegen();
-            FunctionDescriptor fd = codegen.accessibleFunctionDescriptor(constructorDescriptor);
+            FunctionDescriptor fd = codegen.accessibleFunctionDescriptor(constructors.iterator().next());
            generateMethodCallTo(fd, codegen.v);
            field.store(field.type, codegen.v);
        }
@@ -16,8 +16,6 @@

 package org.jetbrains.jet.codegen;

-import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.containers.Stack;
 import kotlin.Function1;
 import kotlin.KotlinPackage;
@@ -37,7 +35,6 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;

 import java.util.Arrays;
@@ -193,20 +190,6 @@ public class JvmCodegenUtil {
        );
    }

-    /**
-     * A work-around of the generic nullability problem in the type checker
-     * @return true if a value of this type can be null
-     */
-    public static boolean isNullableType(@NotNull JetType type) {
-        if (type.isNullable()) {
-            return true;
-        }
-        if (type.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor) {
-            return TypeUtils.hasNullableSuperType(type);
-        }
-        return false;
-    }
-
    public static boolean couldUseDirectAccessToProperty(
            @NotNull PropertyDescriptor propertyDescriptor,
            boolean forGetter,
@@ -23,17 +23,17 @@ import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.reflect.ReflectionTypes;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;

 import java.util.*;

-public class JvmFunctionImplTypes {
+public class JvmRuntimeTypes {
    private final ReflectionTypes reflectionTypes;

    private final ClassDescriptor functionImpl;
@@ -42,7 +42,7 @@ public class JvmFunctionImplTypes {
    private final ClassDescriptor kMemberFunctionImpl;
    private final ClassDescriptor kExtensionFunctionImpl;

-    public JvmFunctionImplTypes(@NotNull ReflectionTypes reflectionTypes) {
+    public JvmRuntimeTypes(@NotNull ReflectionTypes reflectionTypes) {
        this.reflectionTypes = reflectionTypes;

        ModuleDescriptor fakeModule = new ModuleDescriptorImpl(Name.special("<fake module for functions impl>"),
@@ -117,7 +117,7 @@ public class JvmFunctionImplTypes {
        JetType functionType = KotlinBuiltIns.getInstance().getFunctionType(
                Annotations.EMPTY,
                receiverParameter == null ? null : receiverParameter.getType(),
-                DescriptorUtils.getValueParametersTypes(descriptor.getValueParameters()),
+                ExpressionTypingUtils.getValueParametersTypes(descriptor.getValueParameters()),
                descriptor.getReturnType()
        );

@@ -125,7 +125,7 @@ public class JvmFunctionImplTypes {
    }

    @NotNull
-    public Collection<JetType> getSupertypesForCallableReference(@NotNull FunctionDescriptor descriptor) {
+    public Collection<JetType> getSupertypesForFunctionReference(@NotNull FunctionDescriptor descriptor) {
        ReceiverParameterDescriptor receiverParameter = descriptor.getReceiverParameter();
        ReceiverParameterDescriptor expectedThisObject = descriptor.getExpectedThisObject();

@@ -162,7 +162,7 @@ public class JvmFunctionImplTypes {
        JetType kFunctionType = reflectionTypes.getKFunctionType(
                Annotations.EMPTY,
                receiverType,
-                DescriptorUtils.getValueParametersTypes(descriptor.getValueParameters()),
+                ExpressionTypingUtils.getValueParametersTypes(descriptor.getValueParameters()),
                descriptor.getReturnType(),
                receiverParameter != null
        );
@@ -199,11 +199,8 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
    @NotNull
    protected ExpressionCodegen createOrGetClInitCodegen() {
        DeclarationDescriptor descriptor = context.getContextDescriptor();
-        assert state.getClassBuilderMode() == ClassBuilderMode.FULL
-                : "<clinit> should not be generated for light classes. Descriptor: " + descriptor;
        if (clInit == null) {
            MethodVisitor mv = v.newMethod(OtherOrigin(descriptor), ACC_STATIC, "<clinit>", "()V", null, null);
-            mv.visitCode();
            SimpleFunctionDescriptorImpl clInit =
                    SimpleFunctionDescriptorImpl.create(descriptor, Annotations.EMPTY, Name.special("<clinit>"), SYNTHESIZED);
            clInit.initialize(null, null, Collections.<TypeParameterDescriptor>emptyList(),
@@ -23,7 +23,7 @@ import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.codegen.AsmUtil;
-import org.jetbrains.jet.codegen.JvmFunctionImplTypes;
+import org.jetbrains.jet.codegen.JvmRuntimeTypes;
 import org.jetbrains.jet.codegen.SamCodegenUtil;
 import org.jetbrains.jet.codegen.SamType;
 import org.jetbrains.jet.codegen.state.GenerationState;
@@ -88,13 +88,13 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
    private final BindingTrace bindingTrace;
    private final BindingContext bindingContext;
    private final GenerationState.GenerateClassFilter filter;
-    private final JvmFunctionImplTypes functionImplTypes;
+    private final JvmRuntimeTypes runtimeTypes;

    public CodegenAnnotatingVisitor(@NotNull GenerationState state) {
        this.bindingTrace = state.getBindingTrace();
        this.bindingContext = state.getBindingContext();
        this.filter = state.getGenerateDeclaredClassFilter();
-        this.functionImplTypes = state.getJvmFunctionImplTypes();
+        this.runtimeTypes = state.getJvmRuntimeTypes();
    }

    @NotNull
@@ -264,7 +264,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
        if (functionDescriptor == null) return;

        String name = inventAnonymousClassName(expression);
-        Collection<JetType> supertypes = functionImplTypes.getSupertypesForClosure(functionDescriptor);
+        Collection<JetType> supertypes = runtimeTypes.getSupertypesForClosure(functionDescriptor);
        ClassDescriptor classDescriptor = recordClassForFunction(functionDescriptor, supertypes);
        recordClosure(functionLiteral, classDescriptor, name);

@@ -313,7 +313,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
        ResolvedCall<?> referencedFunction = bindingContext.get(RESOLVED_CALL, expression.getCallableReference());
        if (referencedFunction == null) return;
        Collection<JetType> supertypes =
-                functionImplTypes.getSupertypesForCallableReference((FunctionDescriptor) referencedFunction.getResultingDescriptor());
+                runtimeTypes.getSupertypesForFunctionReference((FunctionDescriptor) referencedFunction.getResultingDescriptor());

        String name = inventAnonymousClassName(expression);
        ClassDescriptor classDescriptor = recordClassForFunction(functionDescriptor, supertypes);
@@ -366,7 +366,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
        }
        else {
            String name = inventAnonymousClassName(function);
-            Collection<JetType> supertypes = functionImplTypes.getSupertypesForClosure(functionDescriptor);
+            Collection<JetType> supertypes = runtimeTypes.getSupertypesForClosure(functionDescriptor);
            ClassDescriptor classDescriptor = recordClassForFunction(functionDescriptor, supertypes);
            recordClosure(function, classDescriptor, name);

@@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
+import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
 import org.jetbrains.jet.lang.resolve.kotlin.PackagePartClassUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -42,7 +43,6 @@ import java.util.ArrayList;
 import java.util.Collection;

 import static org.jetbrains.jet.lang.resolve.BindingContextUtils.descriptorToDeclaration;
-import static org.jetbrains.jet.lang.resolve.java.PackageClassUtils.getPackageClassFqName;

 public final class PsiCodegenPredictor {
    private PsiCodegenPredictor() {
@@ -87,9 +87,8 @@ public final class PsiCodegenPredictor {
            FqName packageFqName = declaration.getContainingJetFile().getPackageFqName();

            if (declaration instanceof JetNamedFunction) {
-                FqName packageClass = getPackageClassFqName(packageFqName);
                Name name = ((JetNamedFunction) declaration).getNameAsName();
-                return name == null ? null : AsmUtil.internalNameByFqNameWithoutInnerClasses(packageClass) + "$" + name.asString();
+                return name == null ? null : PackageClassUtils.getPackageClassInternalName(packageFqName) + "$" + name.asString();
            }

            parentInternalName = AsmUtil.internalNameByFqNameWithoutInnerClasses(packageFqName);
@@ -93,7 +93,7 @@ public class GenerationState {
    @Nullable
    private List<ScriptDescriptor> earlierScriptsForReplInterpreter;

-    private final JvmFunctionImplTypes functionImplTypes;
+    private final JvmRuntimeTypes runtimeTypes;

    @NotNull
    private final ModuleDescriptor module;
@@ -153,7 +153,7 @@ public class GenerationState {
        this.generateClassFilter = generateClassFilter;

        ReflectionTypes reflectionTypes = new ReflectionTypes(module);
-        this.functionImplTypes = new JvmFunctionImplTypes(reflectionTypes);
+        this.runtimeTypes = new JvmRuntimeTypes(reflectionTypes);
    }

    @NotNull
@@ -220,8 +220,8 @@ public class GenerationState {
    }

    @NotNull
-    public JvmFunctionImplTypes getJvmFunctionImplTypes() {
-        return functionImplTypes;
+    public JvmRuntimeTypes getJvmRuntimeTypes() {
+        return runtimeTypes;
    }

    public boolean isInlineEnabled() {
@@ -143,7 +143,7 @@ public class JetTypeMapper {
            }
        }

-        return PackageClassUtils.getPackageClassFqName(packageFragment.getFqName()).asString().replace('.', '/');
+        return PackageClassUtils.getPackageClassInternalName(packageFragment.getFqName());
    }

    @NotNull
@@ -0,0 +1,17 @@
+#!/bin/bash --posix
+
+# 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.
+
+$(dirname $0)/kotlinc-jvm "$@"
@@ -0,0 +1,17 @@
+@echo off
+
+rem Copyright 2010-2014 JetBrains s.r.o.
+rem
+rem Licensed under the Apache License, Version 2.0 (the "License");
+rem you may not use this file except in compliance with the License.
+rem You may obtain a copy of the License at
+rem
+rem http://www.apache.org/licenses/LICENSE-2.0
+rem
+rem Unless required by applicable law or agreed to in writing, software
+rem distributed under the License is distributed on an "AS IS" BASIS,
+rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+rem See the License for the specific language governing permissions and
+rem limitations under the License.
+
+call %~dp0kotlinc-jvm.bat %*
@@ -20,7 +20,6 @@ import com.google.common.base.Splitter;
 import com.google.common.collect.Lists;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.util.text.StringUtil;
-import kotlin.modules.Module;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.cli.common.CLICompiler;
 import org.jetbrains.jet.cli.common.CLIConfigurationKeys;
@@ -28,7 +27,10 @@ import org.jetbrains.jet.cli.common.ExitCode;
 import org.jetbrains.jet.cli.common.arguments.CompilerArgumentsUtil;
 import org.jetbrains.jet.cli.common.arguments.K2JVMCompilerArguments;
 import org.jetbrains.jet.cli.common.messages.*;
-import org.jetbrains.jet.cli.jvm.compiler.*;
+import org.jetbrains.jet.cli.jvm.compiler.CommandLineScriptUtils;
+import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.jet.cli.jvm.compiler.KotlinToJVMBytecodeCompiler;
 import org.jetbrains.jet.cli.jvm.repl.ReplFromTerminal;
 import org.jetbrains.jet.codegen.CompilationException;
 import org.jetbrains.jet.codegen.inline.InlineCodegenUtil;
@@ -83,7 +85,8 @@ public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments> {
        if (!arguments.script &&
            arguments.module == null &&
            arguments.src == null &&
-            arguments.freeArgs.isEmpty()
+            arguments.freeArgs.isEmpty() &&
+            !arguments.version
        ) {
            ReplFromTerminal.run(rootDisposable, configuration);
            return ExitCode.OK;
@@ -32,10 +32,7 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.renderer.DescriptorRenderer;

-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;

 public class JavaToKotlinMethodMap {
    public static final JavaToKotlinMethodMap INSTANCE = new JavaToKotlinMethodMap();
@@ -55,7 +52,7 @@ public class JavaToKotlinMethodMap {

        List<FunctionDescriptor> result = Lists.newArrayList();

-        Set<ClassDescriptor> allSuperClasses = DescriptorUtils.getAllSuperClasses(containingClass);
+        Set<ClassDescriptor> allSuperClasses = new HashSet<ClassDescriptor>(DescriptorUtils.getSuperclassDescriptors(containingClass));

        String serializedMethod = JavaSignatureFormatter.getInstance().formatMethod(javaMethod);
        for (ClassData classData : classDatas) {
@@ -21,7 +21,7 @@ import com.intellij.psi.impl.JavaConstantExpressionEvaluator;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.constants.ConstantsPackage;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaField;
@@ -36,7 +36,7 @@ public class JavaPropertyInitializerEvaluatorImpl implements JavaPropertyInitial
        if (evaluatedExpression != null) {
            return ConstantsPackage.createCompileTimeConstant(
                    evaluatedExpression,
-                    DescriptorUtils.isPropertyCompileTimeConstant(descriptor),
+                    ConstantExpressionEvaluator.object$.isPropertyCompileTimeConstant(descriptor),
                    false,
                    true,
                    descriptor.getType());
@@ -58,6 +58,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ThisReceiver;
 import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.MainFunctionDetector;
@@ -591,7 +592,7 @@ public class JetFlowInformationProvider {
                        VariableDescriptor variableDescriptor = PseudocodeUtil.extractVariableDescriptorIfAny(
                                instruction, false, trace.getBindingContext());
                        if (variableDescriptor == null || !declaredVariables.contains(variableDescriptor)
-                                || !DescriptorUtils.isLocal(variableDescriptor.getContainingDeclaration(), variableDescriptor)) {
+                                || !ExpressionTypingUtils.isLocal(variableDescriptor.getContainingDeclaration(), variableDescriptor)) {
                            return;
                        }
                        PseudocodeVariablesData.VariableUseState variableUseState = in.get(variableDescriptor);
@@ -41,6 +41,17 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
            val evaluator = ConstantExpressionEvaluator(trace)
            return evaluator.evaluate(expression, expectedType)
        }
+
+        public fun isPropertyCompileTimeConstant(descriptor: VariableDescriptor): Boolean {
+            if (descriptor.isVar()) {
+                return false
+            }
+            if (DescriptorUtils.isClassObject(descriptor.getContainingDeclaration()) || DescriptorUtils.isTopLevelDeclaration(descriptor)) {
+                val returnType = descriptor.getType()
+                return KotlinBuiltIns.getInstance().isPrimitiveType(returnType) || KotlinBuiltIns.getInstance().getStringType() == returnType
+            }
+            return false
+        }
    }

    private fun evaluate(expression: JetExpression, expectedType: JetType?): CompileTimeConstant<*>? {
@@ -311,7 +322,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
                        else
                            compileTimeConstant.getValue()
                return createCompileTimeConstant(value, expectedType, isPure = false,
-                                                 canBeUsedInAnnotation = DescriptorUtils.isPropertyCompileTimeConstant(callableDescriptor),
+                                                 canBeUsedInAnnotation = isPropertyCompileTimeConstant(callableDescriptor),
                                                 usesVariableAsConstant = true)
            }
        }
@@ -372,7 +372,7 @@ public class JetExpressionParsing extends AbstractJetParsing {

    /*
     * callableReference
-     *   : userType? "::" SimpleName
+     *   : (userType "?"*)? "::" SimpleName
     *   ;
     */
    private boolean parseCallableReferenceExpression() {
@@ -381,7 +381,9 @@ public class JetExpressionParsing extends AbstractJetParsing {
        if (!at(COLONCOLON)) {
            PsiBuilder.Marker typeReference = mark();
            myJetParsing.parseUserType();
+            typeReference = myJetParsing.parseNullableTypeSuffix(typeReference);
            typeReference.done(TYPE_REFERENCE);
+
            if (!at(COLONCOLON)) {
                expression.rollbackTo();
                return false;
@@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.parsing;
 import com.intellij.lang.PsiBuilder;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.TokenSet;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeType;
 import org.jetbrains.jet.lexer.JetKeywordToken;
@@ -1478,14 +1479,7 @@ public class JetParsing extends AbstractJetParsing {
                                   TokenSet.create(EQ, COMMA, GT, RBRACKET, DOT, RPAR, RBRACE, LBRACE, SEMICOLON), extraRecoverySet));
        }

-        while (at(QUEST)) {
-            PsiBuilder.Marker precede = typeRefMarker.precede();
-
-            advance(); // QUEST
-            typeRefMarker.done(NULLABLE_TYPE);
-
-            typeRefMarker = precede;
-        }
+        typeRefMarker = parseNullableTypeSuffix(typeRefMarker);

        if (at(DOT)) {
            // This is a receiver for a function type
@@ -1513,6 +1507,17 @@ public class JetParsing extends AbstractJetParsing {
        return typeRefMarker;
    }

+    @NotNull
+    PsiBuilder.Marker parseNullableTypeSuffix(@NotNull PsiBuilder.Marker typeRefMarker) {
+        while (at(QUEST)) {
+            PsiBuilder.Marker precede = typeRefMarker.precede();
+            advance(); // QUEST
+            typeRefMarker.done(NULLABLE_TYPE);
+            typeRefMarker = precede;
+        }
+        return typeRefMarker;
+    }
+
    /*
     * userType
     *   : ("package" ".")? simpleUserType{"."}
@@ -89,7 +89,7 @@ public class BindingContextUtils {
    public static JetFile getContainingFile(@NotNull BindingContext context, @NotNull DeclarationDescriptor declarationDescriptor) {
        // declarationDescriptor may describe a synthesized element which doesn't have PSI
        // To workaround that, we find a top-level parent (which is inside a PackageFragmentDescriptor), which is guaranteed to have PSI
-        DeclarationDescriptor descriptor = DescriptorUtils.findTopLevelParent(declarationDescriptor);
+        DeclarationDescriptor descriptor = findTopLevelParent(declarationDescriptor);
        if (descriptor == null) return null;

        PsiElement declaration = descriptorToDeclaration(context, descriptor);
@@ -100,6 +100,18 @@ public class BindingContextUtils {
        return (JetFile) containingFile;
    }

+    @Nullable
+    private static DeclarationDescriptor findTopLevelParent(@NotNull DeclarationDescriptor declarationDescriptor) {
+        DeclarationDescriptor descriptor = declarationDescriptor;
+        if (declarationDescriptor instanceof PropertyAccessorDescriptor) {
+            descriptor = ((PropertyAccessorDescriptor) descriptor).getCorrespondingProperty();
+        }
+        while (!(descriptor == null || DescriptorUtils.isTopLevelDeclaration(descriptor))) {
+            descriptor = descriptor.getContainingDeclaration();
+        }
+        return descriptor;
+    }
+
    @Nullable
    private static PsiElement doGetDescriptorToDeclaration(@NotNull BindingContext context, @NotNull DeclarationDescriptor descriptor) {
        return context.get(DESCRIPTOR_TO_DECLARATION, descriptor);
@@ -203,13 +203,20 @@ public class DeclarationResolver {
            MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();

            if (klass instanceof JetClass && klass.hasPrimaryConstructor() && KotlinBuiltIns.getInstance().isData(classDescriptor)) {
-                ConstructorDescriptor constructor = DescriptorUtils.getConstructorOfDataClass(classDescriptor);
+                ConstructorDescriptor constructor = getConstructorOfDataClass(classDescriptor);
                createComponentFunctions(classDescriptor, constructor);
                createCopyFunction(classDescriptor, constructor);
            }
        }
    }

+    @NotNull
+    public static ConstructorDescriptor getConstructorOfDataClass(@NotNull ClassDescriptor classDescriptor) {
+        Collection<ConstructorDescriptor> constructors = classDescriptor.getConstructors();
+        assert constructors.size() == 1 : "Data class must have only one constructor: " + classDescriptor.getConstructors();
+        return constructors.iterator().next();
+    }
+
    private void createComponentFunctions(@NotNull MutableClassDescriptor classDescriptor, @NotNull ConstructorDescriptor constructorDescriptor) {
        int parameterIndex = 0;
        for (ValueParameterDescriptor parameter : constructorDescriptor.getValueParameters()) {
@@ -546,7 +546,7 @@ public class DescriptorResolver {
        JetType variableType = type;
        if (valueParameter.hasModifier(VARARG_KEYWORD)) {
            varargElementType = type;
-            variableType = DescriptorUtils.getVarargParameterType(type);
+            variableType = getVarargParameterType(type);
        }
        ValueParameterDescriptorImpl valueParameterDescriptor = new ValueParameterDescriptorImpl(
                declarationDescriptor,
@@ -563,6 +563,15 @@ public class DescriptorResolver {
        return valueParameterDescriptor;
    }

+    @NotNull
+    private static JetType getVarargParameterType(@NotNull JetType elementType) {
+        JetType primitiveArrayType = KotlinBuiltIns.getInstance().getPrimitiveArrayJetTypeByPrimitiveJetType(elementType);
+        if (primitiveArrayType != null) {
+            return primitiveArrayType;
+        }
+        return KotlinBuiltIns.getInstance().getArrayType(Variance.INVARIANT, elementType);
+    }
+
    public List<TypeParameterDescriptorImpl> resolveTypeParametersForCallableDescriptor(
            DeclarationDescriptor containingDescriptor,
            WritableScope extensibleScope,
@@ -791,7 +800,7 @@ public class DescriptorResolver {
            type = ErrorUtils.createErrorType("Annotation is absent");
        }
        if (parameter.hasModifier(VARARG_KEYWORD)) {
-            return DescriptorUtils.getVarargParameterType(type);
+            return getVarargParameterType(type);
        }
        return type;
    }
@@ -1259,7 +1268,7 @@ public class DescriptorResolver {
                        parameterScope,
                        valueParameters, trace),
                resolveVisibilityFromModifiers(modifierList, getDefaultConstructorVisibility(classDescriptor)),
-                DescriptorUtils.isConstructorOfStaticNestedClass(constructorDescriptor));
+                isConstructorOfStaticNestedClass(constructorDescriptor));
        if (isAnnotationClass(classDescriptor)) {
            CompileTimeConstantUtils.checkConstructorParametersType(valueParameters, trace);
        }
@@ -1425,6 +1434,19 @@ public class DescriptorResolver {
        return true;
    }

+    private static boolean isInsideOuterClassOrItsSubclass(@Nullable DeclarationDescriptor nested, @NotNull ClassDescriptor outer) {
+        if (nested == null) return false;
+
+        if (nested instanceof ClassDescriptor && isSubclass((ClassDescriptor) nested, outer)) return true;
+
+        return isInsideOuterClassOrItsSubclass(nested.getContainingDeclaration(), outer);
+    }
+
+    @Nullable
+    public static ClassDescriptor getContainingClass(@NotNull JetScope scope) {
+        return getParentOfType(scope.getContainingDeclaration(), ClassDescriptor.class, false);
+    }
+
    public static void checkParameterHasNoValOrVar(
            @NotNull BindingTrace trace,
            @NotNull JetParameter parameter,
@@ -21,11 +21,11 @@ import gnu.trove.TObjectHashingStrategy;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall;
+import org.jetbrains.jet.lang.types.BoundsSubstitutor;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
@@ -131,7 +131,7 @@ public class OverloadingConflictResolver {
            if (isGenericF && !isGenericG) return false;

            if (isGenericF && isGenericG) {
-                return moreSpecific(DescriptorUtils.substituteBounds(f), DescriptorUtils.substituteBounds(g), false);
+                return moreSpecific(BoundsSubstitutor.substituteBounds(f), BoundsSubstitutor.substituteBounds(g), false);
            }
        }

@@ -38,8 +38,11 @@ import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.PackageType;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;

-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;

 import static org.jetbrains.jet.lang.resolve.calls.CallResolverUtil.isOrOverridesSynthesized;
 import static org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind.*;
@@ -54,7 +57,7 @@ public class TaskPrioritizer {
            @NotNull Collection<ResolutionCandidate<D>> nonlocal
    ) {
        for (ResolutionCandidate<D> resolvedCall : allDescriptors) {
-            if (DescriptorUtils.isLocal(containerOfTheCurrentLocality, resolvedCall.getDescriptor())) {
+            if (ExpressionTypingUtils.isLocal(containerOfTheCurrentLocality, resolvedCall.getDescriptor())) {
                local.add(resolvedCall);
            }
            else {
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2010-2013 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.types;
+
+import com.google.common.base.Function;
+import com.google.common.collect.Collections2;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
+import org.jetbrains.jet.utils.DFS;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BoundsSubstitutor {
+    private static final Function<TypeProjection,JetType> PROJECTIONS_TO_TYPES = new Function<TypeProjection, JetType>() {
+        @Override
+        public JetType apply(TypeProjection projection) {
+            return projection.getType();
+        }
+    };
+
+    private BoundsSubstitutor() {
+    }
+
+    @NotNull
+    public static <D extends CallableDescriptor> D substituteBounds(@NotNull D functionDescriptor) {
+        List<TypeParameterDescriptor> typeParameters = functionDescriptor.getTypeParameters();
+        if (typeParameters.isEmpty()) return functionDescriptor;
+
+        // TODO: this does not handle any recursion in the bounds
+        @SuppressWarnings("unchecked")
+        D substitutedFunction = (D) functionDescriptor.substitute(createUpperBoundsSubstitutor(typeParameters));
+        assert substitutedFunction != null : "Substituting upper bounds should always be legal";
+
+        return substitutedFunction;
+    }
+
+    @NotNull
+    private static TypeSubstitutor createUpperBoundsSubstitutor(@NotNull List<TypeParameterDescriptor> typeParameters) {
+        Map<TypeConstructor, TypeProjection> mutableSubstitution = new HashMap<TypeConstructor, TypeProjection>();
+        TypeSubstitutor substitutor = TypeSubstitutor.create(mutableSubstitution);
+
+        // todo assert: no loops
+        for (TypeParameterDescriptor descriptor : topologicallySortTypeParameters(typeParameters)) {
+            JetType upperBoundsAsType = descriptor.getUpperBoundsAsType();
+            JetType substitutedUpperBoundsAsType = substitutor.substitute(upperBoundsAsType, Variance.INVARIANT);
+            mutableSubstitution.put(descriptor.getTypeConstructor(), new TypeProjectionImpl(substitutedUpperBoundsAsType));
+        }
+
+        return substitutor;
+    }
+
+    @NotNull
+    private static List<TypeParameterDescriptor> topologicallySortTypeParameters(@NotNull final List<TypeParameterDescriptor> typeParameters) {
+        // In the end, we want every parameter to have no references to those after it in the list
+        // This gives us the reversed order: the one that refers to everybody else comes first
+        List<TypeParameterDescriptor> topOrder = DFS.topologicalOrder(
+                typeParameters,
+                new DFS.Neighbors<TypeParameterDescriptor>() {
+                    @NotNull
+                    @Override
+                    public Iterable<TypeParameterDescriptor> getNeighbors(TypeParameterDescriptor current) {
+                        return getTypeParametersFromUpperBounds(current, typeParameters);
+                    }
+                });
+
+        assert topOrder.size() == typeParameters.size() : "All type parameters must be visited, but only " + topOrder + " were";
+
+        // Now, the one that refers to everybody else stands in the last position
+        Collections.reverse(topOrder);
+        return topOrder;
+    }
+
+    @NotNull
+    private static List<TypeParameterDescriptor> getTypeParametersFromUpperBounds(
+            @NotNull TypeParameterDescriptor current,
+            @NotNull final List<TypeParameterDescriptor> typeParameters
+    ) {
+        return DFS.dfs(
+                current.getUpperBounds(),
+                new DFS.Neighbors<JetType>() {
+                    @NotNull
+                    @Override
+                    public Iterable<JetType> getNeighbors(JetType current) {
+                        return Collections2.transform(current.getArguments(), PROJECTIONS_TO_TYPES);
+                    }
+                },
+                new DFS.NodeHandlerWithListResult<JetType, TypeParameterDescriptor>() {
+                    @Override
+                    public boolean beforeChildren(JetType current) {
+                        ClassifierDescriptor declarationDescriptor = current.getConstructor().getDeclarationDescriptor();
+                        // typeParameters in a list, but it contains very few elements, so it's fine to call contains() on it
+                        //noinspection SuspiciousMethodCalls
+                        if (typeParameters.contains(declarationDescriptor)) {
+                            result.add((TypeParameterDescriptor) declarationDescriptor);
+                        }
+
+                        return true;
+                    }
+                }
+        );
+    }
+}
@@ -498,7 +498,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
        JetType type = components.reflectionTypes.getKFunctionType(
                Annotations.EMPTY,
                receiverType,
-                DescriptorUtils.getValueParametersTypes(descriptor.getValueParameters()),
+                getValueParametersTypes(descriptor.getValueParameters()),
                descriptor.getReturnType(),
                receiverParameter != null
        );
@@ -111,7 +111,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
        functionDescriptor.setReturnType(safeReturnType);

        JetType receiver = DescriptorUtils.getReceiverParameterType(functionDescriptor.getReceiverParameter());
-        List<JetType> valueParametersTypes = DescriptorUtils.getValueParametersTypes(functionDescriptor.getValueParameters());
+        List<JetType> valueParametersTypes = ExpressionTypingUtils.getValueParametersTypes(functionDescriptor.getValueParameters());
        JetType resultType = KotlinBuiltIns.getInstance().getFunctionType(
                Annotations.EMPTY, receiver, valueParametersTypes, safeReturnType);
        if (!noExpectedType(expectedType) && KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(expectedType)) {
@@ -187,7 +187,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
        }
        else {
            if (expectedValueParameters != null && declaredValueParameters.size() != expectedValueParameters.size()) {
-                List<JetType> expectedParameterTypes = DescriptorUtils.getValueParametersTypes(expectedValueParameters);
+                List<JetType> expectedParameterTypes = ExpressionTypingUtils.getValueParametersTypes(expectedValueParameters);
                context.trace.report(EXPECTED_PARAMETERS_NUMBER_MISMATCH.on(functionLiteral, expectedParameterTypes.size(), expectedParameterTypes));
            }
            for (int i = 0; i < declaredValueParameters.size(); i++) {
@@ -370,7 +370,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
            // http://youtrack.jetbrains.net/issue/KT-527

            VariableDescriptor olderVariable = context.scope.getLocalVariable(variableDescriptor.getName());
-            if (olderVariable != null && DescriptorUtils.isLocal(context.scope.getContainingDeclaration(), olderVariable)) {
+            if (olderVariable != null && isLocal(context.scope.getContainingDeclaration(), olderVariable)) {
                PsiElement declaration = BindingContextUtils.descriptorToDeclaration(context.trace.getBindingContext(), variableDescriptor);
                context.trace.report(Errors.NAME_SHADOWING.on(declaration, variableDescriptor.getName().asString()));
            }
@@ -395,7 +395,7 @@ public class ExpressionTypingServices {
            JetExpression defaultValue = jetParameter.getDefaultValue();
            if (defaultValue != null) {
                getType(declaringScope, defaultValue, valueParameterDescriptor.getType(), dataFlowInfo, trace);
-                if (DescriptorUtils.isAnnotationClass(DescriptorUtils.getContainingClass(declaringScope))) {
+                if (DescriptorUtils.isAnnotationClass(DescriptorResolver.getContainingClass(declaringScope))) {
                    ConstantExpressionEvaluator.object$.evaluate(defaultValue, trace, valueParameterDescriptor.getType());
                }
            }
@@ -427,7 +427,7 @@ public class ExpressionTypingUtils {
    }

    public static void checkVariableShadowing(@NotNull ExpressionTypingContext context, @NotNull VariableDescriptor variableDescriptor, VariableDescriptor oldDescriptor) {
-        if (oldDescriptor != null && DescriptorUtils.isLocal(variableDescriptor.getContainingDeclaration(), oldDescriptor)) {
+        if (oldDescriptor != null && isLocal(variableDescriptor.getContainingDeclaration(), oldDescriptor)) {
            PsiElement declaration = BindingContextUtils.descriptorToDeclaration(context.trace.getBindingContext(), variableDescriptor);
            if (declaration != null) {
                context.trace.report(Errors.NAME_SHADOWING.on(declaration, variableDescriptor.getName().asString()));
@@ -486,4 +486,44 @@ public class ExpressionTypingUtils {
    public static boolean isUnaryExpressionDependentOnExpectedType(@NotNull JetUnaryExpression expression) {
        return expression.getOperationReference().getReferencedNameElementType() == JetTokens.EXCLEXCL;
    }
+
+    @NotNull
+    public static List<JetType> getValueParametersTypes(@NotNull List<ValueParameterDescriptor> valueParameters) {
+        List<JetType> parameterTypes = new ArrayList<JetType>(valueParameters.size());
+        for (ValueParameterDescriptor parameter : valueParameters) {
+            parameterTypes.add(parameter.getType());
+        }
+        return parameterTypes;
+    }
+
+    /**
+     * The primary case for local extensions is the following:
+     *
+     * I had a locally declared extension function or a local variable of function type called foo
+     * And I called it on my x
+     * Now, someone added function foo() to the class of x
+     * My code should not change
+     *
+     * thus
+     *
+     * local extension prevail over members (and members prevail over all non-local extensions)
+     */
+    public static boolean isLocal(DeclarationDescriptor containerOfTheCurrentLocality, DeclarationDescriptor candidate) {
+        if (candidate instanceof ValueParameterDescriptor) {
+            return true;
+        }
+        DeclarationDescriptor parent = candidate.getContainingDeclaration();
+        if (!(parent instanceof FunctionDescriptor)) {
+            return false;
+        }
+        FunctionDescriptor functionDescriptor = (FunctionDescriptor) parent;
+        DeclarationDescriptor current = containerOfTheCurrentLocality;
+        while (current != null) {
+            if (current == functionDescriptor) {
+                return true;
+            }
+            current = current.getContainingDeclaration();
+        }
+        return false;
+    }
 }
--- a/Show More
+++ b/Show More