private static void highlightIncorrectArguments( ProblemsHolder holder, CallArgumentsMapping result, @NotNull TypeEvalContext context) { for (Map.Entry<PyExpression, EnumSet<CallArgumentsMapping.ArgFlag>> argEntry : result.getArgumentFlags().entrySet()) { EnumSet<CallArgumentsMapping.ArgFlag> flags = argEntry.getValue(); if (!flags.isEmpty()) { // something's wrong PyExpression arg = argEntry.getKey(); if (flags.contains(CallArgumentsMapping.ArgFlag.IS_DUP)) { holder.registerProblem(arg, PyBundle.message("INSP.duplicate.argument")); } if (flags.contains(CallArgumentsMapping.ArgFlag.IS_DUP_KWD)) { holder.registerProblem(arg, PyBundle.message("INSP.duplicate.doublestar.arg")); } if (flags.contains(CallArgumentsMapping.ArgFlag.IS_DUP_TUPLE)) { holder.registerProblem(arg, PyBundle.message("INSP.duplicate.star.arg")); } if (flags.contains(CallArgumentsMapping.ArgFlag.IS_POS_PAST_KWD)) { holder.registerProblem( arg, PyBundle.message("INSP.cannot.appear.past.keyword.arg"), ProblemHighlightType.ERROR); } if (flags.contains(CallArgumentsMapping.ArgFlag.IS_UNMAPPED)) { holder.registerProblem(arg, PyBundle.message("INSP.unexpected.arg")); } if (flags.contains(CallArgumentsMapping.ArgFlag.IS_TOO_LONG)) { final PyCallExpression.PyMarkedCallee markedCallee = result.getMarkedCallee(); String parameterName = null; if (markedCallee != null) { final List<PyParameter> parameters = PyUtil.getParameters(markedCallee.getCallable(), context); for (int i = parameters.size() - 1; i >= 0; --i) { final PyParameter param = parameters.get(i); if (param instanceof PyNamedParameter) { final List<PyNamedParameter> unmappedParams = result.getUnmappedParams(); if (!((PyNamedParameter) param).isPositionalContainer() && !((PyNamedParameter) param).isKeywordContainer() && param.getDefaultValue() == null && !unmappedParams.contains(param)) { parameterName = param.getName(); break; } } } holder.registerProblem( arg, parameterName != null ? PyBundle.message( "INSP.multiple.values.resolve.to.positional.$0", parameterName) : PyBundle.message("INSP.more.args.that.pos.params")); } } } } }
@Override public void visitPyDecoratorList(final PyDecoratorList node) { PyDecorator[] decorators = node.getDecorators(); for (PyDecorator deco : decorators) { if (deco.hasArgumentList()) continue; final PyCallExpression.PyMarkedCallee markedCallee = deco.resolveCallee(resolveWithoutImplicits()); if (markedCallee != null && !markedCallee.isImplicitlyResolved()) { final Callable callable = markedCallee.getCallable(); int firstParamOffset = markedCallee.getImplicitOffset(); final List<PyParameter> params = PyUtil.getParameters(callable, myTypeEvalContext); final PyNamedParameter allegedFirstParam = params.size() < firstParamOffset ? null : params.get(firstParamOffset - 1).getAsNamed(); if (allegedFirstParam == null || allegedFirstParam.isKeywordContainer()) { // no parameters left to pass function implicitly, or wrong param type registerProblem( deco, PyBundle.message( "INSP.func.$0.lacks.first.arg", callable.getName())); // TODO: better names for anon lambdas } else { // possible unfilled params for (int i = firstParamOffset; i < params.size(); i += 1) { final PyParameter parameter = params.get(i); if (parameter instanceof PySingleStarParameter) continue; final PyNamedParameter par = parameter.getAsNamed(); // param tuples, non-starred or non-default won't do if (par == null || (!par.isKeywordContainer() && !par.isPositionalContainer() && !par.hasDefaultValue())) { String parameterName = par != null ? par.getName() : "(...)"; registerProblem( deco, PyBundle.message("INSP.parameter.$0.unfilled", parameterName)); } } } } // else: this case is handled by arglist visitor } }
@Nullable @Override public PyType getCallType( @NotNull TypeEvalContext context, @NotNull PyCallSiteExpression callSite) { for (PyTypeProvider typeProvider : Extensions.getExtensions(PyTypeProvider.EP_NAME)) { final PyType type = typeProvider.getCallType(this, callSite, context); if (type != null) { type.assertValid(typeProvider.toString()); return type; } } final PyExpression receiver = PyTypeChecker.getReceiver(callSite, this); final List<PyExpression> arguments = PyTypeChecker.getArguments(callSite, this); final List<PyParameter> parameters = PyUtil.getParameters(this, context); final PyResolveContext resolveContext = PyResolveContext.noImplicits().withTypeEvalContext(context); final List<PyParameter> explicitParameters = PyTypeChecker.filterExplicitParameters(parameters, this, callSite, resolveContext); final Map<PyExpression, PyNamedParameter> mapping = PyCallExpressionHelper.mapArguments(arguments, explicitParameters); return getCallType(receiver, mapping, context); }