NamedFunctionDescriptor

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

@@ -207,11 +207,11 @@ public abstract class CodegenContext {
         if(accessor != null)
             return accessor;
 
-        if(descriptor instanceof FunctionDescriptor) {
+        if(descriptor instanceof NamedFunctionDescriptor) {
-            FunctionDescriptorImpl myAccessor = new FunctionDescriptorImpl(contextType,
+            NamedFunctionDescriptorImpl myAccessor = new NamedFunctionDescriptorImpl(contextType,
                                                                            Collections.<AnnotationDescriptor>emptyList(),
                                                                            descriptor.getName() + "$bridge$" + accessors.size());
-            FunctionDescriptor fd = (FunctionDescriptor) descriptor;
+            FunctionDescriptor fd = (NamedFunctionDescriptor) descriptor;
             myAccessor.initialize(fd.getReceiverParameter().exists() ? fd.getReceiverParameter().getType() : null,
                                   fd.getExpectedThisObject(),
                                   fd.getTypeParameters(),

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

@@ -85,9 +85,9 @@ public class CodegenUtil {
         return hasDerivedTypeInfoField(type);
     }
 
-    public static FunctionDescriptor createInvoke(ExpressionAsFunctionDescriptor fd) {
+    public static NamedFunctionDescriptor createInvoke(ExpressionAsFunctionDescriptor fd) {
         int arity = fd.getValueParameters().size();
-        FunctionDescriptorImpl invokeDescriptor = new FunctionDescriptorImpl(
+        NamedFunctionDescriptorImpl invokeDescriptor = new NamedFunctionDescriptorImpl(
                 fd.getExpectedThisObject().exists() ? JetStandardClasses.getReceiverFunction(arity) : JetStandardClasses.getFunction(arity),
                 Collections.<AnnotationDescriptor>emptyList(),
                 "invoke");

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

@@ -1218,7 +1218,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
             callableMethod = ClosureCodegen.asCallableMethod((FunctionDescriptor) fd);
         }
         else if (fd instanceof ExpressionAsFunctionDescriptor) {
-            FunctionDescriptor invoke = CodegenUtil.createInvoke((ExpressionAsFunctionDescriptor) fd);
+            NamedFunctionDescriptor invoke = CodegenUtil.createInvoke((ExpressionAsFunctionDescriptor) fd);
             callableMethod = ClosureCodegen.asCallableMethod(invoke);
         }
         else if (fd instanceof FunctionDescriptor) {

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

@@ -40,7 +40,7 @@ public class FunctionCodegen {
     }
 
     public void gen(JetNamedFunction f) {
-        final FunctionDescriptor functionDescriptor = state.getBindingContext().get(BindingContext.FUNCTION, f);
+        final NamedFunctionDescriptor functionDescriptor = state.getBindingContext().get(BindingContext.FUNCTION, f);
         assert functionDescriptor != null;
         JvmMethodSignature method = typeMapper.mapToCallableMethod(functionDescriptor, false, owner.getContextKind()).getSignature();
         generateMethod(f, method, functionDescriptor);

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

@@ -445,8 +445,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         HashSet<FunctionDescriptor> overridden = new HashSet<FunctionDescriptor>();
         for (JetDeclaration declaration : myClass.getDeclarations()) {
-            if (declaration instanceof JetFunction) {
+            if (declaration instanceof JetNamedFunction) {
-                FunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, declaration);
+                NamedFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, declaration);
                 assert functionDescriptor != null;
                 overridden.addAll(functionDescriptor.getOverriddenDescriptors());
             }

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java

@@ -158,8 +158,8 @@ public class IntrinsicMethods {
                 }
         );
         for (DeclarationDescriptor stringMember : stringMembers) {
-            if (stringMember instanceof FunctionDescriptor) {
+            if (stringMember instanceof NamedFunctionDescriptor) {
-                final FunctionDescriptor stringMethod = (FunctionDescriptor) stringMember;
+                final NamedFunctionDescriptor stringMethod = (NamedFunctionDescriptor) stringMember;
                 final PsiMethod[] methods = stringPsiClass != null?
                                             stringPsiClass.findMethodsByName(stringMember.getName(), false) : new PsiMethod[]{};
                 for (PsiMethod method : methods) {

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java

@@ -5,7 +5,7 @@ import org.jetbrains.jet.codegen.CallableMethod;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
 import org.jetbrains.jet.codegen.OwnerKind;
 import org.jetbrains.jet.codegen.StackValue;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamedFunctionDescriptor;
 import org.jetbrains.jet.lang.psi.JetCallExpression;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.objectweb.asm.Type;
@@ -18,9 +18,9 @@ import java.util.List;
  * @author alex.tkachman
  */
 public class PsiMethodCall implements IntrinsicMethod {
-    private final FunctionDescriptor myMethod;
+    private final NamedFunctionDescriptor myMethod;
 
-    public PsiMethodCall(FunctionDescriptor method) {
+    public PsiMethodCall(NamedFunctionDescriptor method) {
         myMethod = method;
     }
 

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

@@ -1112,7 +1112,7 @@ public class JavaDescriptorResolver {
             return null;
         }
         PsiParameter[] parameters = method.getParameterList().getParameters();
-        FunctionDescriptorImpl functionDescriptorImpl = new FunctionDescriptorImpl(
+        NamedFunctionDescriptorImpl functionDescriptorImpl = new NamedFunctionDescriptorImpl(
                 owner,
                 Collections.<AnnotationDescriptor>emptyList(), // TODO
                 method.getName()

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java

@@ -22,20 +22,20 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
 /**
  * @author abreslav
  */
-public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements FunctionDescriptor {
+public abstract class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements FunctionDescriptor {
 
-    private List<TypeParameterDescriptor> typeParameters;
+    protected List<TypeParameterDescriptor> typeParameters;
-    private List<ValueParameterDescriptor> unsubstitutedValueParameters;
+    protected List<ValueParameterDescriptor> unsubstitutedValueParameters;
-    private JetType unsubstitutedReturnType;
+    protected JetType unsubstitutedReturnType;
     private ReceiverDescriptor receiver;
-    private ReceiverDescriptor expectedThisObject;
+    protected ReceiverDescriptor expectedThisObject;
 
-    private Modality modality;
+    protected Modality modality;
-    private Visibility visibility;
+    protected Visibility visibility;
     private final Set<FunctionDescriptor> overriddenFunctions = Sets.newLinkedHashSet();
     private final FunctionDescriptor original;
 
-    public FunctionDescriptorImpl(
+    protected FunctionDescriptorImpl(
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull List<AnnotationDescriptor> annotations,
             @NotNull String name) {
@@ -43,7 +43,7 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
         this.original = this;
     }
 
-    public FunctionDescriptorImpl(
+    protected FunctionDescriptorImpl(
             @NotNull FunctionDescriptor original,
             @NotNull List<AnnotationDescriptor> annotations,
             @NotNull String name) {
@@ -182,32 +182,11 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
         return substitutedDescriptor;
     }
 
-    protected FunctionDescriptorImpl createSubstitutedCopy() {
+    protected abstract FunctionDescriptorImpl createSubstitutedCopy();
-        return new FunctionDescriptorImpl(
-                this,
-                // TODO : safeSubstitute
-                getAnnotations(),
-                getName());
-    }
 
     @Override
     public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
         return visitor.visitFunctionDescriptor(this, data);
     }
 
-    @NotNull
-    @Override
-    public FunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract) {
-        FunctionDescriptorImpl copy = new FunctionDescriptorImpl(newOwner, Lists.newArrayList(getAnnotations()), getName());
-        copy.initialize(
-                getReceiverParameter().exists() ? getReceiverParameter().getType() : null,
-                expectedThisObject,
-                DescriptorUtils.copyTypeParameters(copy, typeParameters),
-                DescriptorUtils.copyValueParameters(copy, unsubstitutedValueParameters),
-                unsubstitutedReturnType,
-                DescriptorUtils.convertModality(modality, makeNonAbstract),
-                visibility
-        );
-        return copy;
-    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java

@@ -27,7 +27,7 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     private final Set<ConstructorDescriptor> constructors = Sets.newLinkedHashSet();
     private final Set<CallableMemberDescriptor> callableMembers = Sets.newHashSet();
     private final Set<PropertyDescriptor> properties = Sets.newHashSet();
-    private final Set<FunctionDescriptor> functions = Sets.newHashSet();
+    private final Set<NamedFunctionDescriptor> functions = Sets.newHashSet();
     private List<TypeParameterDescriptor> typeParameters = Lists.newArrayList();
     private Collection<JetType> supertypes = Lists.newArrayList();
     private Map<String, ClassDescriptor> innerClasses = Maps.newHashMap();
@@ -152,7 +152,7 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     }
 
     @Override
-    public void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor) {
+    public void addFunctionDescriptor(@NotNull NamedFunctionDescriptor functionDescriptor) {
         functions.add(functionDescriptor);
         callableMembers.add(functionDescriptor);
         scopeForMemberLookup.addFunctionDescriptor(functionDescriptor);
@@ -160,7 +160,7 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     }
 
     @NotNull
-    public Set<FunctionDescriptor> getFunctions() {
+    public Set<NamedFunctionDescriptor> getFunctions() {
         return functions;
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamedFunctionDescriptor.java

@@ -0,0 +1,13 @@
+package org.jetbrains.jet.lang.descriptors;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Stepan Koltsov
+ */
+public interface NamedFunctionDescriptor extends FunctionDescriptor {
+
+    @NotNull
+    @Override
+    NamedFunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract);
+}

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamedFunctionDescriptorImpl.java

@@ -0,0 +1,47 @@
+package org.jetbrains.jet.lang.descriptors;
+
+import com.google.common.collect.Lists;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+
+import java.util.List;
+
+/**
+ * @author Stepan Koltsov
+ */
+public class NamedFunctionDescriptorImpl extends FunctionDescriptorImpl implements NamedFunctionDescriptor {
+
+    public NamedFunctionDescriptorImpl(@NotNull DeclarationDescriptor containingDeclaration, @NotNull List<AnnotationDescriptor> annotations, @NotNull String name) {
+        super(containingDeclaration, annotations, name);
+    }
+
+    private NamedFunctionDescriptorImpl(@NotNull NamedFunctionDescriptor original, @NotNull List<AnnotationDescriptor> annotations, @NotNull String name) {
+        super(original, annotations, name);
+    }
+
+    @Override
+    protected FunctionDescriptorImpl createSubstitutedCopy() {
+        return new NamedFunctionDescriptorImpl(
+                this,
+                // TODO : safeSubstitute
+                getAnnotations(),
+                getName());
+    }
+
+    @NotNull
+    @Override
+    public NamedFunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract) {
+        NamedFunctionDescriptorImpl copy = new NamedFunctionDescriptorImpl(newOwner, Lists.newArrayList(getAnnotations()), getName());
+        copy.initialize(
+                getReceiverParameter().exists() ? getReceiverParameter().getType() : null,
+                expectedThisObject,
+                DescriptorUtils.copyTypeParameters(copy, typeParameters),
+                DescriptorUtils.copyValueParameters(copy, unsubstitutedValueParameters),
+                unsubstitutedReturnType,
+                DescriptorUtils.convertModality(modality, makeNonAbstract),
+                visibility
+        );
+        return copy;
+    }
+}

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptorImpl.java

@@ -49,7 +49,7 @@ public class NamespaceDescriptorImpl extends AbstractNamespaceDescriptorImpl imp
     }
 
     @Override
-    public void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor) {
+    public void addFunctionDescriptor(@NotNull NamedFunctionDescriptor functionDescriptor) {
         memberScope.addFunctionDescriptor(functionDescriptor);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceLike.java

@@ -67,7 +67,7 @@ public interface NamespaceLike extends DeclarationDescriptor {
 
     void addObjectDescriptor(@NotNull MutableClassDescriptor objectDescriptor);
 
-    void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor);
+    void addFunctionDescriptor(@NotNull NamedFunctionDescriptor functionDescriptor);
 
     void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor);
 

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java

@@ -34,4 +34,9 @@ public class VariableAsFunctionDescriptor extends FunctionDescriptorImpl {
     public VariableAsFunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract) {
         throw new UnsupportedOperationException("Should not be copied for overriding");
     }
+
+    @Override
+    protected FunctionDescriptorImpl createSubstitutedCopy() {
+        throw new IllegalStateException();
+    }
 }

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

@@ -126,11 +126,11 @@ public interface Errors {
             return super.on(elementToBlame, nodeToMark, s, classDescriptor, modifierListOwner).add(DiagnosticParameters.CLASS, modifierListOwner);
         }
     };
-    PsiElementOnlyDiagnosticFactory1<JetFunction, FunctionDescriptor> ABSTRACT_FUNCTION_WITH_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "A function {0} with body cannot be abstract");
+    PsiElementOnlyDiagnosticFactory1<JetFunction, NamedFunctionDescriptor> ABSTRACT_FUNCTION_WITH_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "A function {0} with body cannot be abstract");
-    PsiElementOnlyDiagnosticFactory1<JetFunction, FunctionDescriptor> NON_ABSTRACT_FUNCTION_WITH_NO_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Method {0} without a body must be abstract");
+    PsiElementOnlyDiagnosticFactory1<JetFunction, NamedFunctionDescriptor> NON_ABSTRACT_FUNCTION_WITH_NO_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Method {0} without a body must be abstract");
-    PsiElementOnlyDiagnosticFactory1<JetModifierListOwner, FunctionDescriptor> NON_MEMBER_ABSTRACT_FUNCTION = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Function {0} is not a class or trait member and cannot be abstract");
+    PsiElementOnlyDiagnosticFactory1<JetModifierListOwner, NamedFunctionDescriptor> NON_MEMBER_ABSTRACT_FUNCTION = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Function {0} is not a class or trait member and cannot be abstract");
 
-    PsiElementOnlyDiagnosticFactory1<JetFunction, FunctionDescriptor> NON_MEMBER_FUNCTION_NO_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Function {0} must have a body");
+    PsiElementOnlyDiagnosticFactory1<JetFunction, NamedFunctionDescriptor> NON_MEMBER_FUNCTION_NO_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Function {0} must have a body");
     
     DiagnosticWithParameterFactory<JetNamedDeclaration, JetClass> NON_FINAL_MEMBER_IN_FINAL_CLASS = DiagnosticWithParameterFactory.create(ERROR, "Non final member in a final class", DiagnosticParameters.CLASS);
 

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

@@ -122,7 +122,7 @@ public class AnalyzingUtils {
             }
 
             @Override
-            public void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor) {
+            public void addFunctionDescriptor(@NotNull NamedFunctionDescriptor functionDescriptor) {
                 scope.addFunctionDescriptor(functionDescriptor);
             }
 

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

@@ -117,7 +117,7 @@ public interface BindingContext {
     WritableSlice<PsiElement, NamespaceDescriptor> NAMESPACE = Slices.<PsiElement, NamespaceDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
     WritableSlice<PsiElement, ClassDescriptor> CLASS = Slices.<PsiElement, ClassDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
     WritableSlice<JetTypeParameter, TypeParameterDescriptor> TYPE_PARAMETER = Slices.<JetTypeParameter, TypeParameterDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<PsiElement, FunctionDescriptor> FUNCTION = Slices.<PsiElement, FunctionDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+    WritableSlice<PsiElement, NamedFunctionDescriptor> FUNCTION = Slices.<PsiElement, NamedFunctionDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
     WritableSlice<PsiElement, ConstructorDescriptor> CONSTRUCTOR = Slices.<PsiElement, ConstructorDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
     WritableSlice<PsiElement, VariableDescriptor> VARIABLE = Slices.<PsiElement, VariableDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
     WritableSlice<JetParameter, VariableDescriptor> VALUE_PARAMETER = Slices.<JetParameter, VariableDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();

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

@@ -467,9 +467,9 @@ public class BodyResolver {
     }
 
     private void resolveFunctionBodies() {
-        for (Map.Entry<JetNamedFunction, FunctionDescriptorImpl> entry : this.context.getFunctions().entrySet()) {
+        for (Map.Entry<JetNamedFunction, NamedFunctionDescriptor> entry : this.context.getFunctions().entrySet()) {
             JetNamedFunction declaration = entry.getKey();
-            FunctionDescriptor descriptor = entry.getValue();
+            NamedFunctionDescriptor descriptor = entry.getValue();
 
             computeDeferredType(descriptor.getReturnType());
 

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

@@ -34,9 +34,9 @@ public class ControlFlowAnalyzer {
             if (!context.completeAnalysisNeeded(objectDeclaration)) continue;
             checkClassOrObject(objectDeclaration);
         }
-        for (Map.Entry<JetNamedFunction, FunctionDescriptorImpl> entry : context.getFunctions().entrySet()) {
+        for (Map.Entry<JetNamedFunction, NamedFunctionDescriptor> entry : context.getFunctions().entrySet()) {
             JetNamedFunction function = entry.getKey();
-            FunctionDescriptorImpl functionDescriptor = entry.getValue();
+            NamedFunctionDescriptor functionDescriptor = entry.getValue();
             if (!context.completeAnalysisNeeded(function)) continue;
             final JetType expectedReturnType = !function.hasBlockBody() && !function.hasDeclaredReturnType()
                                                ? NO_EXPECTED_TYPE

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

@@ -103,7 +103,7 @@ public class DeclarationResolver {
             declaration.accept(new JetVisitorVoid() {
                 @Override
                 public void visitNamedFunction(JetNamedFunction function) {
-                    FunctionDescriptorImpl functionDescriptor = context.getDescriptorResolver().resolveFunctionDescriptor(namespaceLike, scopeForFunctions, function);
+                    NamedFunctionDescriptor functionDescriptor = context.getDescriptorResolver().resolveFunctionDescriptor(namespaceLike, scopeForFunctions, function);
                     namespaceLike.addFunctionDescriptor(functionDescriptor);
                     context.getFunctions().put(function, functionDescriptor);
                     context.getDeclaringScopes().put(function, scopeForFunctions);

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

@@ -55,10 +55,10 @@ public class DeclarationsChecker {
             checkObject(objectDeclaration, objectDescriptor);
         }
 
-        Map<JetNamedFunction, FunctionDescriptorImpl> functions = context.getFunctions();
+        Map<JetNamedFunction, NamedFunctionDescriptor> functions = context.getFunctions();
-        for (Map.Entry<JetNamedFunction, FunctionDescriptorImpl> entry : functions.entrySet()) {
+        for (Map.Entry<JetNamedFunction, NamedFunctionDescriptor> entry : functions.entrySet()) {
             JetNamedFunction function = entry.getKey();
-            FunctionDescriptorImpl functionDescriptor = entry.getValue();
+            NamedFunctionDescriptor functionDescriptor = entry.getValue();
             
             if (!context.completeAnalysisNeeded(function)) continue;
             checkFunction(function, functionDescriptor);
@@ -254,7 +254,7 @@ public class DeclarationsChecker {
         }
     }
 
-    protected void checkFunction(JetNamedFunction function, FunctionDescriptor functionDescriptor) {
+    protected void checkFunction(JetNamedFunction function, NamedFunctionDescriptor functionDescriptor) {
         DeclarationDescriptor containingDescriptor = functionDescriptor.getContainingDeclaration();
         PsiElement nameIdentifier = function.getNameIdentifier();
         JetModifierList modifierList = function.getModifierList();

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

@@ -3,6 +3,7 @@ package org.jetbrains.jet.lang.resolve;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.MutableClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamedFunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.types.JetType;
@@ -49,10 +50,10 @@ public class DelegationResolver {
                                 context.getTrace().record(DELEGATED, copy);
                             }
                         }
-                        else if (declarationDescriptor instanceof FunctionDescriptor) {
+                        else if (declarationDescriptor instanceof NamedFunctionDescriptor) {
-                            FunctionDescriptor functionDescriptor = (FunctionDescriptor) declarationDescriptor;
+                            NamedFunctionDescriptor functionDescriptor = (NamedFunctionDescriptor) declarationDescriptor;
                             if (functionDescriptor.getModality().isOverridable()) {
-                                FunctionDescriptor copy = functionDescriptor.copy(classDescriptor, true);
+                                NamedFunctionDescriptor copy = functionDescriptor.copy(classDescriptor, true);
                                 classDescriptor.addFunctionDescriptor(copy);
                                 context.getTrace().record(DELEGATED, copy);
                             }

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

@@ -139,8 +139,8 @@ public class DescriptorResolver {
     }
 
     @NotNull
-    public FunctionDescriptorImpl resolveFunctionDescriptor(DeclarationDescriptor containingDescriptor, final JetScope scope, final JetNamedFunction function) {
+    public NamedFunctionDescriptor resolveFunctionDescriptor(DeclarationDescriptor containingDescriptor, final JetScope scope, final JetNamedFunction function) {
-        final FunctionDescriptorImpl functionDescriptor = new FunctionDescriptorImpl(
+        final NamedFunctionDescriptorImpl functionDescriptor = new NamedFunctionDescriptorImpl(
                 containingDescriptor,
                 annotationResolver.resolveAnnotations(scope, function.getModifierList()),
                 JetPsiUtil.safeName(function.getName())

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

@@ -86,7 +86,7 @@ public class OverloadResolver {
 
         MultiMap<Key, FunctionDescriptor> functionsByName = MultiMap.create();
 
-        for (FunctionDescriptorImpl function : context.getFunctions().values()) {
+        for (NamedFunctionDescriptor function : context.getFunctions().values()) {
             DeclarationDescriptor containingDeclaration = function.getContainingDeclaration();
             if (containingDeclaration instanceof NamespaceDescriptor) {
                 NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration;

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

@@ -34,7 +34,7 @@ import java.util.Set;
     protected final Map<JetFile, NamespaceDescriptorImpl> namespaceDescriptors = Maps.newHashMap();
 
     private final Map<JetDeclaration, JetScope> declaringScopes = Maps.newHashMap();
-    private final Map<JetNamedFunction, FunctionDescriptorImpl> functions = Maps.newLinkedHashMap();
+    private final Map<JetNamedFunction, NamedFunctionDescriptor> functions = Maps.newLinkedHashMap();
     private final Map<JetSecondaryConstructor, ConstructorDescriptor> constructors = Maps.newLinkedHashMap();
     private final Map<JetProperty, PropertyDescriptor> properties = Maps.newLinkedHashMap();
     private final Set<PropertyDescriptor> primaryConstructorParameterProperties = Sets.newHashSet();
@@ -138,7 +138,7 @@ import java.util.Set;
         return declaringScopes;
     }
 
-    public Map<JetNamedFunction, FunctionDescriptorImpl> getFunctions() {
+    public Map<JetNamedFunction, NamedFunctionDescriptor> getFunctions() {
         return functions;
     }
 

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

@@ -139,7 +139,7 @@ public class TopDownAnalyzer {
             }
 
             @Override
-            public void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor) {
+            public void addFunctionDescriptor(@NotNull NamedFunctionDescriptor functionDescriptor) {
                 throw new UnsupportedOperationException();
             }
 

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

@@ -18,4 +18,15 @@ public class ExpressionAsFunctionDescriptor extends FunctionDescriptorImpl {
     public ExpressionAsFunctionDescriptor(DeclarationDescriptor containingDeclaration, String name) {
         super(containingDeclaration, Collections.<AnnotationDescriptor>emptyList(), name);
     }
+
+    @Override
+    protected FunctionDescriptorImpl createSubstitutedCopy() {
+        throw new IllegalStateException();
+    }
+
+    @NotNull
+    @Override
+    public FunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract) {
+        throw new IllegalStateException();
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java

@@ -126,7 +126,7 @@ public class ErrorUtils {
     private static final Set<VariableDescriptor> ERROR_PROPERTY_GROUP = Collections.singleton(ERROR_PROPERTY);
 
     private static FunctionDescriptor createErrorFunction(List<TypeParameterDescriptor> typeParameters, List<JetType> positionedValueArgumentTypes) {
-        FunctionDescriptorImpl functionDescriptor = new FunctionDescriptorImpl(ERROR_CLASS, Collections.<AnnotationDescriptor>emptyList(), "<ERROR FUNCTION>");
+        FunctionDescriptorImpl functionDescriptor = new NamedFunctionDescriptorImpl(ERROR_CLASS, Collections.<AnnotationDescriptor>emptyList(), "<ERROR FUNCTION>");
         return functionDescriptor.initialize(
                 null,
                 ReceiverDescriptor.NO_RECEIVER,
@@ -139,7 +139,7 @@ public class ErrorUtils {
     }
 
     public static FunctionDescriptor createErrorFunction(int typeParameterCount, List<JetType> positionedValueParameterTypes) {
-        return new FunctionDescriptorImpl(ERROR_CLASS, Collections.<AnnotationDescriptor>emptyList(), "<ERROR FUNCTION>").initialize(
+        return new NamedFunctionDescriptorImpl(ERROR_CLASS, Collections.<AnnotationDescriptor>emptyList(), "<ERROR FUNCTION>").initialize(
                 null,
                 ReceiverDescriptor.NO_RECEIVER,
                 Collections.<TypeParameterDescriptor>emptyList(), // TODO

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

@@ -68,7 +68,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
         JetType expectedType = context.expectedType;
         boolean functionTypeExpected = expectedType != TypeUtils.NO_EXPECTED_TYPE && JetStandardClasses.isFunctionType(expectedType);
 
-        FunctionDescriptorImpl functionDescriptor = createFunctionDescriptor(expression, context, functionTypeExpected);
+        NamedFunctionDescriptorImpl functionDescriptor = createFunctionDescriptor(expression, context, functionTypeExpected);
 
         List<JetType> parameterTypes = Lists.newArrayList();
         List<ValueParameterDescriptor> valueParameters = functionDescriptor.getValueParameters();
@@ -108,10 +108,10 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
         return DataFlowUtils.checkType(JetStandardClasses.getFunctionType(Collections.<AnnotationDescriptor>emptyList(), receiver, parameterTypes, safeReturnType), expression, context);
     }
 
-    private FunctionDescriptorImpl createFunctionDescriptor(JetFunctionLiteralExpression expression, ExpressionTypingContext context, boolean functionTypeExpected) {
+    private NamedFunctionDescriptorImpl createFunctionDescriptor(JetFunctionLiteralExpression expression, ExpressionTypingContext context, boolean functionTypeExpected) {
         JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
         JetTypeReference receiverTypeRef = functionLiteral.getReceiverTypeRef();
-        FunctionDescriptorImpl functionDescriptor = new FunctionDescriptorImpl(
+        NamedFunctionDescriptorImpl functionDescriptor = new NamedFunctionDescriptorImpl(
                 context.scope.getContainingDeclaration(), Collections.<AnnotationDescriptor>emptyList(), "<anonymous>");
 
         List<ValueParameterDescriptor> valueParameterDescriptors = createValueParameterDescriptors(context, functionLiteral, functionDescriptor, functionTypeExpected);

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

@@ -105,7 +105,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
 
     @Override
     public JetType visitNamedFunction(JetNamedFunction function, ExpressionTypingContext context) {
-        FunctionDescriptorImpl functionDescriptor = context.getDescriptorResolver().resolveFunctionDescriptor(scope.getContainingDeclaration(), scope, function);
+        NamedFunctionDescriptor functionDescriptor = context.getDescriptorResolver().resolveFunctionDescriptor(scope.getContainingDeclaration(), scope, function);
         scope.addFunctionDescriptor(functionDescriptor);
         JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace);
         context.getServices().checkFunctionReturnType(functionInnerScope, function, functionDescriptor, context.dataFlowInfo);

compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java

@@ -74,7 +74,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
             List<JetDeclaration> declarations = aClass.getDeclarations();
             JetNamedFunction function = (JetNamedFunction) declarations.get(0);
-            FunctionDescriptorImpl functionDescriptor = descriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function);
+            NamedFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function);
 
             assertEquals(expectedFunctionModality, functionDescriptor.getModality());
         }

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

@@ -64,7 +64,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
         if (element instanceof JetNamedFunction) {
             JetNamedFunction jetFunction = (JetNamedFunction) element;
 
-            final FunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, jetFunction);
+            final NamedFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, jetFunction);
             if (functionDescriptor == null) return null;
             final Set<? extends FunctionDescriptor> overriddenFunctions = functionDescriptor.getOverriddenDescriptors();
             Icon icon = isMember(functionDescriptor) ? (overriddenFunctions.isEmpty() ? PlatformIcons.METHOD_ICON : OVERRIDING_FUNCTION) : PlatformIcons.FUNCTION_ICON;
@@ -182,7 +182,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
         );
     }
 
-    private boolean isMember(@NotNull FunctionDescriptor functionDescriptor) {
+    private boolean isMember(@NotNull NamedFunctionDescriptor functionDescriptor) {
         return functionDescriptor.getContainingDeclaration().getOriginal() instanceof ClassifierDescriptor;
     }
 

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

@@ -54,8 +54,8 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns
         }
         for (DescriptorClassMember selectedElement : selectedElements) {
             final DeclarationDescriptor descriptor = selectedElement.getDescriptor();
-            if (descriptor instanceof FunctionDescriptor) {
+            if (descriptor instanceof NamedFunctionDescriptor) {
-                JetElement target = overrideFunction(project, (FunctionDescriptor) descriptor);
+                JetElement target = overrideFunction(project, (NamedFunctionDescriptor) descriptor);
                 body.addBefore(target, body.getRBrace());
             }
             else if (descriptor instanceof PropertyDescriptor) {
@@ -84,7 +84,7 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns
         return JetPsiFactory.createProperty(project, bodyBuilder.toString());
     }
 
-    private static JetElement overrideFunction(Project project, FunctionDescriptor descriptor) {
+    private static JetElement overrideFunction(Project project, NamedFunctionDescriptor descriptor) {
         StringBuilder bodyBuilder = new StringBuilder("override fun ");
         bodyBuilder.append(descriptor.getName());
         bodyBuilder.append("(");