diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
index 53db17fe612..421fec69879 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+++ b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
@@ -32,6 +32,7 @@ public class JavaDescriptorResolver {
 
     protected final Map<String, ClassDescriptor> classDescriptorCache = new HashMap<String, ClassDescriptor>();
     protected final Map<PsiTypeParameter, TypeParameterDescriptor> typeParameterDescriptorCache = Maps.newHashMap();
+    protected final Map<PsiMethod, FunctionDescriptor> methodDescriptorCache = Maps.newHashMap();
     protected final Map<String, NamespaceDescriptor> namespaceDescriptorCache = new HashMap<String, NamespaceDescriptor>();
     protected final JavaPsiFacade javaFacade;
     protected final GlobalSearchScope javaSearchScope;
@@ -247,28 +248,34 @@ public class JavaDescriptorResolver {
         WritableFunctionGroup writableFunctionGroup = new WritableFunctionGroup(methodName);
         final Collection<HierarchicalMethodSignature> signatures = psiClass.getVisibleSignatures();
         for (HierarchicalMethodSignature signature: signatures) {
-            final PsiMethod method = signature.getMethod();
+            PsiMethod method = signature.getMethod();
             if (method.hasModifierProperty(PsiModifier.STATIC) != staticMembers) {
                 continue;
             }
             if (!methodName.equals(method.getName())) {
                  continue;
             }
-            final PsiParameter[] parameters = method.getParameterList().getParameters();
+            FunctionDescriptor functionDescriptor = methodDescriptorCache.get(method);
+            if (functionDescriptor != null) {
+                writableFunctionGroup.addFunction(functionDescriptor);
+                continue;
+            }
 
-            FunctionDescriptorImpl functionDescriptor = new FunctionDescriptorImpl(
+            PsiParameter[] parameters = method.getParameterList().getParameters();
+            FunctionDescriptorImpl functionDescriptorImpl = new FunctionDescriptorImpl(
                     JavaDescriptorResolver.JAVA_ROOT,
                     Collections.<Annotation>emptyList(), // TODO
                     methodName
             );
-            functionDescriptor.initialize(
+            functionDescriptorImpl.initialize(
                     null,
                     resolveTypeParameters(method.getTypeParameters()),
-                    semanticServices.getDescriptorResolver().resolveParameterDescriptors(functionDescriptor, parameters),
+                    semanticServices.getDescriptorResolver().resolveParameterDescriptors(functionDescriptorImpl, parameters),
                     semanticServices.getTypeTransformer().transformToType(method.getReturnType())
             );
-            semanticServices.getTrace().recordDeclarationResolution(method, functionDescriptor);
-            writableFunctionGroup.addFunction(functionDescriptor);
+            semanticServices.getTrace().recordDeclarationResolution(method, functionDescriptorImpl);
+            writableFunctionGroup.addFunction(functionDescriptorImpl);
+            methodDescriptorCache.put(method, functionDescriptorImpl);
         }
         return writableFunctionGroup;
     }
diff --git a/idea/testData/checker/regression/DoubleDefine.jet b/idea/testData/checker/regression/DoubleDefine.jet
new file mode 100644
index 00000000000..c622e1cdd10
--- /dev/null
+++ b/idea/testData/checker/regression/DoubleDefine.jet
@@ -0,0 +1,66 @@
+import java.*
+import util.*
+
+import java.io.*
+
+fun takeFirst(expr: StringBuilder): Char {
+  val c = expr.charAt(0)
+  expr.deleteCharAt(0)
+  return c
+}
+
+fun evaluateArg(expr: AbstractStringBuilder, numbers: ArrayList<Int>): Int {
+  if (expr.length() == 0) throw new Exception("Syntax error: Character expected");
+  val c = takeFirst<error>(expr)</error>
+  if (c <error>>=</error> '0' && c <error><=</error> '9') {
+    val n = c - '0'
+    if (!numbers.contains(n)) throw new Exception("You used incorrect number: " + n)
+    numbers.remove(n)
+    return n                                                                                                                                       \
+  }
+  throw new Exception("Syntax error: Unrecognized character " + c)
+}
+
+fun evaluateAdd(expr: StringBuilder, numbers: ArrayList<Int>): Int {
+  val lhs = evaluateArg(expr, numbers)
+  if (expr.length() > 0) {
+
+  }
+  return lhs
+}
+
+fun evaluate(expr: StringBuilder, numbers: ArrayList<Int>): Int {
+  val lhs = evaluateAdd(expr, numbers)
+  if (expr.length() > 0) {
+    val c = expr.charAt(0)
+    expr.deleteCharAt(0)
+  }
+  return lhs
+}
+
+fun main(args: Array<String>) {
+  System.out?.println("24 game")
+  val numbers = new ArrayList<Int>(4)
+  val rnd = new Random();
+  val prompt = new StringBuilder()
+  for(val i in 0..3) {
+    val n = rnd.nextInt(9) + 1
+    numbers.add(n)
+    if (i > 0) prompt.append(" ");
+    prompt.append(n)
+  }
+  System.out?.println("Your numbers: " + prompt)
+  System.out?.println("Enter your expression:")
+  val reader = new BufferedReader(new InputStreamReader(System.`in`))
+  val expr = new StringBuilder(reader.readLine())
+  try {
+    val result = evaluate(expr, numbers)
+    if (result != 24)
+      System.out?.println("Sorry, that's " + result)
+    else
+      System.out?.println("You won!");
+  }
+  catch(e: Throwable) {
+    System.out?.println(e.getMessage())
+  }
+}