protected final void writeParameters(Declaration decl) throws IOException {
if (decl instanceof Functional) {
boolean first = true;
List<ParameterList> parameterLists = ((Functional) decl).getParameterLists();
for (ParameterList parameterList : parameterLists) {
for (Parameter parameter : parameterList.getParameters()) {
String doc = getDoc(parameter, linkRenderer());
if (!doc.isEmpty()) {
if (first) {
first = false;
open("div class='parameters section'");
around("span class='title'", "Parameters: ");
open("ul");
}
open("li");
write(parameter.getName());
write(doc);
close("li");
}
}
}
if (!first) {
close("ul");
close("div");
}
}
}
public MethodDefinitionBuilder resultType(Method method, int flags) {
if (Decl.isMpl(method)) {
// Create a String with the TypeInfo
StringBuilder sb = new StringBuilder();
// It's a bunch of nested callables (# of param lists - 1)
for (int i = 1; i < method.getParameterLists().size(); i++) {
sb.append("ceylon.language::Callable<");
}
// Then the return type as defined originally
sb.append(method.getType().getProducedTypeQualifiedName());
// And then the parameter types of each nested callable
for (int i = method.getParameterLists().size() - 1; i > 0; i--) {
ParameterList plist = method.getParameterLists().get(i);
for (Parameter p : plist.getParameters()) {
sb.append(',');
sb.append(p.getType().getProducedTypeQualifiedName());
}
sb.append('>');
}
return resultType(
gen.makeAtType(sb.toString(), false),
gen.makeJavaType(gen.functionalReturnType(method), flags));
} else {
ProducedTypedReference typedRef = gen.getTypedReference(method);
ProducedTypedReference nonWideningTypedRef = gen.nonWideningTypeDecl(typedRef);
ProducedType nonWideningType = gen.nonWideningType(typedRef, nonWideningTypedRef);
return resultType(
makeResultType(nonWideningTypedRef.getDeclaration(), nonWideningType, flags), method);
}
}
public JCNewClass build() {
// Generate a subclass of Callable
ListBuffer<JCTree> classBody = new ListBuffer<JCTree>();
int numParams = paramLists.getParameters().size();
int minimumParams = 0;
for (Parameter p : paramLists.getParameters()) {
if (p.isDefaulted() || p.isSequenced()) break;
minimumParams++;
}
boolean isVariadic = minimumParams != numParams;
if (parameterListTree != null) {
// generate a method for each defaulted param
for (Tree.Parameter p : parameterListTree.getParameters()) {
if (p.getDefaultArgument() != null || p.getDeclarationModel().isSequenced()) {
MethodDefinitionBuilder methodBuilder =
gen.classGen().makeParamDefaultValueMethod(false, null, parameterListTree, p);
classBody.append(methodBuilder.build());
}
}
}
// collect each parameter type from the callable type model rather than the declarations to get
// them all bound
java.util.List<ProducedType> parameterTypes = new ArrayList<ProducedType>(numParams);
if (forwardCallTo != null) {
for (int i = 0; i < numParams; i++)
parameterTypes.add(gen.getParameterTypeOfCallable(typeModel, i));
} else {
// get them from our declaration
for (Parameter p : paramLists.getParameters()) parameterTypes.add(p.getType());
}
// now generate a method for each supported minimum number of parameters below 4
// which delegates to the $call$typed method if required
for (int i = minimumParams, max = Math.min(numParams, 4); i < max; i++) {
classBody.append(makeDefaultedCall(i, isVariadic, parameterTypes));
}
// generate the $call method for the max number of parameters,
// which delegates to the $call$typed method if required
classBody.append(makeDefaultedCall(numParams, isVariadic, parameterTypes));
// generate the $call$typed method if required
if (isVariadic && forwardCallTo == null)
classBody.append(makeCallTypedMethod(body, parameterTypes));
JCClassDecl classDef =
gen.make().AnonymousClassDef(gen.make().Modifiers(0), classBody.toList());
JCNewClass instance =
gen.make()
.NewClass(
null,
null,
gen.makeJavaType(typeModel, JT_EXTENDS | JT_CLASS_NEW),
List.<JCExpression>of(gen.make().Literal(typeModel.getProducedTypeName(true))),
classDef);
return instance;
}
protected final void writeParameterList(Functional f) throws IOException {
for (ParameterList lists : f.getParameterLists()) {
write("(");
boolean first = true;
for (Parameter param : lists.getParameters()) {
if (!first) {
write(", ");
} else {
first = false;
}
if (param instanceof FunctionalParameter) {
writeFunctionalParameter((FunctionalParameter) param);
} else if (param.isSequenced()) {
writeSequencedParameter(param);
} else {
linkRenderer().to(param.getType()).write();
write(" ", param.getName());
}
}
write(")");
}
}
private JCExpression makeDefaultValueCall(Parameter defaultedParam, int i) {
// add the default value
List<JCExpression> defaultMethodArgs = List.nil();
// pass all the previous values
for (int a = i - 1; a >= 0; a--) {
Parameter param = paramLists.getParameters().get(a);
JCExpression previousValue = gen.makeUnquotedIdent(getCallableTempVarName(param));
defaultMethodArgs = defaultMethodArgs.prepend(previousValue);
}
// now call the default value method
return gen.make()
.Apply(
null,
gen.makeUnquotedIdent(Naming.getDefaultedParamMethodName(null, defaultedParam)),
defaultMethodArgs);
}
private JCTree makeCallTypedMethod(
List<JCStatement> body, java.util.List<ProducedType> parameterTypes) {
// make the method
MethodDefinitionBuilder methodBuilder =
MethodDefinitionBuilder.method(gen, false, Naming.getCallableTypedMethodName());
methodBuilder.modifiers(Flags.PRIVATE);
ProducedType returnType = gen.getReturnTypeOfCallable(typeModel);
methodBuilder.resultType(gen.makeJavaType(returnType, JT_NO_PRIMITIVES), null);
// add all parameters
int i = 0;
for (Parameter param : paramLists.getParameters()) {
ParameterDefinitionBuilder parameterBuilder =
ParameterDefinitionBuilder.instance(gen, param.getName());
JCExpression paramType = gen.makeJavaType(parameterTypes.get(i));
parameterBuilder.type(paramType, null);
methodBuilder.parameter(parameterBuilder);
i++;
}
// Return the call result, or null if a void method
methodBuilder.body(body);
return methodBuilder.build();
}
private JCTree makeDefaultedCall(
int i, boolean isVariadic, java.util.List<ProducedType> parameterTypes) {
// collect every parameter
int a = 0;
ListBuffer<JCStatement> stmts = new ListBuffer<JCStatement>();
for (Parameter param : paramLists.getParameters()) {
// don't read default parameter values for forwarded calls
if (forwardCallTo != null && i == a) break;
// read the value
JCExpression paramExpression = getTypedParameter(param, a, i > 3, parameterTypes);
JCExpression varInitialExpression;
if (param.isDefaulted() || param.isSequenced()) {
if (i > 3) {
// must check if it's defined
JCExpression test =
gen.make()
.Binary(JCTree.GT, gen.makeSelect(getParamName(0), "length"), gen.makeInteger(a));
JCExpression elseBranch = makeDefaultValueCall(param, a);
varInitialExpression = gen.make().Conditional(test, paramExpression, elseBranch);
} else if (a >= i) {
// get its default value because we don't have it
varInitialExpression = makeDefaultValueCall(param, a);
} else {
// we must have it
varInitialExpression = paramExpression;
}
} else {
varInitialExpression = paramExpression;
}
// store it in a local var
JCStatement var =
gen.make()
.VarDef(
gen.make().Modifiers(Flags.FINAL),
gen.naming.makeUnquotedName(getCallableTempVarName(param)),
gen.makeJavaType(
parameterTypes.get(a),
CodegenUtil.isUnBoxed(param) ? 0 : gen.JT_NO_PRIMITIVES),
varInitialExpression);
stmts.append(var);
a++;
}
if (forwardCallTo != null) {
InvocationBuilder invocationBuilder =
InvocationBuilder.forCallableInvocation(gen, forwardCallTo, paramLists, i);
boolean prevCallableInv = gen.expressionGen().withinCallableInvocation(true);
try {
stmts.append(gen.make().Return(invocationBuilder.build()));
} finally {
gen.expressionGen().withinCallableInvocation(prevCallableInv);
}
} else if (isVariadic) {
// chain to n param typed method
List<JCExpression> args = List.nil();
// pass along the parameters
for (a = paramLists.getParameters().size() - 1; a >= 0; a--) {
Parameter param = paramLists.getParameters().get(a);
args = args.prepend(gen.makeUnquotedIdent(getCallableTempVarName(param)));
}
JCMethodInvocation chain =
gen.make().Apply(null, gen.makeUnquotedIdent(Naming.getCallableTypedMethodName()), args);
stmts.append(gen.make().Return(chain));
} else {
// insert the method body directly
stmts.appendList(this.body);
}
List<JCStatement> body = stmts.toList();
return makeCallMethod(body, i);
}