Avoid throwing unchecked exceptions

Make `ResolvedCall.getValueArgumentsByIndex` return null instead of
throwing an InvalidStateException when resolving invalid arguments.
Invalid arguments are a user error (the user specified the invalid
arguments in their code), not a program error.

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

@@ -1927,7 +1927,11 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             ResolvedCall<? extends CallableDescriptor> resolvedCall,
             JavaClassDescriptor samInterface
     ) {
-        ResolvedValueArgument argument = resolvedCall.getValueArgumentsByIndex().get(0);
+        List<ResolvedValueArgument> arguments = resolvedCall.getValueArgumentsByIndex();
+        if (arguments == null) {
+            throw new IllegalStateException("Failed to arrange value arguments by index");
+        }
+        ResolvedValueArgument argument = arguments.get(0);
         if (!(argument instanceof ExpressionValueArgument)) {
             throw new IllegalStateException(
                     "argument of SAM constructor is " + argument.getClass().getName() + " " + expression.getText());
@@ -2321,6 +2325,9 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     private int pushMethodArguments(@NotNull ResolvedCall resolvedCall, List<Type> valueParameterTypes, boolean skipLast, @NotNull CallGenerator callGenerator) {
         @SuppressWarnings("unchecked")
         List<ResolvedValueArgument> valueArguments = resolvedCall.getValueArgumentsByIndex();
+        if (valueArguments == null) {
+            throw new IllegalStateException("Failed to arrange value arguments by index");
+        }
         CallableDescriptor fd = resolvedCall.getResultingDescriptor();
         List<ValueParameterDescriptor> valueParameters = fd.getValueParameters();
 

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

@@ -69,7 +69,11 @@ public class TailRecursionCodegen {
         assert fd instanceof FunctionDescriptor : "the resolved call is not refer to the function descriptor so why do we use generateTailRecursion for something strange?";
         CallableMethod callable = (CallableMethod) codegen.resolveToCallable((FunctionDescriptor) fd, false);
 
-        assignParameterValues(fd, callable, resolvedCall.getValueArgumentsByIndex());
+        List<ResolvedValueArgument> arguments = resolvedCall.getValueArgumentsByIndex();
+        if (arguments == null) {
+            throw new IllegalStateException("Failed to arrange value arguments by index");
+        }
+        assignParameterValues(fd, callable, arguments);
         if (callable.getReceiverClass() != null) {
             if (resolvedCall.getReceiverArgument() != fd.getReceiverParameter().getValue()) {
                 StackValue expression = context.getReceiverExpression(codegen.typeMapper);

compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java

@@ -421,6 +421,9 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
             return;
         }
         List<ResolvedValueArgument> valueArguments = call.getValueArgumentsByIndex();
+        if (valueArguments == null) {
+            throw new IllegalStateException("Failed to arrange value arguments by index");
+        }
         for (ValueParameterDescriptor valueParameter : original.getValueParameters()) {
             JavaClassDescriptor samInterface = getInterfaceIfSamType(valueParameter.getType());
             if (samInterface == null) {

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

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.lang.resolve.calls.model;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
@@ -70,7 +71,7 @@ public abstract class DelegatingResolvedCall<D extends CallableDescriptor> imple
         return resolvedCall.getValueArguments();
     }
 
-    @NotNull
+    @Nullable
     @Override
     public List<ResolvedValueArgument> getValueArgumentsByIndex() {
         return resolvedCall.getValueArgumentsByIndex();

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

@@ -56,7 +56,7 @@ public interface ResolvedCall<D extends CallableDescriptor> {
     Map<ValueParameterDescriptor, ResolvedValueArgument> getValueArguments();
 
     /** Values (arguments) for value parameters indexed by parameter index */
-    @NotNull
+    @Nullable
     List<ResolvedValueArgument> getValueArgumentsByIndex();
 
     /** What's substituted for type parameters */

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

@@ -229,7 +229,7 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
         return valueArguments;
     }
 
-    @NotNull
+    @Nullable
     @Override
     public List<ResolvedValueArgument> getValueArgumentsByIndex() {
         List<ResolvedValueArgument> arguments = new ArrayList<ResolvedValueArgument>(candidateDescriptor.getValueParameters().size());
@@ -242,16 +242,14 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
             ResolvedValueArgument value = entry.getValue();
             ResolvedValueArgument oldValue = arguments.set(parameterDescriptor.getIndex(), value);
             if (oldValue != null) {
-                throw new IllegalStateException("Argument set twice for " + parameterDescriptor + "\n" +
-                                                "old value: " + oldValue + "\n" +
-                                                "new value: " + value);
+                return null;
             }
         }
 
         for (int i = 0; i < arguments.size(); i++) {
             Object o = arguments.get(i);
             if (o == null) {
-                throw new IllegalStateException("No argument for " + getCandidateDescriptor().getValueParameters().get(i));
+                return null;
             }
         }
         

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

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.lang.resolve.calls.model;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
@@ -86,7 +87,7 @@ public class VariableAsFunctionResolvedCall implements ResolvedCallWithTrace<Fun
         return functionCall.getValueArguments();
     }
 
-    @NotNull
+    @Nullable
     @Override
     public List<ResolvedValueArgument> getValueArgumentsByIndex() {
         return functionCall.getValueArgumentsByIndex();

js/js.translator/src/org/jetbrains/k2js/translate/reference/ArrayAccessTranslator.java

@@ -99,6 +99,9 @@ public class ArrayAccessTranslator extends AbstractTranslator implements AccessT
                 BindingUtils.getResolvedCallForArrayAccess(bindingContext(), expression,  /*isGetter = */ false);
 
         List<ResolvedValueArgument> arguments = resolvedCall.getValueArgumentsByIndex();
+        if (arguments == null) {
+            throw new IllegalStateException("Failed to arrange value arguments by index");
+        }
         ResolvedValueArgument lastArgument = arguments.get(arguments.size() - 1);
         assert lastArgument instanceof ExpressionValueArgument: "Last argument of array-like setter must be ExpressionValueArgument";
 

js/js.translator/src/org/jetbrains/k2js/translate/reference/CallArgumentTranslator.java

@@ -159,6 +159,9 @@ public class CallArgumentTranslator extends AbstractTranslator {
 
         List<JsExpression> result = new ArrayList<JsExpression>(valueParameters.size());
         List<ResolvedValueArgument> valueArgumentsByIndex = resolvedCall.getValueArgumentsByIndex();
+        if (valueArgumentsByIndex == null) {
+            throw new IllegalStateException("Failed to arrange value arguments by index");
+        }
         List<JsExpression> argsBeforeVararg = null;
         for (ValueParameterDescriptor parameterDescriptor : valueParameters) {
             ResolvedValueArgument actualArgument = valueArgumentsByIndex.get(parameterDescriptor.getIndex());

js/js.translator/src/org/jetbrains/k2js/translate/reference/InlinedCallExpressionTranslator.java

@@ -148,7 +148,11 @@ public final class InlinedCallExpressionTranslator extends AbstractCallExpressio
 
     @NotNull
     private TemporaryVariable createAliasForArgument(@NotNull ValueParameterDescriptor parameterDescriptor) {
-        ResolvedValueArgument actualArgument = resolvedCall.getValueArgumentsByIndex().get(parameterDescriptor.getIndex());
+        List<ResolvedValueArgument> actualArguments = resolvedCall.getValueArgumentsByIndex();
+        if (actualArguments == null) {
+            throw new IllegalStateException("Failed to arrange value arguments by index");
+        }
+        ResolvedValueArgument actualArgument = actualArguments.get(parameterDescriptor.getIndex());
         JsExpression translatedArgument = translateArgument(actualArgument);
         TemporaryVariable aliasForArgument = context().declareTemporary(translatedArgument);
         context().addStatementToCurrentBlock(aliasForArgument.assignmentExpression().makeStmt());